• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include <string>
6 
7 #include "base/strings/string16.h"
8 #include "base/strings/utf_string_conversions.h"
9 #include "components/autofill/core/browser/address.h"
10 #include "components/autofill/core/browser/autofill_type.h"
11 #include "testing/gtest/include/gtest/gtest.h"
12 
13 using base::ASCIIToUTF16;
14 
15 namespace autofill {
16 
17 // Test that country data can be properly returned as either a country code or a
18 // localized country name.
TEST(AddressTest,GetCountry)19 TEST(AddressTest, GetCountry) {
20   Address address;
21   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
22 
23   // Make sure that nothing breaks when the country code is missing.
24   base::string16 country =
25       address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
26   EXPECT_EQ(base::string16(), country);
27 
28   address.SetInfo(
29       AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("US"), "en-US");
30   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
31   EXPECT_EQ(ASCIIToUTF16("United States"), country);
32   country = address.GetInfo(
33       AutofillType(HTML_TYPE_COUNTRY_NAME, HTML_MODE_NONE), "en-US");
34   EXPECT_EQ(ASCIIToUTF16("United States"), country);
35   country = address.GetInfo(
36       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE), "en-US");
37   EXPECT_EQ(ASCIIToUTF16("US"), country);
38 
39   address.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("CA"));
40   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
41   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
42   country = address.GetInfo(
43       AutofillType(HTML_TYPE_COUNTRY_NAME, HTML_MODE_NONE), "en-US");
44   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
45   country = address.GetInfo(
46       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE), "en-US");
47   EXPECT_EQ(ASCIIToUTF16("CA"), country);
48 }
49 
50 // Test that we properly detect country codes appropriate for each country.
TEST(AddressTest,SetCountry)51 TEST(AddressTest, SetCountry) {
52   Address address;
53   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
54 
55   // Test basic conversion.
56   address.SetInfo(
57       AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("United States"),
58       "en-US");
59   base::string16 country =
60       address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
61   EXPECT_EQ(ASCIIToUTF16("US"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
62   EXPECT_EQ(ASCIIToUTF16("United States"), country);
63 
64   // Test basic synonym detection.
65   address.SetInfo(
66       AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("USA"), "en-US");
67   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
68   EXPECT_EQ(ASCIIToUTF16("US"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
69   EXPECT_EQ(ASCIIToUTF16("United States"), country);
70 
71   // Test case-insensitivity.
72   address.SetInfo(
73       AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("canADA"), "en-US");
74   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
75   EXPECT_EQ(ASCIIToUTF16("CA"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
76   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
77 
78   // Test country code detection.
79   address.SetInfo(
80       AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("JP"), "en-US");
81   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
82   EXPECT_EQ(ASCIIToUTF16("JP"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
83   EXPECT_EQ(ASCIIToUTF16("Japan"), country);
84 
85   // Test that we ignore unknown countries.
86   address.SetInfo(
87       AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("Unknown"), "en-US");
88   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
89   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
90   EXPECT_EQ(base::string16(), country);
91 
92   // Test setting the country based on an HTML field type.
93   AutofillType html_type_country_code =
94       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE);
95   address.SetInfo(html_type_country_code, ASCIIToUTF16("US"), "en-US");
96   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
97   EXPECT_EQ(ASCIIToUTF16("US"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
98   EXPECT_EQ(ASCIIToUTF16("United States"), country);
99 
100   // Test case-insensitivity when setting the country based on an HTML field
101   // type.
102   address.SetInfo(html_type_country_code, ASCIIToUTF16("cA"), "en-US");
103   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
104   EXPECT_EQ(ASCIIToUTF16("CA"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
105   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
106 
107   // Test setting the country based on invalid data with an HTML field type.
108   address.SetInfo(html_type_country_code, ASCIIToUTF16("unknown"), "en-US");
109   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
110   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
111   EXPECT_EQ(base::string16(), country);
112 }
113 
114 // Test that we properly match typed values to stored country data.
TEST(AddressTest,IsCountry)115 TEST(AddressTest, IsCountry) {
116   Address address;
117   address.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
118 
119   const char* const kValidMatches[] = {
120     "United States",
121     "USA",
122     "US",
123     "United states",
124     "us"
125   };
126   for (size_t i = 0; i < arraysize(kValidMatches); ++i) {
127     SCOPED_TRACE(kValidMatches[i]);
128     ServerFieldTypeSet matching_types;
129     address.GetMatchingTypes(ASCIIToUTF16(kValidMatches[i]), "US",
130                              &matching_types);
131     ASSERT_EQ(1U, matching_types.size());
132     EXPECT_EQ(ADDRESS_HOME_COUNTRY, *matching_types.begin());
133   }
134 
135   const char* const kInvalidMatches[] = {
136     "United",
137     "Garbage"
138   };
139   for (size_t i = 0; i < arraysize(kInvalidMatches); ++i) {
140     ServerFieldTypeSet matching_types;
141     address.GetMatchingTypes(ASCIIToUTF16(kInvalidMatches[i]), "US",
142                              &matching_types);
143     EXPECT_EQ(0U, matching_types.size());
144   }
145 
146   // Make sure that garbage values don't match when the country code is empty.
147   address.SetRawInfo(ADDRESS_HOME_COUNTRY, base::string16());
148   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
149   ServerFieldTypeSet matching_types;
150   address.GetMatchingTypes(ASCIIToUTF16("Garbage"), "US", &matching_types);
151   EXPECT_EQ(0U, matching_types.size());
152 }
153 
154 // Verifies that Address::GetInfo() correctly combines address lines.
TEST(AddressTest,GetStreetAddress)155 TEST(AddressTest, GetStreetAddress) {
156   const AutofillType type = AutofillType(ADDRESS_HOME_STREET_ADDRESS);
157 
158   // Address has no address lines.
159   Address address;
160   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
161   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
162   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
163   EXPECT_EQ(base::string16(), address.GetInfo(type, "en-US"));
164 
165   // Address has only line 1.
166   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
167   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
168   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
169   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
170   EXPECT_EQ(ASCIIToUTF16("123 Example Ave."), address.GetInfo(type, "en-US"));
171 
172   // Address has only line 2.
173   address.SetRawInfo(ADDRESS_HOME_LINE1, base::string16());
174   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt 42."));
175   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
176   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
177   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
178   EXPECT_EQ(ASCIIToUTF16("\nApt 42."), address.GetInfo(type, "en-US"));
179 
180   // Address has lines 1 and 2.
181   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
182   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
183   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
184   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
185   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
186   EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
187                          "Apt. 42"),
188             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
189   EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
190                          "Apt. 42"),
191             address.GetInfo(type, "en-US"));
192 
193   // A wild third line appears.
194   address.SetRawInfo(ADDRESS_HOME_LINE3, ASCIIToUTF16("Living room couch"));
195   EXPECT_EQ(ASCIIToUTF16("Living room couch"),
196             address.GetRawInfo(ADDRESS_HOME_LINE3));
197   EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
198                          "Apt. 42\n"
199                          "Living room couch"),
200             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
201 
202   // The second line vanishes.
203   address.SetRawInfo(ADDRESS_HOME_LINE2, base::string16());
204   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
205   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
206   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
207   EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
208                          "\n"
209                          "Living room couch"),
210             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
211 }
212 
213 // Verifies that overwriting an address with N lines with one that has fewer
214 // than N lines does not result in an address with blank lines at the end.
TEST(AddressTest,GetStreetAddressAfterOverwritingLongAddressWithShorterOne)215 TEST(AddressTest, GetStreetAddressAfterOverwritingLongAddressWithShorterOne) {
216   // Start with an address that has two lines.
217   Address address;
218   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
219   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
220 
221   // Now clear out the second address line.
222   address.SetRawInfo(ADDRESS_HOME_LINE2, base::string16());
223   EXPECT_EQ(ASCIIToUTF16("123 Example Ave."),
224             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
225 
226   // Now clear out the first address line as well.
227   address.SetRawInfo(ADDRESS_HOME_LINE1, base::string16());
228   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
229 }
230 
231 // Verifies that Address::SetRawInfo() is able to split address lines correctly.
TEST(AddressTest,SetRawStreetAddress)232 TEST(AddressTest, SetRawStreetAddress) {
233   const base::string16 empty_street_address;
234   const base::string16 short_street_address = ASCIIToUTF16("456 Nowhere Ln.");
235   const base::string16 long_street_address =
236       ASCIIToUTF16("123 Example Ave.\n"
237                    "Apt. 42\n"
238                    "(The one with the blue door)");
239 
240   Address address;
241   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
242   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
243 
244   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, long_street_address);
245   EXPECT_EQ(ASCIIToUTF16("123 Example Ave."),
246             address.GetRawInfo(ADDRESS_HOME_LINE1));
247   EXPECT_EQ(ASCIIToUTF16("Apt. 42"), address.GetRawInfo(ADDRESS_HOME_LINE2));
248   EXPECT_EQ(long_street_address,
249             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
250 
251   // A short address should clear out unused address lines.
252   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, short_street_address);
253   EXPECT_EQ(ASCIIToUTF16("456 Nowhere Ln."),
254             address.GetRawInfo(ADDRESS_HOME_LINE1));
255   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
256 
257   // An empty address should clear out all address lines.
258   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, long_street_address);
259   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, empty_street_address);
260   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
261   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
262 }
263 
264 // Verifies that Address::SetInfo() rejects setting data for
265 // ADDRESS_HOME_STREET_ADDRESS without newlines, as there is no good general way
266 // to parse that data into the consituent address lines. Addresses without
267 // newlines should be set properly.
TEST(AddressTest,SetStreetAddress)268 TEST(AddressTest, SetStreetAddress) {
269   const base::string16 empty_street_address;
270   const base::string16 one_line_street_address =
271       ASCIIToUTF16("456 New St., Apt. 17");
272   const base::string16 multi_line_street_address =
273       ASCIIToUTF16("789 Fancy Pkwy.\n"
274                    "Unit 3.14\n"
275                    "Box 9");
276   const AutofillType type = AutofillType(ADDRESS_HOME_STREET_ADDRESS);
277 
278   // Start with a non-empty address.
279   Address address;
280   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
281   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
282   address.SetRawInfo(ADDRESS_HOME_LINE3, ASCIIToUTF16("and a half"));
283   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
284   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
285   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
286 
287   // Attempting to set a one-line address should fail, as the single line might
288   // actually represent multiple logical lines, combined into one due to the
289   // user having to work around constraints imposed by the website.
290   EXPECT_FALSE(address.SetInfo(type, one_line_street_address, "en-US"));
291   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
292   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
293   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE3));
294 
295   // Attempting to set a multi-line address should succeed.
296   EXPECT_TRUE(address.SetInfo(type, multi_line_street_address, "en-US"));
297   EXPECT_EQ(ASCIIToUTF16("789 Fancy Pkwy."),
298             address.GetRawInfo(ADDRESS_HOME_LINE1));
299   EXPECT_EQ(ASCIIToUTF16("Unit 3.14"), address.GetRawInfo(ADDRESS_HOME_LINE2));
300   EXPECT_EQ(ASCIIToUTF16("Box 9"), address.GetRawInfo(ADDRESS_HOME_LINE3));
301 
302   // Attempting to set an empty address should also succeed, and clear out the
303   // previously stored data.
304   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
305   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
306   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
307   EXPECT_TRUE(address.SetInfo(type, empty_street_address, "en-US"));
308   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
309   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
310   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE3));
311 }
312 
313 // Verifies that Address::SetInfio() rejects setting data for
314 // ADDRESS_HOME_STREET_ADDRESS if the data has any interior blank lines.
TEST(AddressTest,SetStreetAddressRejectsAddressesWithInteriorBlankLines)315 TEST(AddressTest, SetStreetAddressRejectsAddressesWithInteriorBlankLines) {
316   // Start with a non-empty address.
317   Address address;
318   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
319   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
320   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
321   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
322   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
323 
324   // Attempting to set an address with interior blank lines should fail, and
325   // clear out the previously stored address.
326   EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
327                                ASCIIToUTF16("Address line 1\n"
328                                             "\n"
329                                             "Address line 3"),
330                                "en-US"));
331   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
332   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
333   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
334 }
335 
336 // Verifies that Address::SetInfio() rejects setting data for
337 // ADDRESS_HOME_STREET_ADDRESS if the data has any leading blank lines.
TEST(AddressTest,SetStreetAddressRejectsAddressesWithLeadingBlankLines)338 TEST(AddressTest, SetStreetAddressRejectsAddressesWithLeadingBlankLines) {
339   // Start with a non-empty address.
340   Address address;
341   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
342   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
343   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
344   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
345   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
346 
347   // Attempting to set an address with leading blank lines should fail, and
348   // clear out the previously stored address.
349   EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
350                                ASCIIToUTF16("\n"
351                                             "Address line 2"
352                                             "Address line 3"),
353                                "en-US"));
354   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
355   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
356   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
357 }
358 
359 // Verifies that Address::SetInfio() rejects setting data for
360 // ADDRESS_HOME_STREET_ADDRESS if the data has any trailing blank lines.
TEST(AddressTest,SetStreetAddressRejectsAddressesWithTrailingBlankLines)361 TEST(AddressTest, SetStreetAddressRejectsAddressesWithTrailingBlankLines) {
362   // Start with a non-empty address.
363   Address address;
364   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
365   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
366   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
367   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
368   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
369 
370   // Attempting to set an address with leading blank lines should fail, and
371   // clear out the previously stored address.
372   EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
373                                ASCIIToUTF16("Address line 1"
374                                             "Address line 2"
375                                             "\n"),
376                                "en-US"));
377   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
378   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
379   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
380 }
381 
382 }  // namespace autofill
383