OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011 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/basictypes.h" | |
6 #include "base/guid.h" | |
7 #include "base/strings/utf_string_conversions.h" | |
8 #include "components/autofill/browser/autofill_common_test.h" | |
9 #include "components/autofill/browser/credit_card.h" | |
10 #include "components/autofill/core/common/form_field_data.h" | |
11 #include "grit/webkit_resources.h" | |
12 #include "testing/gtest/include/gtest/gtest.h" | |
13 | |
14 namespace autofill { | |
15 namespace { | |
16 | |
17 // From https://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card
_numbers.htm | |
18 const char* const kValidNumbers[] = { | |
19 "378282246310005", | |
20 "3714 4963 5398 431", | |
21 "3787-3449-3671-000", | |
22 "5610591081018250", | |
23 "3056 9309 0259 04", | |
24 "3852-0000-0232-37", | |
25 "6011111111111117", | |
26 "6011 0009 9013 9424", | |
27 "3530-1113-3330-0000", | |
28 "3566002020360505", | |
29 "5555 5555 5555 4444", | |
30 "5105-1051-0510-5100", | |
31 "4111111111111111", | |
32 "4012 8888 8888 1881", | |
33 "4222-2222-2222-2", | |
34 "5019717010103742", | |
35 "6331101999990016", | |
36 }; | |
37 const char* const kInvalidNumbers[] = { | |
38 "4111 1111 112", /* too short */ | |
39 "41111111111111111115", /* too long */ | |
40 "4111-1111-1111-1110", /* wrong Luhn checksum */ | |
41 "3056 9309 0259 04aa", /* non-digit characters */ | |
42 }; | |
43 | |
44 } // namespace | |
45 | |
46 // Tests credit card summary string generation. This test simulates a variety | |
47 // of different possible summary strings. Variations occur based on the | |
48 // existence of credit card number, month, and year fields. | |
49 TEST(CreditCardTest, PreviewSummaryAndObfuscatedNumberStrings) { | |
50 // Case 0: empty credit card. | |
51 CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com/"); | |
52 base::string16 summary0 = credit_card0.Label(); | |
53 EXPECT_EQ(base::string16(), summary0); | |
54 base::string16 obfuscated0 = credit_card0.ObfuscatedNumber(); | |
55 EXPECT_EQ(base::string16(), obfuscated0); | |
56 | |
57 // Case 00: Empty credit card with empty strings. | |
58 CreditCard credit_card00(base::GenerateGUID(), "https://www.example.com/"); | |
59 test::SetCreditCardInfo(&credit_card00,"John Dillinger", "", "", ""); | |
60 base::string16 summary00 = credit_card00.Label(); | |
61 EXPECT_EQ(base::string16(ASCIIToUTF16("John Dillinger")), summary00); | |
62 base::string16 obfuscated00 = credit_card00.ObfuscatedNumber(); | |
63 EXPECT_EQ(base::string16(), obfuscated00); | |
64 | |
65 // Case 1: No credit card number. | |
66 CreditCard credit_card1(base::GenerateGUID(), "https://www.example.com/"); | |
67 test::SetCreditCardInfo(&credit_card1,"John Dillinger", "", "01", "2010"); | |
68 base::string16 summary1 = credit_card1.Label(); | |
69 EXPECT_EQ(base::string16(ASCIIToUTF16("John Dillinger")), summary1); | |
70 base::string16 obfuscated1 = credit_card1.ObfuscatedNumber(); | |
71 EXPECT_EQ(base::string16(), obfuscated1); | |
72 | |
73 // Case 2: No month. | |
74 CreditCard credit_card2(base::GenerateGUID(), "https://www.example.com/"); | |
75 test::SetCreditCardInfo( | |
76 &credit_card2, "John Dillinger", "5105 1051 0510 5100", "", "2010"); | |
77 base::string16 summary2 = credit_card2.Label(); | |
78 EXPECT_EQ(ASCIIToUTF16("************5100"), summary2); | |
79 base::string16 obfuscated2 = credit_card2.ObfuscatedNumber(); | |
80 EXPECT_EQ(ASCIIToUTF16("************5100"), obfuscated2); | |
81 | |
82 // Case 3: No year. | |
83 CreditCard credit_card3(base::GenerateGUID(), "https://www.example.com/"); | |
84 test::SetCreditCardInfo( | |
85 &credit_card3, "John Dillinger", "5105 1051 0510 5100", "01", ""); | |
86 base::string16 summary3 = credit_card3.Label(); | |
87 EXPECT_EQ(ASCIIToUTF16("************5100"), summary3); | |
88 base::string16 obfuscated3 = credit_card3.ObfuscatedNumber(); | |
89 EXPECT_EQ(ASCIIToUTF16("************5100"), obfuscated3); | |
90 | |
91 // Case 4: Have everything. | |
92 CreditCard credit_card4(base::GenerateGUID(), "https://www.example.com/"); | |
93 test::SetCreditCardInfo( | |
94 &credit_card4, "John Dillinger", "5105 1051 0510 5100", "01", "2010"); | |
95 base::string16 summary4 = credit_card4.Label(); | |
96 EXPECT_EQ(ASCIIToUTF16("************5100, Exp: 01/2010"), summary4); | |
97 base::string16 obfuscated4 = credit_card4.ObfuscatedNumber(); | |
98 EXPECT_EQ(ASCIIToUTF16("************5100"), obfuscated4); | |
99 | |
100 // Case 5: Very long credit card | |
101 CreditCard credit_card5(base::GenerateGUID(), "https://www.example.com/"); | |
102 test::SetCreditCardInfo( | |
103 &credit_card5, | |
104 "John Dillinger", | |
105 "0123456789 0123456789 0123456789 5105 1051 0510 5100", "01", "2010"); | |
106 base::string16 summary5 = credit_card5.Label(); | |
107 EXPECT_EQ(ASCIIToUTF16("********************5100, Exp: 01/2010"), summary5); | |
108 base::string16 obfuscated5 = credit_card5.ObfuscatedNumber(); | |
109 EXPECT_EQ(ASCIIToUTF16("********************5100"), obfuscated5); | |
110 } | |
111 | |
112 TEST(CreditCardTest, AssignmentOperator) { | |
113 CreditCard a(base::GenerateGUID(), "some origin"); | |
114 test::SetCreditCardInfo(&a, "John Dillinger", "123456789012", "01", "2010"); | |
115 | |
116 // Result of assignment should be logically equal to the original profile. | |
117 CreditCard b(base::GenerateGUID(), "some other origin"); | |
118 b = a; | |
119 EXPECT_TRUE(a == b); | |
120 | |
121 // Assignment to self should not change the profile value. | |
122 a = a; | |
123 EXPECT_TRUE(a == b); | |
124 } | |
125 | |
126 TEST(CreditCardTest, Copy) { | |
127 CreditCard a(base::GenerateGUID(), "https://www.example.com"); | |
128 test::SetCreditCardInfo(&a, "John Dillinger", "123456789012", "01", "2010"); | |
129 | |
130 // Clone should be logically equal to the original. | |
131 CreditCard b(a); | |
132 EXPECT_TRUE(a == b); | |
133 } | |
134 | |
135 TEST(CreditCardTest, Compare) { | |
136 CreditCard a(base::GenerateGUID(), std::string()); | |
137 CreditCard b(base::GenerateGUID(), std::string()); | |
138 | |
139 // Empty cards are the same. | |
140 EXPECT_EQ(0, a.Compare(b)); | |
141 | |
142 // GUIDs don't count. | |
143 a.set_guid(base::GenerateGUID()); | |
144 b.set_guid(base::GenerateGUID()); | |
145 EXPECT_EQ(0, a.Compare(b)); | |
146 | |
147 // Origins don't count. | |
148 a.set_origin("apple"); | |
149 b.set_origin("banana"); | |
150 EXPECT_EQ(0, a.Compare(b)); | |
151 | |
152 // Different values produce non-zero results. | |
153 test::SetCreditCardInfo(&a, "Jimmy", NULL, NULL, NULL); | |
154 test::SetCreditCardInfo(&b, "Ringo", NULL, NULL, NULL); | |
155 EXPECT_GT(0, a.Compare(b)); | |
156 EXPECT_LT(0, b.Compare(a)); | |
157 } | |
158 | |
159 // Test we get the correct icon for each card type. | |
160 TEST(CreditCardTest, IconResourceId) { | |
161 EXPECT_EQ(IDR_AUTOFILL_CC_AMEX, | |
162 CreditCard::IconResourceId(kAmericanExpressCard)); | |
163 EXPECT_EQ(IDR_AUTOFILL_CC_DINERS, | |
164 CreditCard::IconResourceId(kDinersCard)); | |
165 EXPECT_EQ(IDR_AUTOFILL_CC_DISCOVER, | |
166 CreditCard::IconResourceId(kDiscoverCard)); | |
167 EXPECT_EQ(IDR_AUTOFILL_CC_JCB, | |
168 CreditCard::IconResourceId(kJCBCard)); | |
169 EXPECT_EQ(IDR_AUTOFILL_CC_MASTERCARD, | |
170 CreditCard::IconResourceId(kMasterCard)); | |
171 EXPECT_EQ(IDR_AUTOFILL_CC_VISA, | |
172 CreditCard::IconResourceId(kVisaCard)); | |
173 } | |
174 | |
175 TEST(CreditCardTest, UpdateFromImportedCard) { | |
176 CreditCard original_card(base::GenerateGUID(), "https://www.example.com"); | |
177 test::SetCreditCardInfo( | |
178 &original_card, "John Dillinger", "123456789012", "09", "2017"); | |
179 | |
180 CreditCard a = original_card; | |
181 | |
182 // The new card has a different name, expiration date, and origin. | |
183 CreditCard b = a; | |
184 b.set_guid(base::GenerateGUID()); | |
185 b.set_origin("https://www.example.org"); | |
186 b.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("J. Dillinger")); | |
187 b.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("08")); | |
188 b.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2019")); | |
189 | |
190 EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US")); | |
191 EXPECT_EQ("https://www.example.org", a.origin()); | |
192 EXPECT_EQ(ASCIIToUTF16("J. Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME)); | |
193 EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
194 EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR)); | |
195 | |
196 // Try again, but with no name set for |b|. | |
197 a = original_card; | |
198 b.SetRawInfo(CREDIT_CARD_NAME, base::string16()); | |
199 | |
200 EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US")); | |
201 EXPECT_EQ("https://www.example.org", a.origin()); | |
202 EXPECT_EQ(ASCIIToUTF16("John Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME)); | |
203 EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
204 EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR)); | |
205 | |
206 // Try again, but with only the original card having a verified origin. | |
207 // |a| should be unchanged. | |
208 a = original_card; | |
209 a.set_origin("Chrome settings"); | |
210 b.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("J. Dillinger")); | |
211 | |
212 EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US")); | |
213 EXPECT_EQ("Chrome settings", a.origin()); | |
214 EXPECT_EQ(ASCIIToUTF16("John Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME)); | |
215 EXPECT_EQ(ASCIIToUTF16("09"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
216 EXPECT_EQ(ASCIIToUTF16("2017"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR)); | |
217 | |
218 // Try again, but with only the new card having a verified origin. | |
219 a = original_card; | |
220 b.set_origin("Chrome settings"); | |
221 | |
222 EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US")); | |
223 EXPECT_EQ("Chrome settings", a.origin()); | |
224 EXPECT_EQ(ASCIIToUTF16("J. Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME)); | |
225 EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
226 EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR)); | |
227 | |
228 // Try again, with both cards having a verified origin. | |
229 a = original_card; | |
230 a.set_origin("Chrome Autofill dialog"); | |
231 b.set_origin("Chrome settings"); | |
232 | |
233 EXPECT_TRUE(a.UpdateFromImportedCard(b, "en-US")); | |
234 EXPECT_EQ("Chrome settings", a.origin()); | |
235 EXPECT_EQ(ASCIIToUTF16("J. Dillinger"), a.GetRawInfo(CREDIT_CARD_NAME)); | |
236 EXPECT_EQ(ASCIIToUTF16("08"), a.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
237 EXPECT_EQ(ASCIIToUTF16("2019"), a.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR)); | |
238 | |
239 // Try again, but with |b| having a different card number. | |
240 // |a| should be unchanged. | |
241 a = original_card; | |
242 b.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111111111111111")); | |
243 | |
244 EXPECT_FALSE(a.UpdateFromImportedCard(b, "en-US")); | |
245 EXPECT_EQ(original_card, a); | |
246 } | |
247 | |
248 TEST(CreditCardTest, IsComplete) { | |
249 CreditCard card(base::GenerateGUID(), "https://www.example.com/"); | |
250 EXPECT_FALSE(card.IsComplete()); | |
251 card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Wally T. Walrus")); | |
252 EXPECT_FALSE(card.IsComplete()); | |
253 card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01")); | |
254 EXPECT_FALSE(card.IsComplete()); | |
255 card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2014")); | |
256 | |
257 for (size_t i = 0; i < arraysize(kValidNumbers); ++i) { | |
258 SCOPED_TRACE(kValidNumbers[i]); | |
259 card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(kValidNumbers[i])); | |
260 EXPECT_TRUE(card.IsComplete()); | |
261 } | |
262 for (size_t i = 0; i < arraysize(kInvalidNumbers); ++i) { | |
263 SCOPED_TRACE(kInvalidNumbers[i]); | |
264 card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16(kInvalidNumbers[i])); | |
265 EXPECT_FALSE(card.IsComplete()); | |
266 } | |
267 } | |
268 | |
269 TEST(CreditCardTest, InvalidMastercardNumber) { | |
270 CreditCard card(base::GenerateGUID(), "https://www.example.com/"); | |
271 | |
272 test::SetCreditCardInfo(&card, "Baby Face Nelson", | |
273 "5200000000000004", "01", "2010"); | |
274 EXPECT_EQ("genericCC", card.type()); | |
275 } | |
276 | |
277 // Verify that we preserve exactly what the user typed for credit card numbers. | |
278 TEST(CreditCardTest, SetRawInfoCreditCardNumber) { | |
279 CreditCard card(base::GenerateGUID(), "https://www.example.com/"); | |
280 | |
281 test::SetCreditCardInfo(&card, "Bob Dylan", | |
282 "4321-5432-6543-xxxx", "07", "2013"); | |
283 EXPECT_EQ(ASCIIToUTF16("4321-5432-6543-xxxx"), | |
284 card.GetRawInfo(CREDIT_CARD_NUMBER)); | |
285 } | |
286 | |
287 // Verify that we can handle both numeric and named months. | |
288 TEST(CreditCardTest, SetExpirationMonth) { | |
289 CreditCard card(base::GenerateGUID(), "https://www.example.com/"); | |
290 | |
291 card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("05")); | |
292 EXPECT_EQ(ASCIIToUTF16("05"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
293 EXPECT_EQ(5, card.expiration_month()); | |
294 | |
295 card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("7")); | |
296 EXPECT_EQ(ASCIIToUTF16("07"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
297 EXPECT_EQ(7, card.expiration_month()); | |
298 | |
299 // This should fail, and preserve the previous value. | |
300 card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("January")); | |
301 EXPECT_EQ(ASCIIToUTF16("07"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
302 EXPECT_EQ(7, card.expiration_month()); | |
303 | |
304 card.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("January"), "en-US"); | |
305 EXPECT_EQ(ASCIIToUTF16("01"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
306 EXPECT_EQ(1, card.expiration_month()); | |
307 | |
308 card.SetInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("Apr"), "en-US"); | |
309 EXPECT_EQ(ASCIIToUTF16("04"), card.GetRawInfo(CREDIT_CARD_EXP_MONTH)); | |
310 EXPECT_EQ(4, card.expiration_month()); | |
311 } | |
312 | |
313 TEST(CreditCardTest, CreditCardType) { | |
314 CreditCard card(base::GenerateGUID(), "https://www.example.com/"); | |
315 | |
316 // The card type cannot be set directly. | |
317 card.SetRawInfo(CREDIT_CARD_TYPE, ASCIIToUTF16("Visa")); | |
318 EXPECT_EQ(base::string16(), card.GetRawInfo(CREDIT_CARD_TYPE)); | |
319 | |
320 // Setting the number should implicitly set the type. | |
321 card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("4111 1111 1111 1111")); | |
322 EXPECT_EQ(ASCIIToUTF16("Visa"), card.GetRawInfo(CREDIT_CARD_TYPE)); | |
323 } | |
324 | |
325 TEST(CreditCardTest, CreditCardVerificationCode) { | |
326 CreditCard card(base::GenerateGUID(), "https://www.example.com/"); | |
327 | |
328 // The verification code cannot be set, as Chrome does not store this data. | |
329 card.SetRawInfo(CREDIT_CARD_VERIFICATION_CODE, ASCIIToUTF16("999")); | |
330 EXPECT_EQ(base::string16(), card.GetRawInfo(CREDIT_CARD_VERIFICATION_CODE)); | |
331 } | |
332 | |
333 | |
334 TEST(CreditCardTest, CreditCardMonthExact) { | |
335 const char* const kMonthsNumeric[] = { | |
336 "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", | |
337 }; | |
338 std::vector<base::string16> options(arraysize(kMonthsNumeric)); | |
339 for (size_t i = 0; i < arraysize(kMonthsNumeric); ++i) { | |
340 options[i] = ASCIIToUTF16(kMonthsNumeric[i]); | |
341 } | |
342 | |
343 FormFieldData field; | |
344 field.form_control_type = "select-one"; | |
345 field.option_values = options; | |
346 field.option_contents = options; | |
347 | |
348 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); | |
349 credit_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01")); | |
350 credit_card.FillSelectControl(CREDIT_CARD_EXP_MONTH, "en-US", &field); | |
351 EXPECT_EQ(ASCIIToUTF16("01"), field.value); | |
352 } | |
353 | |
354 TEST(CreditCardTest, CreditCardMonthAbbreviated) { | |
355 const char* const kMonthsAbbreviated[] = { | |
356 "Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
357 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", | |
358 }; | |
359 std::vector<base::string16> options(arraysize(kMonthsAbbreviated)); | |
360 for (size_t i = 0; i < arraysize(kMonthsAbbreviated); ++i) { | |
361 options[i] = ASCIIToUTF16(kMonthsAbbreviated[i]); | |
362 } | |
363 | |
364 FormFieldData field; | |
365 field.form_control_type = "select-one"; | |
366 field.option_values = options; | |
367 field.option_contents = options; | |
368 | |
369 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); | |
370 credit_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01")); | |
371 credit_card.FillSelectControl(CREDIT_CARD_EXP_MONTH, "en-US", &field); | |
372 EXPECT_EQ(ASCIIToUTF16("Jan"), field.value); | |
373 } | |
374 | |
375 TEST(CreditCardTest, CreditCardMonthFull) { | |
376 const char* const kMonthsFull[] = { | |
377 "January", "February", "March", "April", "May", "June", | |
378 "July", "August", "September", "October", "November", "December", | |
379 }; | |
380 std::vector<base::string16> options(arraysize(kMonthsFull)); | |
381 for (size_t i = 0; i < arraysize(kMonthsFull); ++i) { | |
382 options[i] = ASCIIToUTF16(kMonthsFull[i]); | |
383 } | |
384 | |
385 FormFieldData field; | |
386 field.form_control_type = "select-one"; | |
387 field.option_values = options; | |
388 field.option_contents = options; | |
389 | |
390 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); | |
391 credit_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01")); | |
392 credit_card.FillSelectControl(CREDIT_CARD_EXP_MONTH, "en-US", &field); | |
393 EXPECT_EQ(ASCIIToUTF16("January"), field.value); | |
394 } | |
395 | |
396 TEST(CreditCardTest, CreditCardMonthNumeric) { | |
397 const char* const kMonthsNumeric[] = { | |
398 "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", | |
399 }; | |
400 std::vector<base::string16> options(arraysize(kMonthsNumeric)); | |
401 for (size_t i = 0; i < arraysize(kMonthsNumeric); ++i) { | |
402 options[i] = ASCIIToUTF16(kMonthsNumeric[i]); | |
403 } | |
404 | |
405 FormFieldData field; | |
406 field.form_control_type = "select-one"; | |
407 field.option_values = options; | |
408 field.option_contents = options; | |
409 | |
410 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); | |
411 credit_card.SetRawInfo(CREDIT_CARD_EXP_MONTH, ASCIIToUTF16("01")); | |
412 credit_card.FillSelectControl(CREDIT_CARD_EXP_MONTH, "en-US", &field); | |
413 EXPECT_EQ(ASCIIToUTF16("1"), field.value); | |
414 } | |
415 | |
416 TEST(CreditCardTest, CreditCardTwoDigitYear) { | |
417 const char* const kYears[] = { | |
418 "12", "13", "14", "15", "16", "17", "18", "19" | |
419 }; | |
420 std::vector<base::string16> options(arraysize(kYears)); | |
421 for (size_t i = 0; i < arraysize(kYears); ++i) { | |
422 options[i] = ASCIIToUTF16(kYears[i]); | |
423 } | |
424 | |
425 FormFieldData field; | |
426 field.form_control_type = "select-one"; | |
427 field.option_values = options; | |
428 field.option_contents = options; | |
429 | |
430 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); | |
431 credit_card.SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, ASCIIToUTF16("2017")); | |
432 credit_card.FillSelectControl(CREDIT_CARD_EXP_4_DIGIT_YEAR, "en-US", &field); | |
433 EXPECT_EQ(ASCIIToUTF16("17"), field.value); | |
434 EXPECT_EQ(2017, credit_card.expiration_year()); | |
435 } | |
436 | |
437 TEST(CreditCardTest, CreditCardTypeSelectControl) { | |
438 const char* const kCreditCardTypes[] = { | |
439 "Visa", "Master Card", "AmEx", "discover" | |
440 }; | |
441 std::vector<base::string16> options(arraysize(kCreditCardTypes)); | |
442 for (size_t i = 0; i < arraysize(kCreditCardTypes); ++i) { | |
443 options[i] = ASCIIToUTF16(kCreditCardTypes[i]); | |
444 } | |
445 | |
446 FormFieldData field; | |
447 field.form_control_type = "select-one"; | |
448 field.option_values = options; | |
449 field.option_contents = options; | |
450 | |
451 // Credit card types are inferred from the numbers, so we use test numbers for | |
452 // each card type. Test card numbers are drawn from | |
453 // http://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_num
bers.htm | |
454 | |
455 { | |
456 // Normal case: | |
457 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); | |
458 credit_card.SetRawInfo(CREDIT_CARD_NUMBER, | |
459 ASCIIToUTF16("4111111111111111")); | |
460 credit_card.FillSelectControl(CREDIT_CARD_TYPE, "en-US", &field); | |
461 EXPECT_EQ(ASCIIToUTF16("Visa"), field.value); | |
462 } | |
463 | |
464 { | |
465 // Filling should be able to handle intervening whitespace: | |
466 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); | |
467 credit_card.SetRawInfo(CREDIT_CARD_NUMBER, | |
468 ASCIIToUTF16("5105105105105100")); | |
469 credit_card.FillSelectControl(CREDIT_CARD_TYPE, "en-US", &field); | |
470 EXPECT_EQ(ASCIIToUTF16("Master Card"), field.value); | |
471 } | |
472 | |
473 { | |
474 // American Express is sometimes abbreviated as AmEx: | |
475 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); | |
476 credit_card.SetRawInfo(CREDIT_CARD_NUMBER, ASCIIToUTF16("371449635398431")); | |
477 credit_card.FillSelectControl(CREDIT_CARD_TYPE, "en-US", &field); | |
478 EXPECT_EQ(ASCIIToUTF16("AmEx"), field.value); | |
479 } | |
480 | |
481 { | |
482 // Case insensitivity: | |
483 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); | |
484 credit_card.SetRawInfo(CREDIT_CARD_NUMBER, | |
485 ASCIIToUTF16("6011111111111117")); | |
486 credit_card.FillSelectControl(CREDIT_CARD_TYPE, "en-US", &field); | |
487 EXPECT_EQ(ASCIIToUTF16("discover"), field.value); | |
488 } | |
489 } | |
490 | |
491 } // namespace autofill | |
OLD | NEW |