address_unittest.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
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
13using base::ASCIIToUTF16;
14
15namespace autofill {
16
17// Test that country data can be properly returned as either a country code or a
18// localized country name.
19TEST(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.
51TEST(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.
115TEST(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.
155TEST(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_EQ(base::string16(), address.GetInfo(type, "en-US"));
163
164  // Address has only line 1.
165  address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
166  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
167  EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
168  EXPECT_EQ(ASCIIToUTF16("123 Example Ave."), address.GetInfo(type, "en-US"));
169
170  // Address has only line 2.
171  address.SetRawInfo(ADDRESS_HOME_LINE1, base::string16());
172  address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt 42."));
173  EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
174  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
175  EXPECT_EQ(ASCIIToUTF16("\nApt 42."), address.GetInfo(type, "en-US"));
176
177  // Address has lines 1 and 2.
178  address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
179  address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
180  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
181  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
182  EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
183                         "Apt. 42"),
184            address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
185  EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
186                         "Apt. 42"),
187            address.GetInfo(type, "en-US"));
188}
189
190// Verifies that overwriting an address with N lines with one that has fewer
191// than N lines does not result in an address with blank lines at the end.
192TEST(AddressTest, GetStreetAddressAfterOverwritingLongAddressWithShorterOne) {
193  // Start with an address that has two lines.
194  Address address;
195  address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
196  address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
197
198  // Now clear out the second address line.
199  address.SetRawInfo(ADDRESS_HOME_LINE2, base::string16());
200  EXPECT_EQ(ASCIIToUTF16("123 Example Ave."),
201            address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
202
203  // Now clear out the first address line as well.
204  address.SetRawInfo(ADDRESS_HOME_LINE1, base::string16());
205  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
206}
207
208// Verifies that Address::SetRawInfo() is able to split address lines correctly.
209TEST(AddressTest, SetRawStreetAddress) {
210  const base::string16 empty_street_address;
211  const base::string16 short_street_address = ASCIIToUTF16("456 Nowhere Ln.");
212  const base::string16 long_street_address =
213      ASCIIToUTF16("123 Example Ave.\n"
214                   "Apt. 42\n"
215                   "(The one with the blue door)");
216
217  Address address;
218  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
219  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
220
221  address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, long_street_address);
222  EXPECT_EQ(ASCIIToUTF16("123 Example Ave."),
223            address.GetRawInfo(ADDRESS_HOME_LINE1));
224  EXPECT_EQ(ASCIIToUTF16("Apt. 42"), address.GetRawInfo(ADDRESS_HOME_LINE2));
225  EXPECT_EQ(long_street_address,
226            address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
227
228  // A short address should clear out unused address lines.
229  address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, short_street_address);
230  EXPECT_EQ(ASCIIToUTF16("456 Nowhere Ln."),
231            address.GetRawInfo(ADDRESS_HOME_LINE1));
232  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
233
234  // An empty address should clear out all address lines.
235  address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, long_street_address);
236  address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, empty_street_address);
237  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
238  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
239}
240
241// Verifies that Address::SetInfo() rejects setting data for
242// ADDRESS_HOME_STREET_ADDRESS without newlines, as there is no good general way
243// to parse that data into the consituent address lines. Addresses without
244// newlines should be set properly.
245TEST(AddressTest, SetStreetAddress) {
246  const base::string16 empty_street_address;
247  const base::string16 one_line_street_address =
248      ASCIIToUTF16("456 New St., Apt. 17");
249  const base::string16 multi_line_street_address =
250      ASCIIToUTF16("789 Fancy Pkwy.\n"
251                   "Unit 3.14");
252  const AutofillType type = AutofillType(ADDRESS_HOME_STREET_ADDRESS);
253
254  // Start with a non-empty address.
255  Address address;
256  address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
257  address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
258  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
259  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
260
261  // Attempting to set a one-line address should fail, as the single line might
262  // actually represent multiple logical lines, combined into one due to the
263  // user having to work around constraints imposed by the website.
264  EXPECT_FALSE(address.SetInfo(type, one_line_street_address, "en-US"));
265  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
266  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
267
268  // Attempting to set a multi-line address should succeed.
269  EXPECT_TRUE(address.SetInfo(type, multi_line_street_address, "en-US"));
270  EXPECT_EQ(ASCIIToUTF16("789 Fancy Pkwy."),
271            address.GetRawInfo(ADDRESS_HOME_LINE1));
272  EXPECT_EQ(ASCIIToUTF16("Unit 3.14"), address.GetRawInfo(ADDRESS_HOME_LINE2));
273
274  // Attempting to set an empty address should also succeed, and clear out the
275  // previously stored data.
276  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
277  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
278  EXPECT_TRUE(address.SetInfo(type, empty_street_address, "en-US"));
279  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
280  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
281}
282
283// Verifies that Address::SetInfio() rejects setting data for
284// ADDRESS_HOME_STREET_ADDRESS if the data has any interior blank lines.
285TEST(AddressTest, SetStreetAddressRejectsAddressesWithInteriorBlankLines) {
286  // Start with a non-empty address.
287  Address address;
288  address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
289  address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
290  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
291  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
292  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
293
294  // Attempting to set an address with interior blank lines should fail, and
295  // clear out the previously stored address.
296  EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
297                               ASCIIToUTF16("Address line 1\n"
298                                            "\n"
299                                            "Address line 3"),
300                               "en-US"));
301  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
302  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
303  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
304}
305
306// Verifies that Address::SetInfio() rejects setting data for
307// ADDRESS_HOME_STREET_ADDRESS if the data has any leading blank lines.
308TEST(AddressTest, SetStreetAddressRejectsAddressesWithLeadingBlankLines) {
309  // Start with a non-empty address.
310  Address address;
311  address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
312  address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
313  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
314  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
315  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
316
317  // Attempting to set an address with leading blank lines should fail, and
318  // clear out the previously stored address.
319  EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
320                               ASCIIToUTF16("\n"
321                                            "Address line 2"
322                                            "Address line 3"),
323                               "en-US"));
324  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
325  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
326  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
327}
328
329// Verifies that Address::SetInfio() rejects setting data for
330// ADDRESS_HOME_STREET_ADDRESS if the data has any trailing blank lines.
331TEST(AddressTest, SetStreetAddressRejectsAddressesWithTrailingBlankLines) {
332  // Start with a non-empty address.
333  Address address;
334  address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
335  address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
336  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
337  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
338  EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
339
340  // Attempting to set an address with leading blank lines should fail, and
341  // clear out the previously stored address.
342  EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
343                               ASCIIToUTF16("Address line 1"
344                                            "Address line 2"
345                                            "\n"),
346                               "en-US"));
347  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
348  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
349  EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
350}
351
352}  // namespace autofill
353