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 "components/autofill/core/browser/autofill_test_utils.h"
6
7 #include <string>
8
9 #include "base/guid.h"
10 #include "base/rand_util.h"
11 #include "base/strings/string_number_conversions.h"
12 #include "base/strings/stringprintf.h"
13 #include "base/strings/utf_string_conversions.h"
14 #include "base/time/time.h"
15 #include "build/build_config.h"
16 #include "components/autofill/core/browser/autofill_external_delegate.h"
17 #include "components/autofill/core/browser/data_model/autofill_profile.h"
18 #include "components/autofill/core/browser/data_model/credit_card.h"
19 #include "components/autofill/core/browser/field_types.h"
20 #include "components/autofill/core/browser/randomized_encoder.h"
21 #include "components/autofill/core/browser/webdata/autofill_table.h"
22 #include "components/autofill/core/common/autofill_clock.h"
23 #include "components/autofill/core/common/autofill_constants.h"
24 #include "components/autofill/core/common/autofill_features.h"
25 #include "components/autofill/core/common/autofill_prefs.h"
26 #include "components/autofill/core/common/autofill_util.h"
27 #include "components/autofill/core/common/form_data.h"
28 #include "components/autofill/core/common/form_data_predictions.h"
29 #include "components/autofill/core/common/form_field_data.h"
30 #include "components/autofill/core/common/form_field_data_predictions.h"
31 #include "components/autofill/core/common/renderer_id.h"
32 #include "components/os_crypt/os_crypt_mocker.h"
33 #include "components/pref_registry/pref_registry_syncable.h"
34 #include "components/prefs/pref_service.h"
35 #include "components/prefs/pref_service_factory.h"
36 #include "components/prefs/testing_pref_store.h"
37 #include "components/security_interstitials/core/pref_names.h"
38 #include "testing/gtest/include/gtest/gtest.h"
39 #include "ui/gfx/geometry/rect.h"
40
41 using base::ASCIIToUTF16;
42
43 namespace autofill {
44
operator ==(const FormFieldDataPredictions & a,const FormFieldDataPredictions & b)45 bool operator==(const FormFieldDataPredictions& a,
46 const FormFieldDataPredictions& b) {
47 auto members = [](const FormFieldDataPredictions& p) {
48 return std::tie(p.signature, p.heuristic_type, p.server_type,
49 p.overall_type, p.parseable_name, p.section);
50 };
51 return members(a) == members(b);
52 }
53
operator ==(const FormDataPredictions & a,const FormDataPredictions & b)54 bool operator==(const FormDataPredictions& a, const FormDataPredictions& b) {
55 return a.data.SameFormAs(b.data) && a.signature == b.signature &&
56 a.fields == b.fields;
57 }
58
59 namespace test {
60
61 namespace {
62
63 const int kValidityStateBitfield = 1984;
64
GetRandomCardNumber()65 std::string GetRandomCardNumber() {
66 const size_t length = 16;
67 std::string value;
68 value.reserve(length);
69 for (size_t i = 0; i < length; ++i)
70 value.push_back(static_cast<char>(base::RandInt('0', '9')));
71 return value;
72 }
73
MakeFormRendererId()74 FormRendererId MakeFormRendererId() {
75 static uint32_t counter = 10;
76 return FormRendererId(counter++);
77 }
78
MakeFieldRendererId()79 FieldRendererId MakeFieldRendererId() {
80 static uint32_t counter = 10;
81 return FieldRendererId(counter++);
82 }
83
84 } // namespace
85
PrefServiceForTesting()86 std::unique_ptr<PrefService> PrefServiceForTesting() {
87 scoped_refptr<user_prefs::PrefRegistrySyncable> registry(
88 new user_prefs::PrefRegistrySyncable());
89 registry->RegisterBooleanPref(
90 RandomizedEncoder::kUrlKeyedAnonymizedDataCollectionEnabled, false);
91 registry->RegisterBooleanPref(::prefs::kMixedFormsWarningsEnabled, true);
92 return PrefServiceForTesting(registry.get());
93 }
94
PrefServiceForTesting(user_prefs::PrefRegistrySyncable * registry)95 std::unique_ptr<PrefService> PrefServiceForTesting(
96 user_prefs::PrefRegistrySyncable* registry) {
97 prefs::RegisterProfilePrefs(registry);
98
99 PrefServiceFactory factory;
100 factory.set_user_prefs(base::MakeRefCounted<TestingPrefStore>());
101 return factory.Create(registry);
102 }
103
CreateTestFormField(const char * label,const char * name,const char * value,const char * type,FormFieldData * field)104 void CreateTestFormField(const char* label,
105 const char* name,
106 const char* value,
107 const char* type,
108 FormFieldData* field) {
109 field->unique_renderer_id = MakeFieldRendererId();
110 field->label = ASCIIToUTF16(label);
111 field->name = ASCIIToUTF16(name);
112 field->value = ASCIIToUTF16(value);
113 field->form_control_type = type;
114 field->is_focusable = true;
115 }
116
CreateTestSelectField(const char * label,const char * name,const char * value,const std::vector<const char * > & values,const std::vector<const char * > & contents,size_t select_size,FormFieldData * field)117 void CreateTestSelectField(const char* label,
118 const char* name,
119 const char* value,
120 const std::vector<const char*>& values,
121 const std::vector<const char*>& contents,
122 size_t select_size,
123 FormFieldData* field) {
124 // Fill the base attributes.
125 CreateTestFormField(label, name, value, "select-one", field);
126
127 std::vector<base::string16> values16(select_size);
128 for (size_t i = 0; i < select_size; ++i)
129 values16[i] = base::UTF8ToUTF16(values[i]);
130
131 std::vector<base::string16> contents16(select_size);
132 for (size_t i = 0; i < select_size; ++i)
133 contents16[i] = base::UTF8ToUTF16(contents[i]);
134
135 field->option_values = values16;
136 field->option_contents = contents16;
137 }
138
CreateTestSelectField(const std::vector<const char * > & values,FormFieldData * field)139 void CreateTestSelectField(const std::vector<const char*>& values,
140 FormFieldData* field) {
141 CreateTestSelectField("", "", "", values, values, values.size(), field);
142 }
143
CreateTestDatalistField(const char * label,const char * name,const char * value,const std::vector<const char * > & values,const std::vector<const char * > & labels,FormFieldData * field)144 void CreateTestDatalistField(const char* label,
145 const char* name,
146 const char* value,
147 const std::vector<const char*>& values,
148 const std::vector<const char*>& labels,
149 FormFieldData* field) {
150 // Fill the base attributes.
151 CreateTestFormField(label, name, value, "text", field);
152
153 std::vector<base::string16> values16(values.size());
154 for (size_t i = 0; i < values.size(); ++i)
155 values16[i] = base::UTF8ToUTF16(values[i]);
156
157 std::vector<base::string16> label16(labels.size());
158 for (size_t i = 0; i < labels.size(); ++i)
159 label16[i] = base::UTF8ToUTF16(labels[i]);
160
161 field->datalist_values = values16;
162 field->datalist_labels = label16;
163 }
164
CreateTestAddressFormData(FormData * form,const char * unique_id)165 void CreateTestAddressFormData(FormData* form, const char* unique_id) {
166 std::vector<ServerFieldTypeSet> types;
167 CreateTestAddressFormData(form, &types, unique_id);
168 }
169
CreateTestAddressFormData(FormData * form,std::vector<ServerFieldTypeSet> * types,const char * unique_id)170 void CreateTestAddressFormData(FormData* form,
171 std::vector<ServerFieldTypeSet>* types,
172 const char* unique_id) {
173 form->unique_renderer_id = MakeFormRendererId();
174 form->name =
175 ASCIIToUTF16("MyForm") + ASCIIToUTF16(unique_id ? unique_id : "");
176 form->button_titles = {
177 std::make_pair(ASCIIToUTF16("Submit"),
178 mojom::ButtonTitleType::BUTTON_ELEMENT_SUBMIT_TYPE)};
179 form->url = GURL("http://myform.com/form.html");
180 form->full_url = GURL("http://myform.com/form.html?foo=bar");
181 form->action = GURL("http://myform.com/submit.html");
182 form->is_action_empty = true;
183 form->main_frame_origin =
184 url::Origin::Create(GURL("https://myform_root.com/form.html"));
185 types->clear();
186 form->submission_event =
187 mojom::SubmissionIndicatorEvent::SAME_DOCUMENT_NAVIGATION;
188
189 FormFieldData field;
190 ServerFieldTypeSet type_set;
191 test::CreateTestFormField("First Name", "firstname", "", "text", &field);
192 form->fields.push_back(field);
193 type_set.clear();
194 type_set.insert(NAME_FIRST);
195 types->push_back(type_set);
196 test::CreateTestFormField("Middle Name", "middlename", "", "text", &field);
197 form->fields.push_back(field);
198 type_set.clear();
199 type_set.insert(NAME_MIDDLE);
200 types->push_back(type_set);
201 test::CreateTestFormField("Last Name", "lastname", "", "text", &field);
202 form->fields.push_back(field);
203 type_set.clear();
204 type_set.insert(NAME_LAST);
205 if (base::FeatureList::IsEnabled(
206 features::kAutofillEnableSupportForMoreStructureInNames)) {
207 type_set.insert(NAME_LAST_SECOND);
208 }
209 types->push_back(type_set);
210 test::CreateTestFormField("Address Line 1", "addr1", "", "text", &field);
211 form->fields.push_back(field);
212 type_set.clear();
213 type_set.insert(ADDRESS_HOME_LINE1);
214 types->push_back(type_set);
215 test::CreateTestFormField("Address Line 2", "addr2", "", "text", &field);
216 form->fields.push_back(field);
217 type_set.clear();
218 type_set.insert(ADDRESS_HOME_LINE2);
219 types->push_back(type_set);
220 test::CreateTestFormField("City", "city", "", "text", &field);
221 form->fields.push_back(field);
222 type_set.clear();
223 type_set.insert(ADDRESS_HOME_CITY);
224 types->push_back(type_set);
225 test::CreateTestFormField("State", "state", "", "text", &field);
226 form->fields.push_back(field);
227 type_set.clear();
228 type_set.insert(ADDRESS_HOME_STATE);
229 types->push_back(type_set);
230 test::CreateTestFormField("Postal Code", "zipcode", "", "text", &field);
231 form->fields.push_back(field);
232 type_set.clear();
233 type_set.insert(ADDRESS_HOME_ZIP);
234 types->push_back(type_set);
235 test::CreateTestFormField("Country", "country", "", "text", &field);
236 form->fields.push_back(field);
237 type_set.clear();
238 type_set.insert(ADDRESS_HOME_COUNTRY);
239 types->push_back(type_set);
240 test::CreateTestFormField("Phone Number", "phonenumber", "", "tel", &field);
241 form->fields.push_back(field);
242 type_set.clear();
243 type_set.insert(PHONE_HOME_WHOLE_NUMBER);
244 types->push_back(type_set);
245 test::CreateTestFormField("Email", "email", "", "email", &field);
246 form->fields.push_back(field);
247 type_set.clear();
248 type_set.insert(EMAIL_ADDRESS);
249 types->push_back(type_set);
250 }
251
CreateTestPersonalInformationFormData(FormData * form,const char * unique_id)252 void CreateTestPersonalInformationFormData(FormData* form,
253 const char* unique_id) {
254 form->unique_renderer_id = MakeFormRendererId();
255 form->name =
256 ASCIIToUTF16("MyForm") + ASCIIToUTF16(unique_id ? unique_id : "");
257 form->url = GURL("http://myform.com/form.html");
258 form->full_url = GURL("http://myform.com/form.html?foo=bar");
259 form->action = GURL("http://myform.com/submit.html");
260 form->main_frame_origin =
261 url::Origin::Create(GURL("https://myform_root.com/form.html"));
262
263 FormFieldData field;
264 test::CreateTestFormField("First Name", "firstname", "", "text", &field);
265 form->fields.push_back(field);
266 test::CreateTestFormField("Middle Name", "middlename", "", "text", &field);
267 form->fields.push_back(field);
268 test::CreateTestFormField("Last Name", "lastname", "", "text", &field);
269 form->fields.push_back(field);
270 test::CreateTestFormField("Email", "email", "", "email", &field);
271 form->fields.push_back(field);
272 }
273
CreateTestCreditCardFormData(FormData * form,bool is_https,bool use_month_type,bool split_names,const char * unique_id)274 void CreateTestCreditCardFormData(FormData* form,
275 bool is_https,
276 bool use_month_type,
277 bool split_names,
278 const char* unique_id) {
279 form->unique_renderer_id = MakeFormRendererId();
280 form->name =
281 ASCIIToUTF16("MyForm") + ASCIIToUTF16(unique_id ? unique_id : "");
282 if (is_https) {
283 form->url = GURL("https://myform.com/form.html");
284 form->full_url = GURL("http://myform.com/form.html?foo=bar");
285 form->action = GURL("https://myform.com/submit.html");
286 form->main_frame_origin =
287 url::Origin::Create(GURL("https://myform_root.com/form.html"));
288 } else {
289 form->url = GURL("http://myform.com/form.html");
290 form->full_url = GURL("http://myform.com/form.html?foo=bar");
291 form->action = GURL("http://myform.com/submit.html");
292 form->main_frame_origin =
293 url::Origin::Create(GURL("http://myform_root.com/form.html"));
294 }
295
296 FormFieldData field;
297 if (split_names) {
298 test::CreateTestFormField("First Name on Card", "firstnameoncard", "",
299 "text", &field);
300 field.autocomplete_attribute = "cc-given-name";
301 form->fields.push_back(field);
302 test::CreateTestFormField("Last Name on Card", "lastnameoncard", "", "text",
303 &field);
304 field.autocomplete_attribute = "cc-family-name";
305 form->fields.push_back(field);
306 field.autocomplete_attribute = "";
307 } else {
308 test::CreateTestFormField("Name on Card", "nameoncard", "", "text", &field);
309 form->fields.push_back(field);
310 }
311 test::CreateTestFormField("Card Number", "cardnumber", "", "text", &field);
312 form->fields.push_back(field);
313 if (use_month_type) {
314 test::CreateTestFormField("Expiration Date", "ccmonth", "", "month",
315 &field);
316 form->fields.push_back(field);
317 } else {
318 test::CreateTestFormField("Expiration Date", "ccmonth", "", "text", &field);
319 form->fields.push_back(field);
320 test::CreateTestFormField("", "ccyear", "", "text", &field);
321 form->fields.push_back(field);
322 }
323 test::CreateTestFormField("CVC", "cvc", "", "text", &field);
324 form->fields.push_back(field);
325 }
326
check_and_set(FormGroup * profile,ServerFieldType type,const char * value)327 inline void check_and_set(FormGroup* profile,
328 ServerFieldType type,
329 const char* value) {
330 if (value) {
331 profile->SetRawInfoWithVerificationStatus(
332 type, base::UTF8ToUTF16(value),
333 structured_address::VerificationStatus::kObserved);
334 }
335 }
336
GetFullValidProfileForCanada()337 AutofillProfile GetFullValidProfileForCanada() {
338 AutofillProfile profile(base::GenerateGUID(), kEmptyOrigin);
339 SetProfileInfo(&profile, "Alice", "", "Wonderland", "alice@wonderland.ca",
340 "Fiction", "666 Notre-Dame Ouest", "Apt 8", "Montreal", "QC",
341 "H3B 2T9", "CA", "15141112233");
342 return profile;
343 }
344
GetFullValidProfileForChina()345 AutofillProfile GetFullValidProfileForChina() {
346 AutofillProfile profile(base::GenerateGUID(), kEmptyOrigin);
347 SetProfileInfo(&profile, "John", "H.", "Doe", "johndoe@google.cn", "Google",
348 "100 Century Avenue", "", "赫章县", "毕节地区", "贵州省",
349 "200120", "CN", "+86-21-6133-7666");
350 return profile;
351 }
352
GetFullProfile()353 AutofillProfile GetFullProfile() {
354 AutofillProfile profile(base::GenerateGUID(), kEmptyOrigin);
355 SetProfileInfo(&profile, "John", "H.", "Doe", "johndoe@hades.com",
356 "Underworld", "666 Erebus St.", "Apt 8", "Elysium", "CA",
357 "91111", "US", "16502111111");
358 return profile;
359 }
360
GetFullProfile2()361 AutofillProfile GetFullProfile2() {
362 AutofillProfile profile(base::GenerateGUID(), kEmptyOrigin);
363 SetProfileInfo(&profile, "Jane", "A.", "Smith", "jsmith@example.com", "ACME",
364 "123 Main Street", "Unit 1", "Greensdale", "MI", "48838", "US",
365 "13105557889");
366 return profile;
367 }
368
GetFullCanadianProfile()369 AutofillProfile GetFullCanadianProfile() {
370 AutofillProfile profile(base::GenerateGUID(), kEmptyOrigin);
371 SetProfileInfo(&profile, "Wayne", "", "Gretzky", "wayne@hockey.com", "NHL",
372 "123 Hockey rd.", "Apt 8", "Moncton", "New Brunswick",
373 "E1A 0A6", "CA", "15068531212");
374 return profile;
375 }
376
GetIncompleteProfile1()377 AutofillProfile GetIncompleteProfile1() {
378 AutofillProfile profile(base::GenerateGUID(), kEmptyOrigin);
379 SetProfileInfo(&profile, "John", "H.", "Doe", "jsmith@example.com", "ACME",
380 "123 Main Street", "Unit 1", "Greensdale", "MI", "48838", "US",
381 "");
382 return profile;
383 }
384
GetIncompleteProfile2()385 AutofillProfile GetIncompleteProfile2() {
386 AutofillProfile profile(base::GenerateGUID(), kEmptyOrigin);
387 SetProfileInfo(&profile, "", "", "", "jsmith@example.com", "", "", "", "", "",
388 "", "", "");
389 return profile;
390 }
391
GetVerifiedProfile()392 AutofillProfile GetVerifiedProfile() {
393 AutofillProfile profile(GetFullProfile());
394 profile.set_origin(kSettingsOrigin);
395 return profile;
396 }
397
GetServerProfile()398 AutofillProfile GetServerProfile() {
399 AutofillProfile profile(AutofillProfile::SERVER_PROFILE, "id1");
400 // Note: server profiles don't have email addresses and only have full names.
401 SetProfileInfo(&profile, "", "", "", "", "Google, Inc.", "123 Fake St.",
402 "Apt. 42", "Mountain View", "California", "94043", "US",
403 "1.800.555.1234");
404
405 profile.SetInfo(NAME_FULL, ASCIIToUTF16("John K. Doe"), "en");
406 profile.SetRawInfo(ADDRESS_HOME_SORTING_CODE, ASCIIToUTF16("CEDEX"));
407 profile.SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
408 ASCIIToUTF16("Santa Clara"));
409
410 profile.set_language_code("en");
411 profile.SetClientValidityFromBitfieldValue(kValidityStateBitfield);
412 profile.set_is_client_validity_states_updated(true);
413 profile.set_use_count(7);
414 profile.set_use_date(base::Time::FromTimeT(54321));
415
416 profile.GenerateServerProfileIdentifier();
417
418 return profile;
419 }
420
GetServerProfile2()421 AutofillProfile GetServerProfile2() {
422 AutofillProfile profile(AutofillProfile::SERVER_PROFILE, "id2");
423 // Note: server profiles don't have email addresses.
424 SetProfileInfo(&profile, "", "", "", "", "Main, Inc.", "4323 Wrong St.",
425 "Apt. 1032", "Sunnyvale", "California", "10011", "US",
426 "+1 514-123-1234");
427
428 profile.SetInfo(NAME_FULL, ASCIIToUTF16("Jim S. Bristow"), "en");
429 profile.SetRawInfo(ADDRESS_HOME_SORTING_CODE, ASCIIToUTF16("XEDEC"));
430 profile.SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
431 ASCIIToUTF16("Santa Monica"));
432
433 profile.set_language_code("en");
434 profile.SetClientValidityFromBitfieldValue(kValidityStateBitfield);
435 profile.set_is_client_validity_states_updated(true);
436 profile.set_use_count(14);
437 profile.set_use_date(base::Time::FromTimeT(98765));
438
439 profile.GenerateServerProfileIdentifier();
440
441 return profile;
442 }
443
GetCreditCard()444 CreditCard GetCreditCard() {
445 CreditCard credit_card(base::GenerateGUID(), kEmptyOrigin);
446 SetCreditCardInfo(&credit_card, "Test User", "4111111111111111" /* Visa */,
447 NextMonth().c_str(), NextYear().c_str(), "1");
448 return credit_card;
449 }
450
GetCreditCard2()451 CreditCard GetCreditCard2() {
452 CreditCard credit_card(base::GenerateGUID(), kEmptyOrigin);
453 SetCreditCardInfo(&credit_card, "Someone Else", "378282246310005" /* AmEx */,
454 NextMonth().c_str(), TenYearsFromNow().c_str(), "1");
455 return credit_card;
456 }
457
GetExpiredCreditCard()458 CreditCard GetExpiredCreditCard() {
459 CreditCard credit_card(base::GenerateGUID(), kEmptyOrigin);
460 SetCreditCardInfo(&credit_card, "Test User", "4111111111111111" /* Visa */,
461 NextMonth().c_str(), LastYear().c_str(), "1");
462 return credit_card;
463 }
464
GetIncompleteCreditCard()465 CreditCard GetIncompleteCreditCard() {
466 CreditCard credit_card(base::GenerateGUID(), kEmptyOrigin);
467 SetCreditCardInfo(&credit_card, "", "4111111111111111" /* Visa */,
468 NextMonth().c_str(), NextYear().c_str(), "1");
469 return credit_card;
470 }
471
GetVerifiedCreditCard()472 CreditCard GetVerifiedCreditCard() {
473 CreditCard credit_card(GetCreditCard());
474 credit_card.set_origin(kSettingsOrigin);
475 return credit_card;
476 }
477
GetVerifiedCreditCard2()478 CreditCard GetVerifiedCreditCard2() {
479 CreditCard credit_card(GetCreditCard2());
480 credit_card.set_origin(kSettingsOrigin);
481 return credit_card;
482 }
483
GetMaskedServerCard()484 CreditCard GetMaskedServerCard() {
485 CreditCard credit_card(CreditCard::MASKED_SERVER_CARD, "a123");
486 test::SetCreditCardInfo(&credit_card, "Bonnie Parker",
487 "2109" /* Mastercard */, NextMonth().c_str(),
488 NextYear().c_str(), "1");
489 credit_card.SetNetworkForMaskedCard(kMasterCard);
490 credit_card.set_instrument_id(1);
491 return credit_card;
492 }
493
GetMaskedServerCardAmex()494 CreditCard GetMaskedServerCardAmex() {
495 CreditCard credit_card(CreditCard::MASKED_SERVER_CARD, "b456");
496 test::SetCreditCardInfo(&credit_card, "Justin Thyme", "8431" /* Amex */,
497 NextMonth().c_str(), NextYear().c_str(), "1");
498 credit_card.SetNetworkForMaskedCard(kAmericanExpressCard);
499 return credit_card;
500 }
501
GetMaskedServerCardWithNickname()502 CreditCard GetMaskedServerCardWithNickname() {
503 CreditCard credit_card(CreditCard::MASKED_SERVER_CARD, "c789");
504 test::SetCreditCardInfo(&credit_card, "Test user", "1111" /* Visa */,
505 NextMonth().c_str(), NextYear().c_str(), "1");
506 credit_card.SetNetworkForMaskedCard(kVisaCard);
507 credit_card.SetNickname(ASCIIToUTF16("Test nickname"));
508 return credit_card;
509 }
510
GetMaskedServerCardWithInvalidNickname()511 CreditCard GetMaskedServerCardWithInvalidNickname() {
512 CreditCard credit_card(CreditCard::MASKED_SERVER_CARD, "c789");
513 test::SetCreditCardInfo(&credit_card, "Test user", "1111" /* Visa */,
514 NextMonth().c_str(), NextYear().c_str(), "1");
515 credit_card.SetNetworkForMaskedCard(kVisaCard);
516 credit_card.SetNickname(ASCIIToUTF16("Invalid nickname which is too long"));
517 return credit_card;
518 }
519
GetFullServerCard()520 CreditCard GetFullServerCard() {
521 CreditCard credit_card(CreditCard::FULL_SERVER_CARD, "c123");
522 test::SetCreditCardInfo(&credit_card, "Full Carter",
523 "4111111111111111" /* Visa */, NextMonth().c_str(),
524 NextYear().c_str(), "1");
525 return credit_card;
526 }
527
GetRandomCreditCard(CreditCard::RecordType record_type)528 CreditCard GetRandomCreditCard(CreditCard::RecordType record_type) {
529 static const char* const kNetworks[] = {
530 kAmericanExpressCard,
531 kDinersCard,
532 kDiscoverCard,
533 kEloCard,
534 kGenericCard,
535 kJCBCard,
536 kMasterCard,
537 kMirCard,
538 kUnionPay,
539 kVisaCard,
540 };
541 constexpr size_t kNumNetworks = sizeof(kNetworks) / sizeof(kNetworks[0]);
542 base::Time::Exploded now;
543 AutofillClock::Now().LocalExplode(&now);
544
545 CreditCard credit_card =
546 (record_type == CreditCard::LOCAL_CARD)
547 ? CreditCard(base::GenerateGUID(), kEmptyOrigin)
548 : CreditCard(record_type, base::GenerateGUID().substr(24));
549 test::SetCreditCardInfo(
550 &credit_card, "Justin Thyme", GetRandomCardNumber().c_str(),
551 base::StringPrintf("%d", base::RandInt(1, 12)).c_str(),
552 base::StringPrintf("%d", now.year + base::RandInt(1, 4)).c_str(), "1");
553 if (record_type == CreditCard::MASKED_SERVER_CARD) {
554 credit_card.SetNetworkForMaskedCard(
555 kNetworks[base::RandInt(0, kNumNetworks - 1)]);
556 }
557
558 return credit_card;
559 }
560
GetCreditCardCloudTokenData1()561 CreditCardCloudTokenData GetCreditCardCloudTokenData1() {
562 CreditCardCloudTokenData data;
563 data.masked_card_id = "data1_id";
564 data.suffix = ASCIIToUTF16("1111");
565 data.exp_month = 1;
566 base::StringToInt(NextYear(), &data.exp_year);
567 data.card_art_url = "fake url 1";
568 data.instrument_token = "fake token 1";
569 return data;
570 }
571
GetCreditCardCloudTokenData2()572 CreditCardCloudTokenData GetCreditCardCloudTokenData2() {
573 CreditCardCloudTokenData data;
574 data.masked_card_id = "data2_id";
575 data.suffix = ASCIIToUTF16("2222");
576 data.exp_month = 2;
577 base::StringToInt(NextYear(), &data.exp_year);
578 data.exp_year += 1;
579 data.card_art_url = "fake url 2";
580 data.instrument_token = "fake token 2";
581 return data;
582 }
583
GetCardLinkedOfferData1()584 AutofillOfferData GetCardLinkedOfferData1() {
585 AutofillOfferData data;
586 data.offer_id = 111;
587 data.offer_reward_amount = "5%";
588 // Sets the expiry to be 45 days later.
589 data.expiry = AutofillClock::Now() + base::TimeDelta::FromDays(45);
590 data.offer_details_url = GURL("http://www.example1.com");
591 data.merchant_domain.emplace_back("http://www.example1.com");
592 data.eligible_instrument_id.emplace_back(111111);
593 return data;
594 }
595
GetCardLinkedOfferData2()596 AutofillOfferData GetCardLinkedOfferData2() {
597 AutofillOfferData data;
598 data.offer_id = 222;
599 data.offer_reward_amount = "$10";
600 // Sets the expiry to be 40 days later.
601 data.expiry = AutofillClock::Now() + base::TimeDelta::FromDays(40);
602 data.offer_details_url = GURL("http://www.example2.com");
603 data.merchant_domain.emplace_back("http://www.example2.com");
604 data.eligible_instrument_id.emplace_back(222222);
605 return data;
606 }
607
SetProfileInfo(AutofillProfile * profile,const char * first_name,const char * middle_name,const char * last_name,const char * email,const char * company,const char * address1,const char * address2,const char * dependent_locality,const char * city,const char * state,const char * zipcode,const char * country,const char * phone,bool finalize)608 void SetProfileInfo(AutofillProfile* profile,
609 const char* first_name,
610 const char* middle_name,
611 const char* last_name,
612 const char* email,
613 const char* company,
614 const char* address1,
615 const char* address2,
616 const char* dependent_locality,
617 const char* city,
618 const char* state,
619 const char* zipcode,
620 const char* country,
621 const char* phone,
622 bool finalize) {
623 check_and_set(profile, NAME_FIRST, first_name);
624 check_and_set(profile, NAME_MIDDLE, middle_name);
625 check_and_set(profile, NAME_LAST, last_name);
626 check_and_set(profile, EMAIL_ADDRESS, email);
627 check_and_set(profile, COMPANY_NAME, company);
628 check_and_set(profile, ADDRESS_HOME_LINE1, address1);
629 check_and_set(profile, ADDRESS_HOME_LINE2, address2);
630 check_and_set(profile, ADDRESS_HOME_DEPENDENT_LOCALITY, dependent_locality);
631 check_and_set(profile, ADDRESS_HOME_CITY, city);
632 check_and_set(profile, ADDRESS_HOME_STATE, state);
633 check_and_set(profile, ADDRESS_HOME_ZIP, zipcode);
634 check_and_set(profile, ADDRESS_HOME_COUNTRY, country);
635 check_and_set(profile, PHONE_HOME_WHOLE_NUMBER, phone);
636 if (finalize)
637 profile->FinalizeAfterImport();
638 }
639
SetProfileInfo(AutofillProfile * profile,const char * first_name,const char * middle_name,const char * last_name,const char * email,const char * company,const char * address1,const char * address2,const char * city,const char * state,const char * zipcode,const char * country,const char * phone,bool finalize)640 void SetProfileInfo(AutofillProfile* profile,
641 const char* first_name,
642 const char* middle_name,
643 const char* last_name,
644 const char* email,
645 const char* company,
646 const char* address1,
647 const char* address2,
648 const char* city,
649 const char* state,
650 const char* zipcode,
651 const char* country,
652 const char* phone,
653 bool finalize) {
654 check_and_set(profile, NAME_FIRST, first_name);
655 check_and_set(profile, NAME_MIDDLE, middle_name);
656 check_and_set(profile, NAME_LAST, last_name);
657 check_and_set(profile, EMAIL_ADDRESS, email);
658 check_and_set(profile, COMPANY_NAME, company);
659 check_and_set(profile, ADDRESS_HOME_LINE1, address1);
660 check_and_set(profile, ADDRESS_HOME_LINE2, address2);
661 check_and_set(profile, ADDRESS_HOME_CITY, city);
662 check_and_set(profile, ADDRESS_HOME_STATE, state);
663 check_and_set(profile, ADDRESS_HOME_ZIP, zipcode);
664 check_and_set(profile, ADDRESS_HOME_COUNTRY, country);
665 check_and_set(profile, PHONE_HOME_WHOLE_NUMBER, phone);
666 if (finalize)
667 profile->FinalizeAfterImport();
668 }
669
SetProfileInfoWithGuid(AutofillProfile * profile,const char * guid,const char * first_name,const char * middle_name,const char * last_name,const char * email,const char * company,const char * address1,const char * address2,const char * city,const char * state,const char * zipcode,const char * country,const char * phone,bool finalize)670 void SetProfileInfoWithGuid(AutofillProfile* profile,
671 const char* guid,
672 const char* first_name,
673 const char* middle_name,
674 const char* last_name,
675 const char* email,
676 const char* company,
677 const char* address1,
678 const char* address2,
679 const char* city,
680 const char* state,
681 const char* zipcode,
682 const char* country,
683 const char* phone,
684 bool finalize) {
685 if (guid)
686 profile->set_guid(guid);
687 SetProfileInfo(profile, first_name, middle_name, last_name, email, company,
688 address1, address2, city, state, zipcode, country, phone,
689 finalize);
690 }
691
SetCreditCardInfo(CreditCard * credit_card,const char * name_on_card,const char * card_number,const char * expiration_month,const char * expiration_year,const std::string & billing_address_id)692 void SetCreditCardInfo(CreditCard* credit_card,
693 const char* name_on_card,
694 const char* card_number,
695 const char* expiration_month,
696 const char* expiration_year,
697 const std::string& billing_address_id) {
698 check_and_set(credit_card, CREDIT_CARD_NAME_FULL, name_on_card);
699 check_and_set(credit_card, CREDIT_CARD_NUMBER, card_number);
700 check_and_set(credit_card, CREDIT_CARD_EXP_MONTH, expiration_month);
701 check_and_set(credit_card, CREDIT_CARD_EXP_4_DIGIT_YEAR, expiration_year);
702 credit_card->set_billing_address_id(billing_address_id);
703 }
704
DisableSystemServices(PrefService * prefs)705 void DisableSystemServices(PrefService* prefs) {
706 // Use a mock Keychain rather than the OS one to store credit card data.
707 OSCryptMocker::SetUp();
708 }
709
ReenableSystemServices()710 void ReenableSystemServices() {
711 OSCryptMocker::TearDown();
712 }
713
SetServerCreditCards(AutofillTable * table,const std::vector<CreditCard> & cards)714 void SetServerCreditCards(AutofillTable* table,
715 const std::vector<CreditCard>& cards) {
716 std::vector<CreditCard> as_masked_cards = cards;
717 for (CreditCard& card : as_masked_cards) {
718 card.set_record_type(CreditCard::MASKED_SERVER_CARD);
719 card.SetNumber(card.LastFourDigits());
720 card.SetNetworkForMaskedCard(card.network());
721 card.set_instrument_id(card.instrument_id());
722 }
723 table->SetServerCreditCards(as_masked_cards);
724
725 for (const CreditCard& card : cards) {
726 if (card.record_type() != CreditCard::FULL_SERVER_CARD)
727 continue;
728 ASSERT_TRUE(table->UnmaskServerCreditCard(card, card.number()));
729 }
730 }
731
InitializePossibleTypesAndValidities(std::vector<ServerFieldTypeSet> & possible_field_types,std::vector<ServerFieldTypeValidityStatesMap> & possible_field_types_validities,const std::vector<ServerFieldType> & possible_types,const std::vector<AutofillDataModel::ValidityState> & validity_states)732 void InitializePossibleTypesAndValidities(
733 std::vector<ServerFieldTypeSet>& possible_field_types,
734 std::vector<ServerFieldTypeValidityStatesMap>&
735 possible_field_types_validities,
736 const std::vector<ServerFieldType>& possible_types,
737 const std::vector<AutofillDataModel::ValidityState>& validity_states) {
738 possible_field_types.push_back(ServerFieldTypeSet());
739 possible_field_types_validities.push_back(ServerFieldTypeValidityStatesMap());
740
741 if (validity_states.empty()) {
742 for (const auto& possible_type : possible_types) {
743 possible_field_types.back().insert(possible_type);
744 possible_field_types_validities.back()[possible_type].push_back(
745 AutofillProfile::UNVALIDATED);
746 }
747 return;
748 }
749
750 ASSERT_FALSE(possible_types.empty());
751 ASSERT_TRUE((possible_types.size() == validity_states.size()) ||
752 (possible_types.size() == 1 && validity_states.size() > 1));
753
754 ServerFieldType possible_type = possible_types[0];
755 for (unsigned i = 0; i < validity_states.size(); ++i) {
756 if (possible_types.size() == validity_states.size()) {
757 possible_type = possible_types[i];
758 }
759 possible_field_types.back().insert(possible_type);
760 possible_field_types_validities.back()[possible_type].push_back(
761 validity_states[i]);
762 }
763 }
764
BasicFillUploadField(AutofillUploadContents::Field * field,unsigned signature,const char * name,const char * control_type,const char * autocomplete)765 void BasicFillUploadField(AutofillUploadContents::Field* field,
766 unsigned signature,
767 const char* name,
768 const char* control_type,
769 const char* autocomplete) {
770 field->set_signature(signature);
771 if (name)
772 field->set_name(name);
773 if (control_type)
774 field->set_type(control_type);
775 if (autocomplete)
776 field->set_autocomplete(autocomplete);
777 }
778
FillUploadField(AutofillUploadContents::Field * field,unsigned signature,const char * name,const char * control_type,const char * autocomplete,unsigned autofill_type,unsigned validity_state)779 void FillUploadField(AutofillUploadContents::Field* field,
780 unsigned signature,
781 const char* name,
782 const char* control_type,
783 const char* autocomplete,
784 unsigned autofill_type,
785 unsigned validity_state) {
786 BasicFillUploadField(field, signature, name, control_type, autocomplete);
787
788 field->add_autofill_type(autofill_type);
789
790 auto* type_validities = field->add_autofill_type_validities();
791 type_validities->set_type(autofill_type);
792 type_validities->add_validity(validity_state);
793 }
794
FillUploadField(AutofillUploadContents::Field * field,unsigned signature,const char * name,const char * control_type,const char * autocomplete,const std::vector<unsigned> & autofill_types,const std::vector<unsigned> & validity_states)795 void FillUploadField(AutofillUploadContents::Field* field,
796 unsigned signature,
797 const char* name,
798 const char* control_type,
799 const char* autocomplete,
800 const std::vector<unsigned>& autofill_types,
801 const std::vector<unsigned>& validity_states) {
802 BasicFillUploadField(field, signature, name, control_type, autocomplete);
803
804 for (unsigned i = 0; i < autofill_types.size(); ++i) {
805 field->add_autofill_type(autofill_types[i]);
806
807 auto* type_validities = field->add_autofill_type_validities();
808 type_validities->set_type(autofill_types[i]);
809 if (i < validity_states.size()) {
810 type_validities->add_validity(validity_states[i]);
811 } else {
812 type_validities->add_validity(0);
813 }
814 }
815 }
816
FillUploadField(AutofillUploadContents::Field * field,unsigned signature,const char * name,const char * control_type,const char * autocomplete,unsigned autofill_type,const std::vector<unsigned> & validity_states)817 void FillUploadField(AutofillUploadContents::Field* field,
818 unsigned signature,
819 const char* name,
820 const char* control_type,
821 const char* autocomplete,
822 unsigned autofill_type,
823 const std::vector<unsigned>& validity_states) {
824 BasicFillUploadField(field, signature, name, control_type, autocomplete);
825
826 field->add_autofill_type(autofill_type);
827 auto* type_validities = field->add_autofill_type_validities();
828 type_validities->set_type(autofill_type);
829 for (unsigned i = 0; i < validity_states.size(); ++i)
830 type_validities->add_validity(validity_states[i]);
831 }
832
FillQueryField(AutofillQueryContents::Form::Field * field,unsigned signature,const char * name,const char * control_type)833 void FillQueryField(AutofillQueryContents::Form::Field* field,
834 unsigned signature,
835 const char* name,
836 const char* control_type) {
837 field->set_signature(signature);
838 if (name)
839 field->set_name(name);
840 if (control_type)
841 field->set_type(control_type);
842 }
843
FillQueryField(AutofillPageQueryRequest_Form_Field * field,unsigned signature,const char * name,const char * control_type)844 void FillQueryField(AutofillPageQueryRequest_Form_Field* field,
845 unsigned signature,
846 const char* name,
847 const char* control_type) {
848 field->set_signature(signature);
849 if (name)
850 field->set_name(name);
851 if (control_type)
852 field->set_control_type(control_type);
853 }
854
GenerateTestAutofillPopup(AutofillExternalDelegate * autofill_external_delegate)855 void GenerateTestAutofillPopup(
856 AutofillExternalDelegate* autofill_external_delegate) {
857 int query_id = 1;
858 FormData form;
859 FormFieldData field;
860 field.is_focusable = true;
861 field.should_autocomplete = true;
862 gfx::RectF bounds(100.f, 100.f);
863 autofill_external_delegate->OnQuery(query_id, form, field, bounds);
864
865 std::vector<Suggestion> suggestions;
866 suggestions.push_back(Suggestion(base::ASCIIToUTF16("Test suggestion")));
867 autofill_external_delegate->OnSuggestionsReturned(
868 query_id, suggestions, /*autoselect_first_suggestion=*/false);
869 }
870
ObfuscatedCardDigitsAsUTF8(const std::string & str)871 std::string ObfuscatedCardDigitsAsUTF8(const std::string& str) {
872 return base::UTF16ToUTF8(
873 internal::GetObfuscatedStringForCardDigits(base::ASCIIToUTF16(str)));
874 }
875
NextMonth()876 std::string NextMonth() {
877 base::Time::Exploded now;
878 // Using AutofillClock here might cause test flakiness. See crbug/1108232.
879 base::Time::Now().LocalExplode(&now);
880 return base::StringPrintf("%02d", now.month % 12 + 1);
881 }
LastYear()882 std::string LastYear() {
883 base::Time::Exploded now;
884 // Using AutofillClock here might cause test flakiness. See crbug/1108232.
885 base::Time::Now().LocalExplode(&now);
886 return base::NumberToString(now.year - 1);
887 }
NextYear()888 std::string NextYear() {
889 base::Time::Exploded now;
890 // Using AutofillClock here might cause test flakiness. See crbug/1108232.
891 base::Time::Now().LocalExplode(&now);
892 return base::NumberToString(now.year + 1);
893 }
TenYearsFromNow()894 std::string TenYearsFromNow() {
895 base::Time::Exploded now;
896 // Using AutofillClock here might cause test flakiness. See crbug/1108232.
897 base::Time::Now().LocalExplode(&now);
898 return base::NumberToString(now.year + 10);
899 }
900
GetEncodedSignatures(const FormStructure & form)901 std::vector<FormSignature> GetEncodedSignatures(const FormStructure& form) {
902 std::vector<FormSignature> signatures;
903 signatures.push_back(form.form_signature());
904 return signatures;
905 }
906
GetEncodedSignatures(const std::vector<FormStructure * > & forms)907 std::vector<FormSignature> GetEncodedSignatures(
908 const std::vector<FormStructure*>& forms) {
909 std::vector<FormSignature> all_signatures;
910 for (const FormStructure* form : forms)
911 all_signatures.push_back(form->form_signature());
912 return all_signatures;
913 }
914
915 } // namespace test
916 } // namespace autofill
917