| 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 |