autofill_field_unittest.cc revision 1e9bf3e0803691d0a228da41fc608347b6db4340 
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 "base/format_macros.h"
6#include "base/strings/string_util.h"
7#include "base/strings/stringprintf.h"
8#include "base/strings/utf_string_conversions.h"
9#include "components/autofill/core/browser/autofill_field.h"
10#include "components/autofill/core/browser/autofill_type.h"
11#include "components/autofill/core/browser/field_types.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14namespace autofill {
15namespace {
16
17// Returns a FormFieldData object corresponding to a <select> field populated
18// with the given |options|.
19FormFieldData GenerateSelectFieldWithOptions(const char* const* options,
20                                             size_t options_size) {
21  std::vector<base::string16> options16(options_size);
22  for (size_t i = 0; i < options_size; ++i) {
23    options16[i] = ASCIIToUTF16(options[i]);
24  }
25
26  FormFieldData form_field;
27  form_field.form_control_type = "select-one";
28  form_field.option_values = options16;
29  form_field.option_contents = options16;
30  return form_field;
31}
32
33TEST(AutofillFieldTest, Type) {
34  AutofillField field;
35  ASSERT_EQ(NO_SERVER_DATA, field.server_type());
36  ASSERT_EQ(UNKNOWN_TYPE, field.heuristic_type());
37
38  // |server_type_| is NO_SERVER_DATA, so |heuristic_type_| is returned.
39  EXPECT_EQ(UNKNOWN_TYPE, field.Type().GetStorableType());
40
41  // Set the heuristic type and check it.
42  field.set_heuristic_type(NAME_FIRST);
43  EXPECT_EQ(NAME_FIRST, field.Type().GetStorableType());
44  EXPECT_EQ(NAME, field.Type().group());
45
46  // Set the server type and check it.
47  field.set_server_type(ADDRESS_BILLING_LINE1);
48  EXPECT_EQ(ADDRESS_HOME_LINE1, field.Type().GetStorableType());
49  EXPECT_EQ(ADDRESS_BILLING, field.Type().group());
50
51  // Remove the server type to make sure the heuristic type is preserved.
52  field.set_server_type(NO_SERVER_DATA);
53  EXPECT_EQ(NAME_FIRST, field.Type().GetStorableType());
54  EXPECT_EQ(NAME, field.Type().group());
55}
56
57TEST(AutofillFieldTest, IsEmpty) {
58  AutofillField field;
59  ASSERT_EQ(base::string16(), field.value);
60
61  // Field value is empty.
62  EXPECT_TRUE(field.IsEmpty());
63
64  // Field value is non-empty.
65  field.value = ASCIIToUTF16("Value");
66  EXPECT_FALSE(field.IsEmpty());
67}
68
69TEST(AutofillFieldTest, FieldSignature) {
70  AutofillField field;
71  ASSERT_EQ(base::string16(), field.name);
72  ASSERT_EQ(std::string(), field.form_control_type);
73
74  // Signature is empty.
75  EXPECT_EQ("2085434232", field.FieldSignature());
76
77  // Field name is set.
78  field.name = ASCIIToUTF16("Name");
79  EXPECT_EQ("1606968241", field.FieldSignature());
80
81  // Field form control type is set.
82  field.form_control_type = "text";
83  EXPECT_EQ("502192749", field.FieldSignature());
84
85  // Heuristic type does not affect FieldSignature.
86  field.set_heuristic_type(NAME_FIRST);
87  EXPECT_EQ("502192749", field.FieldSignature());
88
89  // Server type does not affect FieldSignature.
90  field.set_server_type(NAME_LAST);
91  EXPECT_EQ("502192749", field.FieldSignature());
92}
93
94TEST(AutofillFieldTest, IsFieldFillable) {
95  AutofillField field;
96  ASSERT_EQ(UNKNOWN_TYPE, field.Type().GetStorableType());
97
98  // Type is unknown.
99  EXPECT_FALSE(field.IsFieldFillable());
100
101  // Only heuristic type is set.
102  field.set_heuristic_type(NAME_FIRST);
103  EXPECT_TRUE(field.IsFieldFillable());
104
105  // Only server type is set.
106  field.set_heuristic_type(UNKNOWN_TYPE);
107  field.set_server_type(NAME_LAST);
108  EXPECT_TRUE(field.IsFieldFillable());
109
110  // Both types set.
111  field.set_heuristic_type(NAME_FIRST);
112  field.set_server_type(NAME_LAST);
113  EXPECT_TRUE(field.IsFieldFillable());
114}
115
116TEST(AutofillFieldTest, FillPhoneNumber) {
117  AutofillField field;
118  field.SetHtmlType(HTML_TYPE_TEL_LOCAL_PREFIX, HtmlFieldMode());
119
120  // Fill with a non-phone number; should fill normally.
121  AutofillField::FillFormField(field, ASCIIToUTF16("Oh hai"), "en-US", &field);
122  EXPECT_EQ(ASCIIToUTF16("Oh hai"), field.value);
123
124  // Fill with a phone number; should fill just the prefix.
125  AutofillField::FillFormField(field, ASCIIToUTF16("5551234"), "en-US", &field);
126  EXPECT_EQ(ASCIIToUTF16("555"), field.value);
127
128  // Now reset the type, and set a max-length instead.
129  field.SetHtmlType(HTML_TYPE_UNKNOWN, HtmlFieldMode());
130  field.set_heuristic_type(PHONE_HOME_NUMBER);
131  field.max_length = 4;
132
133  // Fill with a phone-number; should fill just the suffix.
134  AutofillField::FillFormField(field, ASCIIToUTF16("5551234"), "en-US", &field);
135  EXPECT_EQ(ASCIIToUTF16("1234"), field.value);
136}
137
138TEST(AutofillFieldTest, FillSelectControlByValue) {
139  const char* const kOptions[] = {
140    "Eenie", "Meenie", "Miney", "Mo",
141  };
142  AutofillField field(
143      GenerateSelectFieldWithOptions(kOptions, arraysize(kOptions)),
144      base::string16());
145
146  // Set semantically empty contents for each option, so that only the values
147  // can be used for matching.
148  for (size_t i = 0; i < field.option_contents.size(); ++i) {
149    field.option_contents[i] = ASCIIToUTF16(base::StringPrintf("%" PRIuS, i));
150  }
151
152  AutofillField::FillFormField(field, ASCIIToUTF16("Meenie"), "en-US",
153                               &field);
154  EXPECT_EQ(ASCIIToUTF16("Meenie"), field.value);
155}
156
157TEST(AutofillFieldTest, FillSelectControlByContents) {
158  const char* const kOptions[] = {
159    "Eenie", "Meenie", "Miney", "Mo",
160  };
161  AutofillField field(
162      GenerateSelectFieldWithOptions(kOptions, arraysize(kOptions)),
163      base::string16());
164
165  // Set semantically empty values for each option, so that only the contents
166  // can be used for matching.
167  for (size_t i = 0; i < field.option_values.size(); ++i) {
168    field.option_values[i] = ASCIIToUTF16(base::StringPrintf("%" PRIuS, i));
169  }
170
171  AutofillField::FillFormField(field, ASCIIToUTF16("Miney"), "en-US",
172                               &field);
173  EXPECT_EQ(ASCIIToUTF16("2"), field.value);  // Corresponds to "Miney".
174}
175
176TEST(AutofillFieldTest, FillSelectControlWithFullCountryNames) {
177  const char* const kCountries[] = {
178    "Albania", "Canada"
179  };
180  AutofillField field(
181      GenerateSelectFieldWithOptions(kCountries, arraysize(kCountries)),
182      base::string16());
183  field.set_heuristic_type(ADDRESS_HOME_COUNTRY);
184
185  AutofillField::FillFormField(field, ASCIIToUTF16("CA"), "en-US", &field);
186  EXPECT_EQ(ASCIIToUTF16("Canada"), field.value);
187}
188
189TEST(AutofillFieldTest, FillSelectControlWithAbbreviatedCountryNames) {
190  const char* const kCountries[] = {
191    "AL", "CA"
192  };
193  AutofillField field(
194      GenerateSelectFieldWithOptions(kCountries, arraysize(kCountries)),
195      base::string16());
196  field.set_heuristic_type(ADDRESS_HOME_COUNTRY);
197
198  AutofillField::FillFormField(field, ASCIIToUTF16("Canada"), "en-US", &field);
199  EXPECT_EQ(ASCIIToUTF16("CA"), field.value);
200}
201
202TEST(AutofillFieldTest, FillSelectControlWithFullStateNames) {
203  const char* const kStates[] = {
204    "Alabama", "California"
205  };
206  AutofillField field(
207      GenerateSelectFieldWithOptions(kStates, arraysize(kStates)),
208      base::string16());
209  field.set_heuristic_type(ADDRESS_HOME_STATE);
210
211  AutofillField::FillFormField(field, ASCIIToUTF16("CA"), "en-US", &field);
212  EXPECT_EQ(ASCIIToUTF16("California"), field.value);
213}
214
215TEST(AutofillFieldTest, FillSelectControlWithWithAbbreviateStateNames) {
216  const char* const kStates[] = {
217    "AL", "CA"
218  };
219  AutofillField field(
220      GenerateSelectFieldWithOptions(kStates, arraysize(kStates)),
221      base::string16());
222  field.set_heuristic_type(ADDRESS_HOME_STATE);
223
224  AutofillField::FillFormField(field, ASCIIToUTF16("California"), "en-US",
225                               &field);
226  EXPECT_EQ(ASCIIToUTF16("CA"), field.value);
227}
228
229TEST(AutofillFieldTest, FillSelectControlWithNumericMonth) {
230  const char* const kMonthsNumeric[] = {
231    "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12",
232  };
233  AutofillField field(
234      GenerateSelectFieldWithOptions(kMonthsNumeric, arraysize(kMonthsNumeric)),
235      base::string16());
236  field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
237
238  // Try with a leading zero.
239  AutofillField::FillFormField(field, ASCIIToUTF16("03"), "en-US", &field);
240  EXPECT_EQ(ASCIIToUTF16("03"), field.value);
241
242  // Try without a leading zero.
243  AutofillField::FillFormField(field, ASCIIToUTF16("4"), "en-US", &field);
244  EXPECT_EQ(ASCIIToUTF16("04"), field.value);
245
246  // Try a two-digit month.
247  AutofillField::FillFormField(field, ASCIIToUTF16("11"), "en-US", &field);
248  EXPECT_EQ(ASCIIToUTF16("11"), field.value);
249}
250
251TEST(AutofillFieldTest, FillSelectControlWithAbbreviatedMonthName) {
252  const char* const kMonthsAbbreviated[] = {
253    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
254    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
255  };
256  AutofillField field(
257      GenerateSelectFieldWithOptions(
258          kMonthsAbbreviated, arraysize(kMonthsAbbreviated)),
259      base::string16());
260  field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
261
262  AutofillField::FillFormField(field, ASCIIToUTF16("04"), "en-US", &field);
263  EXPECT_EQ(ASCIIToUTF16("Apr"), field.value);
264}
265
266TEST(AutofillFieldTest, FillSelectControlWithFullMonthName) {
267  const char* const kMonthsFull[] = {
268    "January", "February", "March", "April", "May", "June",
269    "July", "August", "September", "October", "November", "December",
270  };
271  AutofillField field(
272      GenerateSelectFieldWithOptions(kMonthsFull, arraysize(kMonthsFull)),
273      base::string16());
274  field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
275
276  AutofillField::FillFormField(field, ASCIIToUTF16("04"), "en-US", &field);
277  EXPECT_EQ(ASCIIToUTF16("April"), field.value);
278}
279
280TEST(AutofillFieldTest, FillSelectControlWithNumericMonthSansLeadingZero) {
281  const char* const kMonthsNumeric[] = {
282    "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
283  };
284  AutofillField field(
285      GenerateSelectFieldWithOptions(kMonthsNumeric, arraysize(kMonthsNumeric)),
286      base::string16());
287  field.set_heuristic_type(CREDIT_CARD_EXP_MONTH);
288
289  AutofillField::FillFormField(field, ASCIIToUTF16("04"), "en-US", &field);
290  EXPECT_EQ(ASCIIToUTF16("4"), field.value);
291}
292
293TEST(AutofillFieldTest, FillSelectControlWithTwoDigitCreditCardYear) {
294  const char* const kYears[] = {
295    "12", "13", "14", "15", "16", "17", "18", "19"
296  };
297  AutofillField field(GenerateSelectFieldWithOptions(kYears, arraysize(kYears)),
298                      base::string16());
299  field.set_heuristic_type(CREDIT_CARD_EXP_2_DIGIT_YEAR);
300
301  AutofillField::FillFormField(field, ASCIIToUTF16("2017"), "en-US", &field);
302  EXPECT_EQ(ASCIIToUTF16("17"), field.value);
303}
304
305TEST(AutofillFieldTest, FillSelectControlWithCreditCardType) {
306  const char* const kCreditCardTypes[] = {
307    "Visa", "Master Card", "AmEx", "discover"
308  };
309  AutofillField field(
310      GenerateSelectFieldWithOptions(
311          kCreditCardTypes, arraysize(kCreditCardTypes)),
312      base::string16());
313  field.set_heuristic_type(CREDIT_CARD_TYPE);
314
315  // Normal case:
316  AutofillField::FillFormField(field, ASCIIToUTF16("Visa"), "en-US", &field);
317  EXPECT_EQ(ASCIIToUTF16("Visa"), field.value);
318
319  // Filling should be able to handle intervening whitespace:
320  AutofillField::FillFormField(field, ASCIIToUTF16("MasterCard"), "en-US",
321                               &field);
322  EXPECT_EQ(ASCIIToUTF16("Master Card"), field.value);
323
324  // American Express is sometimes abbreviated as AmEx:
325  AutofillField::FillFormField(field, ASCIIToUTF16("American Express"), "en-US",
326                               &field);
327  EXPECT_EQ(ASCIIToUTF16("AmEx"), field.value);
328
329  // Case insensitivity:
330  AutofillField::FillFormField(field, ASCIIToUTF16("Discover"), "en-US",
331                               &field);
332  EXPECT_EQ(ASCIIToUTF16("discover"), field.value);
333}
334
335TEST(AutofillFieldTest, FillMonthControl) {
336  AutofillField field;
337  field.form_control_type = "month";
338
339  // Try a month with two digits.
340  AutofillField::FillFormField(field, ASCIIToUTF16("12/2017"), "en-US", &field);
341  EXPECT_EQ(ASCIIToUTF16("2017-12"), field.value);
342
343  // Try a month with a leading zero.
344  AutofillField::FillFormField(field, ASCIIToUTF16("03/2019"), "en-US", &field);
345  EXPECT_EQ(ASCIIToUTF16("2019-03"), field.value);
346
347  // Try a month without a leading zero.
348  AutofillField::FillFormField(field, ASCIIToUTF16("4/2018"), "en-US", &field);
349  EXPECT_EQ(ASCIIToUTF16("2018-04"), field.value);
350}
351
352}  // namespace
353}  // namespace autofill
354