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 <string> 6 7 #include "base/basictypes.h" 8 #include "base/memory/ref_counted.h" 9 #include "base/memory/scoped_ptr.h" 10 #include "base/message_loop.h" 11 #include "base/utf_string_conversions.h" 12 #include "chrome/browser/autofill/autofill_common_test.h" 13 #include "chrome/browser/autofill/autofill_profile.h" 14 #include "chrome/browser/autofill/form_structure.h" 15 #include "chrome/browser/autofill/personal_data_manager.h" 16 #include "chrome/browser/password_manager/encryptor.h" 17 #include "chrome/common/guid.h" 18 #include "chrome/test/testing_browser_process.h" 19 #include "chrome/test/testing_profile.h" 20 #include "content/browser/browser_thread.h" 21 #include "content/common/notification_details.h" 22 #include "content/common/notification_observer_mock.h" 23 #include "content/common/notification_registrar.h" 24 #include "content/common/notification_source.h" 25 #include "content/common/notification_type.h" 26 #include "testing/gmock/include/gmock/gmock.h" 27 #include "testing/gtest/include/gtest/gtest.h" 28 #include "webkit/glue/form_data.h" 29 #include "webkit/glue/form_data.h" 30 31 using webkit_glue::FormData; 32 33 ACTION(QuitUIMessageLoop) { 34 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 35 MessageLoop::current()->Quit(); 36 } 37 38 class PersonalDataLoadedObserverMock : public PersonalDataManager::Observer { 39 public: 40 PersonalDataLoadedObserverMock() {} 41 virtual ~PersonalDataLoadedObserverMock() {} 42 43 MOCK_METHOD0(OnPersonalDataLoaded, void()); 44 }; 45 46 class PersonalDataManagerTest : public testing::Test { 47 protected: 48 PersonalDataManagerTest() 49 : ui_thread_(BrowserThread::UI, &message_loop_), 50 db_thread_(BrowserThread::DB) { 51 } 52 53 virtual void SetUp() { 54 db_thread_.Start(); 55 56 profile_.reset(new TestingProfile); 57 profile_->CreateWebDataService(false); 58 59 autofill_test::DisableSystemServices(profile_.get()); 60 ResetPersonalDataManager(); 61 } 62 63 virtual void TearDown() { 64 personal_data_ = NULL; 65 if (profile_.get()) 66 profile_.reset(NULL); 67 68 db_thread_.Stop(); 69 MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask); 70 MessageLoop::current()->Run(); 71 } 72 73 void ResetPersonalDataManager() { 74 personal_data_ = new PersonalDataManager(); 75 personal_data_->Init(profile_.get()); 76 personal_data_->SetObserver(&personal_data_observer_); 77 } 78 79 ScopedTestingBrowserProcess browser_process_; 80 MessageLoopForUI message_loop_; 81 BrowserThread ui_thread_; 82 BrowserThread db_thread_; 83 scoped_ptr<TestingProfile> profile_; 84 scoped_refptr<PersonalDataManager> personal_data_; 85 NotificationRegistrar registrar_; 86 NotificationObserverMock observer_; 87 PersonalDataLoadedObserverMock personal_data_observer_; 88 }; 89 90 // TODO(jhawkins): Test SetProfiles w/out a WebDataService in the profile. 91 TEST_F(PersonalDataManagerTest, SetProfiles) { 92 AutofillProfile profile0; 93 autofill_test::SetProfileInfo(&profile0, 94 "Marion", "Mitchell", "Morrison", 95 "johnwayne (at) me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 96 "91601", "US", "12345678910", "01987654321"); 97 98 AutofillProfile profile1; 99 autofill_test::SetProfileInfo(&profile1, 100 "Josephine", "Alicia", "Saenz", 101 "joewayne (at) me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", 102 "US", "19482937549", "13502849239"); 103 104 AutofillProfile profile2; 105 autofill_test::SetProfileInfo(&profile2, 106 "Josephine", "Alicia", "Saenz", 107 "joewayne (at) me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL", 108 "32801", "US", "19482937549", "13502849239"); 109 110 // This will verify that the web database has been loaded and the notification 111 // sent out. 112 EXPECT_CALL(personal_data_observer_, 113 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 114 115 // The message loop will exit when the mock observer is notified. 116 MessageLoop::current()->Run(); 117 118 // Add two test profiles to the database. 119 std::vector<AutofillProfile> update; 120 update.push_back(profile0); 121 update.push_back(profile1); 122 personal_data_->SetProfiles(&update); 123 124 const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); 125 ASSERT_EQ(2U, results1.size()); 126 EXPECT_EQ(0, profile0.Compare(*results1.at(0))); 127 EXPECT_EQ(0, profile1.Compare(*results1.at(1))); 128 129 // Three operations in one: 130 // - Update profile0 131 // - Remove profile1 132 // - Add profile2 133 profile0.SetInfo(NAME_FIRST, ASCIIToUTF16("John")); 134 update.clear(); 135 update.push_back(profile0); 136 update.push_back(profile2); 137 personal_data_->SetProfiles(&update); 138 139 const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); 140 ASSERT_EQ(2U, results2.size()); 141 EXPECT_EQ(0, profile0.Compare(*results2.at(0))); 142 EXPECT_EQ(0, profile2.Compare(*results2.at(1))); 143 144 // Reset the PersonalDataManager. This tests that the personal data was saved 145 // to the web database, and that we can load the profiles from the web 146 // database. 147 ResetPersonalDataManager(); 148 149 // This will verify that the web database has been loaded and the notification 150 // sent out. 151 EXPECT_CALL(personal_data_observer_, 152 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 153 154 // The message loop will exit when the PersonalDataLoadedObserver is notified. 155 MessageLoop::current()->Run(); 156 157 // Verify that we've loaded the profiles from the web database. 158 const std::vector<AutofillProfile*>& results3 = personal_data_->profiles(); 159 ASSERT_EQ(2U, results3.size()); 160 EXPECT_EQ(0, profile0.Compare(*results3.at(0))); 161 EXPECT_EQ(0, profile2.Compare(*results3.at(1))); 162 } 163 164 // TODO(jhawkins): Test SetCreditCards w/out a WebDataService in the profile. 165 TEST_F(PersonalDataManagerTest, SetCreditCards) { 166 CreditCard creditcard0; 167 autofill_test::SetCreditCardInfo(&creditcard0, 168 "John Dillinger", "423456789012" /* Visa */, "01", "2010"); 169 170 CreditCard creditcard1; 171 autofill_test::SetCreditCardInfo(&creditcard1, 172 "Bonnie Parker", "518765432109" /* Mastercard */, "12", "2012"); 173 174 CreditCard creditcard2; 175 autofill_test::SetCreditCardInfo(&creditcard2, 176 "Clyde Barrow", "347666888555" /* American Express */, "04", "2015"); 177 178 // This will verify that the web database has been loaded and the notification 179 // sent out. 180 EXPECT_CALL(personal_data_observer_, 181 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 182 183 // The message loop will exit when the mock observer is notified. 184 MessageLoop::current()->Run(); 185 186 // Add two test credit cards to the database. 187 std::vector<CreditCard> update; 188 update.push_back(creditcard0); 189 update.push_back(creditcard1); 190 personal_data_->SetCreditCards(&update); 191 192 const std::vector<CreditCard*>& results1 = personal_data_->credit_cards(); 193 ASSERT_EQ(2U, results1.size()); 194 EXPECT_EQ(0, creditcard0.Compare(*results1.at(0))); 195 EXPECT_EQ(0, creditcard1.Compare(*results1.at(1))); 196 197 // Three operations in one: 198 // - Update creditcard0 199 // - Remove creditcard1 200 // - Add creditcard2 201 creditcard0.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Joe")); 202 update.clear(); 203 update.push_back(creditcard0); 204 update.push_back(creditcard2); 205 personal_data_->SetCreditCards(&update); 206 207 const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); 208 ASSERT_EQ(2U, results2.size()); 209 EXPECT_EQ(creditcard0, *results2.at(0)); 210 EXPECT_EQ(creditcard2, *results2.at(1)); 211 212 // Reset the PersonalDataManager. This tests that the personal data was saved 213 // to the web database, and that we can load the credit cards from the web 214 // database. 215 ResetPersonalDataManager(); 216 217 // This will verify that the web database has been loaded and the notification 218 // sent out. 219 EXPECT_CALL(personal_data_observer_, 220 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 221 222 // The message loop will exit when the PersonalDataLoadedObserver is notified. 223 MessageLoop::current()->Run(); 224 225 // Verify that we've loaded the credit cards from the web database. 226 const std::vector<CreditCard*>& results3 = personal_data_->credit_cards(); 227 ASSERT_EQ(2U, results3.size()); 228 EXPECT_EQ(creditcard0, *results3.at(0)); 229 EXPECT_EQ(creditcard2, *results3.at(1)); 230 } 231 232 TEST_F(PersonalDataManagerTest, SetProfilesAndCreditCards) { 233 AutofillProfile profile0; 234 autofill_test::SetProfileInfo(&profile0, 235 "Marion", "Mitchell", "Morrison", 236 "johnwayne (at) me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 237 "91601", "US", "12345678910", "01987654321"); 238 239 AutofillProfile profile1; 240 autofill_test::SetProfileInfo(&profile1, 241 "Josephine", "Alicia", "Saenz", 242 "joewayne (at) me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", 243 "US", "19482937549", "13502849239"); 244 245 CreditCard creditcard0; 246 autofill_test::SetCreditCardInfo(&creditcard0, 247 "John Dillinger", "423456789012" /* Visa */, "01", "2010"); 248 249 CreditCard creditcard1; 250 autofill_test::SetCreditCardInfo(&creditcard1, 251 "Bonnie Parker", "518765432109" /* Mastercard */, "12", "2012"); 252 253 // This will verify that the web database has been loaded and the notification 254 // sent out. 255 EXPECT_CALL( 256 personal_data_observer_, 257 OnPersonalDataLoaded()).Times(2).WillRepeatedly(QuitUIMessageLoop()); 258 259 // The message loop will exit when the mock observer is notified. 260 MessageLoop::current()->Run(); 261 262 // Add two test profiles to the database. 263 std::vector<AutofillProfile> update; 264 update.push_back(profile0); 265 update.push_back(profile1); 266 personal_data_->SetProfiles(&update); 267 268 const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); 269 ASSERT_EQ(2U, results1.size()); 270 EXPECT_EQ(0, profile0.Compare(*results1.at(0))); 271 EXPECT_EQ(0, profile1.Compare(*results1.at(1))); 272 273 MessageLoop::current()->Run(); 274 275 // Add two test credit cards to the database. 276 std::vector<CreditCard> update_cc; 277 update_cc.push_back(creditcard0); 278 update_cc.push_back(creditcard1); 279 personal_data_->SetCreditCards(&update_cc); 280 281 282 const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); 283 ASSERT_EQ(2U, results2.size()); 284 EXPECT_EQ(creditcard0, *results2.at(0)); 285 EXPECT_EQ(creditcard1, *results2.at(1)); 286 287 // Determine uniqueness by inserting all of the GUIDs into a set and verifying 288 // the size of the set matches the number of GUIDs. 289 std::set<std::string> guids; 290 guids.insert(profile0.guid()); 291 guids.insert(profile1.guid()); 292 guids.insert(creditcard0.guid()); 293 guids.insert(creditcard1.guid()); 294 EXPECT_EQ(4U, guids.size()); 295 } 296 297 // Test care for 50047. Makes sure that unique_ids_ is populated correctly on 298 // load. 299 TEST_F(PersonalDataManagerTest, PopulateUniqueIDsOnLoad) { 300 AutofillProfile profile0; 301 autofill_test::SetProfileInfo(&profile0, 302 "y", "", "", "", "", "", "", "", "", "", "", "", ""); 303 304 // This will verify that the web database has been loaded and the notification 305 // sent out. 306 EXPECT_CALL(personal_data_observer_, 307 OnPersonalDataLoaded()).WillRepeatedly(QuitUIMessageLoop()); 308 309 // The message loop will exit when the mock observer is notified. 310 MessageLoop::current()->Run(); 311 312 // Add the profile0 to the db. 313 std::vector<AutofillProfile> update; 314 update.push_back(profile0); 315 personal_data_->SetProfiles(&update); 316 317 // Reset the PersonalDataManager. This recreates PersonalDataManager, which 318 // should populate unique_ids_. 319 ResetPersonalDataManager(); 320 321 // The message loop will exit when the PersonalDataLoadedObserver is notified. 322 MessageLoop::current()->Run(); 323 324 // Verify that we've loaded the profiles from the web database. 325 const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); 326 ASSERT_EQ(1U, results2.size()); 327 328 // Add a new profile. 329 AutofillProfile profile1; 330 autofill_test::SetProfileInfo(&profile1, 331 "y", "", "", "", "", "", "", "", "", "", "", "", ""); 332 update.clear(); 333 update.push_back(*results2[0]); 334 update.push_back(profile1); 335 personal_data_->SetProfiles(&update); 336 337 // Make sure the two profiles have different ids (and neither equal to 0, 338 // which is an invalid id). 339 const std::vector<AutofillProfile*>& results3 = personal_data_->profiles(); 340 ASSERT_EQ(2U, results3.size()); 341 EXPECT_NE(results3[0]->guid(), results3[1]->guid()); 342 EXPECT_TRUE(guid::IsValidGUID(results3[0]->guid())); 343 EXPECT_TRUE(guid::IsValidGUID(results3[1]->guid())); 344 } 345 346 TEST_F(PersonalDataManagerTest, SetEmptyProfile) { 347 AutofillProfile profile0; 348 autofill_test::SetProfileInfo(&profile0, 349 "", "", "", "", "", "", "", "", "", "", "", "", ""); 350 351 // This will verify that the web database has been loaded and the notification 352 // sent out. 353 EXPECT_CALL(personal_data_observer_, 354 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 355 356 // The message loop will exit when the mock observer is notified. 357 MessageLoop::current()->Run(); 358 359 // Add the empty profile to the database. 360 std::vector<AutofillProfile> update; 361 update.push_back(profile0); 362 personal_data_->SetProfiles(&update); 363 364 // Check the local store of profiles, not yet saved to the web database. 365 const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); 366 ASSERT_EQ(0U, results1.size()); 367 368 // Reset the PersonalDataManager. This tests that the personal data was saved 369 // to the web database, and that we can load the profiles from the web 370 // database. 371 ResetPersonalDataManager(); 372 373 // This will verify that the web database has been loaded and the notification 374 // sent out. 375 EXPECT_CALL(personal_data_observer_, 376 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 377 378 // The message loop will exit when the PersonalDataLoadedObserver is notified. 379 MessageLoop::current()->Run(); 380 381 // Verify that we've loaded the profiles from the web database. 382 const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); 383 ASSERT_EQ(0U, results2.size()); 384 } 385 386 TEST_F(PersonalDataManagerTest, SetEmptyCreditCard) { 387 CreditCard creditcard0; 388 autofill_test::SetCreditCardInfo(&creditcard0, "", "", "", ""); 389 390 // This will verify that the web database has been loaded and the notification 391 // sent out. 392 EXPECT_CALL(personal_data_observer_, 393 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 394 395 // The message loop will exit when the mock observer is notified. 396 MessageLoop::current()->Run(); 397 398 // Add the empty credit card to the database. 399 std::vector<CreditCard> update; 400 update.push_back(creditcard0); 401 personal_data_->SetCreditCards(&update); 402 403 // Check the local store of credit cards, not yet saved to the web database. 404 const std::vector<CreditCard*>& results1 = personal_data_->credit_cards(); 405 ASSERT_EQ(0U, results1.size()); 406 407 // Reset the PersonalDataManager. This tests that the personal data was saved 408 // to the web database, and that we can load the credit cards from the web 409 // database. 410 ResetPersonalDataManager(); 411 412 // This will verify that the web database has been loaded and the notification 413 // sent out. 414 EXPECT_CALL(personal_data_observer_, 415 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 416 417 // The message loop will exit when the PersonalDataLoadedObserver is notified. 418 MessageLoop::current()->Run(); 419 420 // Verify that we've loaded the credit cards from the web database. 421 const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); 422 ASSERT_EQ(0U, results2.size()); 423 } 424 425 TEST_F(PersonalDataManagerTest, Refresh) { 426 AutofillProfile profile0; 427 autofill_test::SetProfileInfo(&profile0, 428 "Marion", "Mitchell", "Morrison", 429 "johnwayne (at) me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 430 "91601", "US", "12345678910", "01987654321"); 431 432 AutofillProfile profile1; 433 autofill_test::SetProfileInfo(&profile1, 434 "Josephine", "Alicia", "Saenz", 435 "joewayne (at) me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", 436 "US", "19482937549", "13502849239"); 437 438 EXPECT_CALL(personal_data_observer_, 439 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 440 441 MessageLoop::current()->Run(); 442 443 // Add the test profiles to the database. 444 std::vector<AutofillProfile> update; 445 update.push_back(profile0); 446 update.push_back(profile1); 447 personal_data_->SetProfiles(&update); 448 449 // Labels depend on other profiles in the list - update labels manually. 450 std::vector<AutofillProfile *> profile_pointers; 451 profile_pointers.push_back(&profile0); 452 profile_pointers.push_back(&profile1); 453 AutofillProfile::AdjustInferredLabels(&profile_pointers); 454 455 // Wait for the refresh. 456 EXPECT_CALL(personal_data_observer_, 457 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 458 459 MessageLoop::current()->Run(); 460 461 const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); 462 ASSERT_EQ(2U, results1.size()); 463 EXPECT_EQ(profile0, *results1.at(0)); 464 EXPECT_EQ(profile1, *results1.at(1)); 465 466 AutofillProfile profile2; 467 autofill_test::SetProfileInfo(&profile2, 468 "Josephine", "Alicia", "Saenz", 469 "joewayne (at) me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL", 470 "32801", "US", "19482937549", "13502849239"); 471 472 // Adjust all labels. 473 profile_pointers.push_back(&profile2); 474 AutofillProfile::AdjustInferredLabels(&profile_pointers); 475 476 WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS); 477 ASSERT_TRUE(wds); 478 wds->AddAutofillProfile(profile2); 479 480 personal_data_->Refresh(); 481 482 // Wait for the refresh. 483 EXPECT_CALL(personal_data_observer_, 484 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 485 486 MessageLoop::current()->Run(); 487 488 const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); 489 ASSERT_EQ(3U, results2.size()); 490 EXPECT_EQ(profile0, *results2.at(0)); 491 EXPECT_EQ(profile1, *results2.at(1)); 492 EXPECT_EQ(profile2, *results2.at(2)); 493 494 wds->RemoveAutofillProfile(profile1.guid()); 495 wds->RemoveAutofillProfile(profile2.guid()); 496 497 // Before telling the PDM to refresh, simulate an edit to one of the profiles 498 // via a SetProfile update (this would happen if the Autofill window was 499 // open with a previous snapshot of the profiles, and something [e.g. sync] 500 // removed a profile from the browser. In this edge case, we will end up 501 // in a consistent state by dropping the write). 502 profile2.SetInfo(NAME_FIRST, ASCIIToUTF16("Jo")); 503 update.clear(); 504 update.push_back(profile0); 505 update.push_back(profile1); 506 update.push_back(profile2); 507 personal_data_->SetProfiles(&update); 508 509 // Wait for the refresh. 510 EXPECT_CALL(personal_data_observer_, 511 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 512 513 MessageLoop::current()->Run(); 514 515 const std::vector<AutofillProfile*>& results3 = personal_data_->profiles(); 516 ASSERT_EQ(1U, results3.size()); 517 EXPECT_EQ(profile0, *results2.at(0)); 518 } 519 520 TEST_F(PersonalDataManagerTest, ImportFormData) { 521 FormData form; 522 webkit_glue::FormField field; 523 autofill_test::CreateTestFormField( 524 "First name:", "first_name", "George", "text", &field); 525 form.fields.push_back(field); 526 autofill_test::CreateTestFormField( 527 "Last name:", "last_name", "Washington", "text", &field); 528 form.fields.push_back(field); 529 autofill_test::CreateTestFormField( 530 "Email:", "email", "theprez (at) gmail.com", "text", &field); 531 form.fields.push_back(field); 532 autofill_test::CreateTestFormField( 533 "Address:", "address1", "21 Laussat St", "text", &field); 534 form.fields.push_back(field); 535 autofill_test::CreateTestFormField( 536 "City:", "city", "San Francisco", "text", &field); 537 form.fields.push_back(field); 538 autofill_test::CreateTestFormField( 539 "State:", "state", "California", "text", &field); 540 form.fields.push_back(field); 541 autofill_test::CreateTestFormField( 542 "Zip:", "zip", "94102", "text", &field); 543 form.fields.push_back(field); 544 FormStructure form_structure(form); 545 form_structure.DetermineHeuristicTypes(); 546 std::vector<const FormStructure*> forms; 547 forms.push_back(&form_structure); 548 const CreditCard* imported_credit_card; 549 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 550 ASSERT_FALSE(imported_credit_card); 551 552 // Wait for the refresh. 553 EXPECT_CALL(personal_data_observer_, 554 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 555 556 MessageLoop::current()->Run(); 557 558 AutofillProfile expected; 559 autofill_test::SetProfileInfo(&expected, "George", NULL, 560 "Washington", "theprez (at) gmail.com", NULL, "21 Laussat St", NULL, 561 "San Francisco", "California", "94102", NULL, NULL, NULL); 562 const std::vector<AutofillProfile*>& results = personal_data_->profiles(); 563 ASSERT_EQ(1U, results.size()); 564 EXPECT_EQ(0, expected.Compare(*results[0])); 565 } 566 567 TEST_F(PersonalDataManagerTest, ImportFormDataBadEmail) { 568 FormData form; 569 webkit_glue::FormField field; 570 autofill_test::CreateTestFormField( 571 "First name:", "first_name", "George", "text", &field); 572 form.fields.push_back(field); 573 autofill_test::CreateTestFormField( 574 "Last name:", "last_name", "Washington", "text", &field); 575 form.fields.push_back(field); 576 autofill_test::CreateTestFormField( 577 "Email:", "email", "bogus", "text", &field); 578 form.fields.push_back(field); 579 autofill_test::CreateTestFormField( 580 "Address:", "address1", "21 Laussat St", "text", &field); 581 form.fields.push_back(field); 582 autofill_test::CreateTestFormField( 583 "City:", "city", "San Francisco", "text", &field); 584 form.fields.push_back(field); 585 autofill_test::CreateTestFormField( 586 "State:", "state", "California", "text", &field); 587 form.fields.push_back(field); 588 autofill_test::CreateTestFormField( 589 "Zip:", "zip", "94102", "text", &field); 590 form.fields.push_back(field); 591 FormStructure form_structure(form); 592 form_structure.DetermineHeuristicTypes(); 593 std::vector<const FormStructure*> forms; 594 forms.push_back(&form_structure); 595 const CreditCard* imported_credit_card; 596 EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); 597 ASSERT_EQ(static_cast<CreditCard*>(NULL), imported_credit_card); 598 599 // Wait for the refresh. 600 EXPECT_CALL(personal_data_observer_, 601 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 602 603 MessageLoop::current()->Run(); 604 605 const std::vector<AutofillProfile*>& results = personal_data_->profiles(); 606 ASSERT_EQ(0U, results.size()); 607 } 608 609 TEST_F(PersonalDataManagerTest, ImportFormDataNotEnoughFilledFields) { 610 FormData form; 611 webkit_glue::FormField field; 612 autofill_test::CreateTestFormField( 613 "First name:", "first_name", "George", "text", &field); 614 form.fields.push_back(field); 615 autofill_test::CreateTestFormField( 616 "Last name:", "last_name", "Washington", "text", &field); 617 form.fields.push_back(field); 618 autofill_test::CreateTestFormField( 619 "Card number:", "card_number", "4111 1111 1111 1111", "text", &field); 620 form.fields.push_back(field); 621 FormStructure form_structure(form); 622 form_structure.DetermineHeuristicTypes(); 623 std::vector<const FormStructure*> forms; 624 forms.push_back(&form_structure); 625 const CreditCard* imported_credit_card; 626 EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); 627 ASSERT_FALSE(imported_credit_card); 628 629 // Wait for the refresh. 630 EXPECT_CALL(personal_data_observer_, 631 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 632 633 MessageLoop::current()->Run(); 634 635 const std::vector<AutofillProfile*>& profiles = personal_data_->profiles(); 636 ASSERT_EQ(0U, profiles.size()); 637 const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards(); 638 ASSERT_EQ(0U, credit_cards.size()); 639 } 640 641 TEST_F(PersonalDataManagerTest, ImportPhoneNumberSplitAcrossMultipleFields) { 642 FormData form; 643 webkit_glue::FormField field; 644 autofill_test::CreateTestFormField( 645 "First name:", "first_name", "George", "text", &field); 646 form.fields.push_back(field); 647 autofill_test::CreateTestFormField( 648 "Last name:", "last_name", "Washington", "text", &field); 649 form.fields.push_back(field); 650 autofill_test::CreateTestFormField( 651 "Phone #:", "home_phone_area_code", "650", "text", &field); 652 field.max_length = 3; 653 form.fields.push_back(field); 654 autofill_test::CreateTestFormField( 655 "Phone #:", "home_phone_prefix", "555", "text", &field); 656 field.max_length = 3; 657 form.fields.push_back(field); 658 autofill_test::CreateTestFormField( 659 "Phone #:", "home_phone_suffix", "0000", "text", &field); 660 field.max_length = 4; 661 form.fields.push_back(field); 662 autofill_test::CreateTestFormField( 663 "Address:", "address1", "21 Laussat St", "text", &field); 664 form.fields.push_back(field); 665 autofill_test::CreateTestFormField( 666 "City:", "city", "San Francisco", "text", &field); 667 form.fields.push_back(field); 668 autofill_test::CreateTestFormField( 669 "State:", "state", "California", "text", &field); 670 form.fields.push_back(field); 671 autofill_test::CreateTestFormField( 672 "Zip:", "zip", "94102", "text", &field); 673 form.fields.push_back(field); 674 FormStructure form_structure(form); 675 form_structure.DetermineHeuristicTypes(); 676 std::vector<const FormStructure*> forms; 677 forms.push_back(&form_structure); 678 const CreditCard* imported_credit_card; 679 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 680 ASSERT_FALSE(imported_credit_card); 681 682 // Wait for the refresh. 683 EXPECT_CALL(personal_data_observer_, 684 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 685 686 MessageLoop::current()->Run(); 687 688 AutofillProfile expected; 689 autofill_test::SetProfileInfo(&expected, "George", NULL, 690 "Washington", NULL, NULL, "21 Laussat St", NULL, 691 "San Francisco", "California", "94102", NULL, "6505550000", NULL); 692 const std::vector<AutofillProfile*>& results = personal_data_->profiles(); 693 ASSERT_EQ(1U, results.size()); 694 EXPECT_EQ(0, expected.Compare(*results[0])); 695 } 696 697 TEST_F(PersonalDataManagerTest, SetUniqueCreditCardLabels) { 698 CreditCard credit_card0; 699 credit_card0.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("John")); 700 CreditCard credit_card1; 701 credit_card1.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Paul")); 702 CreditCard credit_card2; 703 credit_card2.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Ringo")); 704 CreditCard credit_card3; 705 credit_card3.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Other")); 706 CreditCard credit_card4; 707 credit_card4.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Ozzy")); 708 CreditCard credit_card5; 709 credit_card5.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Dio")); 710 711 // This will verify that the web database has been loaded and the notification 712 // sent out. 713 EXPECT_CALL(personal_data_observer_, 714 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 715 716 // The message loop will exit when the mock observer is notified. 717 MessageLoop::current()->Run(); 718 719 // Add the test credit cards to the database. 720 std::vector<CreditCard> update; 721 update.push_back(credit_card0); 722 update.push_back(credit_card1); 723 update.push_back(credit_card2); 724 update.push_back(credit_card3); 725 update.push_back(credit_card4); 726 update.push_back(credit_card5); 727 personal_data_->SetCreditCards(&update); 728 729 // Reset the PersonalDataManager. This tests that the personal data was saved 730 // to the web database, and that we can load the credit cards from the web 731 // database. 732 ResetPersonalDataManager(); 733 734 // This will verify that the web database has been loaded and the notification 735 // sent out. 736 EXPECT_CALL(personal_data_observer_, 737 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 738 739 // The message loop will exit when the mock observer is notified. 740 MessageLoop::current()->Run(); 741 742 const std::vector<CreditCard*>& results = personal_data_->credit_cards(); 743 ASSERT_EQ(6U, results.size()); 744 EXPECT_EQ(credit_card0.guid(), results[0]->guid()); 745 EXPECT_EQ(credit_card1.guid(), results[1]->guid()); 746 EXPECT_EQ(credit_card2.guid(), results[2]->guid()); 747 EXPECT_EQ(credit_card3.guid(), results[3]->guid()); 748 EXPECT_EQ(credit_card4.guid(), results[4]->guid()); 749 EXPECT_EQ(credit_card5.guid(), results[5]->guid()); 750 } 751 752 TEST_F(PersonalDataManagerTest, AggregateTwoDifferentProfiles) { 753 FormData form1; 754 webkit_glue::FormField field; 755 autofill_test::CreateTestFormField( 756 "First name:", "first_name", "George", "text", &field); 757 form1.fields.push_back(field); 758 autofill_test::CreateTestFormField( 759 "Last name:", "last_name", "Washington", "text", &field); 760 form1.fields.push_back(field); 761 autofill_test::CreateTestFormField( 762 "Email:", "email", "theprez (at) gmail.com", "text", &field); 763 form1.fields.push_back(field); 764 autofill_test::CreateTestFormField( 765 "Address:", "address1", "21 Laussat St", "text", &field); 766 form1.fields.push_back(field); 767 autofill_test::CreateTestFormField( 768 "City:", "city", "San Francisco", "text", &field); 769 form1.fields.push_back(field); 770 autofill_test::CreateTestFormField( 771 "State:", "state", "California", "text", &field); 772 form1.fields.push_back(field); 773 autofill_test::CreateTestFormField( 774 "Zip:", "zip", "94102", "text", &field); 775 form1.fields.push_back(field); 776 777 FormStructure form_structure1(form1); 778 form_structure1.DetermineHeuristicTypes(); 779 std::vector<const FormStructure*> forms; 780 forms.push_back(&form_structure1); 781 const CreditCard* imported_credit_card; 782 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 783 ASSERT_FALSE(imported_credit_card); 784 785 // Wait for the refresh. 786 EXPECT_CALL(personal_data_observer_, 787 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 788 789 MessageLoop::current()->Run(); 790 791 AutofillProfile expected; 792 autofill_test::SetProfileInfo(&expected, "George", NULL, 793 "Washington", "theprez (at) gmail.com", NULL, "21 Laussat St", NULL, 794 "San Francisco", "California", "94102", NULL, NULL, NULL); 795 const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); 796 ASSERT_EQ(1U, results1.size()); 797 EXPECT_EQ(0, expected.Compare(*results1[0])); 798 799 // Now create a completely different profile. 800 FormData form2; 801 autofill_test::CreateTestFormField( 802 "First name:", "first_name", "John", "text", &field); 803 form2.fields.push_back(field); 804 autofill_test::CreateTestFormField( 805 "Last name:", "last_name", "Adams", "text", &field); 806 form2.fields.push_back(field); 807 autofill_test::CreateTestFormField( 808 "Email:", "email", "second (at) gmail.com", "text", &field); 809 form2.fields.push_back(field); 810 autofill_test::CreateTestFormField( 811 "Address:", "address1", "22 Laussat St", "text", &field); 812 form2.fields.push_back(field); 813 autofill_test::CreateTestFormField( 814 "City:", "city", "San Francisco", "text", &field); 815 form2.fields.push_back(field); 816 autofill_test::CreateTestFormField( 817 "State:", "state", "California", "text", &field); 818 form2.fields.push_back(field); 819 autofill_test::CreateTestFormField( 820 "Zip:", "zip", "94102", "text", &field); 821 form2.fields.push_back(field); 822 823 FormStructure form_structure2(form2); 824 form_structure2.DetermineHeuristicTypes(); 825 forms.clear(); 826 forms.push_back(&form_structure2); 827 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 828 ASSERT_FALSE(imported_credit_card); 829 830 // Wait for the refresh. 831 EXPECT_CALL(personal_data_observer_, 832 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 833 834 MessageLoop::current()->Run(); 835 836 const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); 837 838 AutofillProfile expected2; 839 autofill_test::SetProfileInfo(&expected2, "John", NULL, 840 "Adams", "second (at) gmail.com", NULL, "22 Laussat St", NULL, 841 "San Francisco", "California", "94102", NULL, NULL, NULL); 842 ASSERT_EQ(2U, results2.size()); 843 EXPECT_EQ(0, expected.Compare(*results2[0])); 844 EXPECT_EQ(0, expected2.Compare(*results2[1])); 845 } 846 847 TEST_F(PersonalDataManagerTest, AggregateTwoProfilesWithMultiValue) { 848 FormData form1; 849 webkit_glue::FormField field; 850 autofill_test::CreateTestFormField( 851 "First name:", "first_name", "George", "text", &field); 852 form1.fields.push_back(field); 853 autofill_test::CreateTestFormField( 854 "Last name:", "last_name", "Washington", "text", &field); 855 form1.fields.push_back(field); 856 autofill_test::CreateTestFormField( 857 "Email:", "email", "theprez (at) gmail.com", "text", &field); 858 form1.fields.push_back(field); 859 autofill_test::CreateTestFormField( 860 "Address:", "address1", "21 Laussat St", "text", &field); 861 form1.fields.push_back(field); 862 autofill_test::CreateTestFormField( 863 "City:", "city", "San Francisco", "text", &field); 864 form1.fields.push_back(field); 865 autofill_test::CreateTestFormField( 866 "State:", "state", "California", "text", &field); 867 form1.fields.push_back(field); 868 autofill_test::CreateTestFormField( 869 "Zip:", "zip", "94102", "text", &field); 870 form1.fields.push_back(field); 871 872 FormStructure form_structure1(form1); 873 form_structure1.DetermineHeuristicTypes(); 874 std::vector<const FormStructure*> forms; 875 forms.push_back(&form_structure1); 876 const CreditCard* imported_credit_card; 877 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 878 ASSERT_FALSE(imported_credit_card); 879 880 // Wait for the refresh. 881 EXPECT_CALL(personal_data_observer_, 882 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 883 884 MessageLoop::current()->Run(); 885 886 AutofillProfile expected; 887 autofill_test::SetProfileInfo(&expected, "George", NULL, 888 "Washington", "theprez (at) gmail.com", NULL, "21 Laussat St", NULL, 889 "San Francisco", "California", "94102", NULL, NULL, NULL); 890 const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); 891 ASSERT_EQ(1U, results1.size()); 892 EXPECT_EQ(0, expected.Compare(*results1[0])); 893 894 // Now create a completely different profile. 895 FormData form2; 896 autofill_test::CreateTestFormField( 897 "First name:", "first_name", "John", "text", &field); 898 form2.fields.push_back(field); 899 autofill_test::CreateTestFormField( 900 "Last name:", "last_name", "Adams", "text", &field); 901 form2.fields.push_back(field); 902 autofill_test::CreateTestFormField( 903 "Email:", "email", "second (at) gmail.com", "text", &field); 904 form2.fields.push_back(field); 905 autofill_test::CreateTestFormField( 906 "Address:", "address1", "21 Laussat St", "text", &field); 907 form2.fields.push_back(field); 908 autofill_test::CreateTestFormField( 909 "City:", "city", "San Francisco", "text", &field); 910 form2.fields.push_back(field); 911 autofill_test::CreateTestFormField( 912 "State:", "state", "California", "text", &field); 913 form2.fields.push_back(field); 914 autofill_test::CreateTestFormField( 915 "Zip:", "zip", "94102", "text", &field); 916 form2.fields.push_back(field); 917 918 FormStructure form_structure2(form2); 919 form_structure2.DetermineHeuristicTypes(); 920 forms.clear(); 921 forms.push_back(&form_structure2); 922 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 923 ASSERT_FALSE(imported_credit_card); 924 925 // Wait for the refresh. 926 EXPECT_CALL(personal_data_observer_, 927 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 928 929 MessageLoop::current()->Run(); 930 931 const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); 932 933 // Modify expected to include multi-valued fields. 934 std::vector<string16> values; 935 expected.GetMultiInfo(NAME_FULL, &values); 936 values.push_back(ASCIIToUTF16("John Adams")); 937 expected.SetMultiInfo(NAME_FULL, values); 938 expected.GetMultiInfo(EMAIL_ADDRESS, &values); 939 values.push_back(ASCIIToUTF16("second (at) gmail.com")); 940 expected.SetMultiInfo(EMAIL_ADDRESS, values); 941 942 ASSERT_EQ(1U, results2.size()); 943 EXPECT_EQ(0, expected.CompareMulti(*results2[0])); 944 } 945 946 TEST_F(PersonalDataManagerTest, AggregateSameProfileWithConflict) { 947 FormData form1; 948 webkit_glue::FormField field; 949 autofill_test::CreateTestFormField( 950 "First name:", "first_name", "George", "text", &field); 951 form1.fields.push_back(field); 952 autofill_test::CreateTestFormField( 953 "Last name:", "last_name", "Washington", "text", &field); 954 form1.fields.push_back(field); 955 autofill_test::CreateTestFormField( 956 "Address:", "address", "1600 Pennsylvania Avenue", "text", &field); 957 form1.fields.push_back(field); 958 autofill_test::CreateTestFormField( 959 "Address Line 2:", "address2", "Suite A", "text", &field); 960 form1.fields.push_back(field); 961 autofill_test::CreateTestFormField( 962 "City:", "city", "San Francisco", "text", &field); 963 form1.fields.push_back(field); 964 autofill_test::CreateTestFormField( 965 "State:", "state", "California", "text", &field); 966 form1.fields.push_back(field); 967 autofill_test::CreateTestFormField( 968 "Zip:", "zip", "94102", "text", &field); 969 form1.fields.push_back(field); 970 autofill_test::CreateTestFormField( 971 "Email:", "email", "theprez (at) gmail.com", "text", &field); 972 form1.fields.push_back(field); 973 // Phone gets updated. 974 autofill_test::CreateTestFormField( 975 "Phone:", "phone", "4445556666", "text", &field); 976 form1.fields.push_back(field); 977 978 FormStructure form_structure1(form1); 979 form_structure1.DetermineHeuristicTypes(); 980 std::vector<const FormStructure*> forms; 981 forms.push_back(&form_structure1); 982 const CreditCard* imported_credit_card; 983 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 984 ASSERT_FALSE(imported_credit_card); 985 986 // Wait for the refresh. 987 EXPECT_CALL(personal_data_observer_, 988 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 989 990 MessageLoop::current()->Run(); 991 992 AutofillProfile expected; 993 autofill_test::SetProfileInfo(&expected, "George", NULL, 994 "Washington", "theprez (at) gmail.com", NULL, "1600 Pennsylvania Avenue", 995 "Suite A", "San Francisco", "California", "94102", NULL, "4445556666", 996 NULL); 997 const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); 998 ASSERT_EQ(1U, results1.size()); 999 EXPECT_EQ(0, expected.Compare(*results1[0])); 1000 1001 // Now create an updated profile. 1002 FormData form2; 1003 autofill_test::CreateTestFormField( 1004 "First name:", "first_name", "George", "text", &field); 1005 form2.fields.push_back(field); 1006 autofill_test::CreateTestFormField( 1007 "Last name:", "last_name", "Washington", "text", &field); 1008 form2.fields.push_back(field); 1009 autofill_test::CreateTestFormField( 1010 "Address:", "address", "1600 Pennsylvania Avenue", "text", &field); 1011 form2.fields.push_back(field); 1012 autofill_test::CreateTestFormField( 1013 "Address Line 2:", "address2", "Suite A", "text", &field); 1014 form2.fields.push_back(field); 1015 autofill_test::CreateTestFormField( 1016 "City:", "city", "San Francisco", "text", &field); 1017 form2.fields.push_back(field); 1018 autofill_test::CreateTestFormField( 1019 "State:", "state", "California", "text", &field); 1020 form2.fields.push_back(field); 1021 autofill_test::CreateTestFormField( 1022 "Zip:", "zip", "94102", "text", &field); 1023 form2.fields.push_back(field); 1024 autofill_test::CreateTestFormField( 1025 "Email:", "email", "theprez (at) gmail.com", "text", &field); 1026 form2.fields.push_back(field); 1027 // Country gets added. 1028 autofill_test::CreateTestFormField( 1029 "Country:", "country", "USA", "text", &field); 1030 form2.fields.push_back(field); 1031 // Phone gets updated. 1032 autofill_test::CreateTestFormField( 1033 "Phone:", "phone", "1231231234", "text", &field); 1034 form2.fields.push_back(field); 1035 1036 FormStructure form_structure2(form2); 1037 form_structure2.DetermineHeuristicTypes(); 1038 forms.clear(); 1039 forms.push_back(&form_structure2); 1040 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1041 ASSERT_FALSE(imported_credit_card); 1042 1043 // Wait for the refresh. 1044 EXPECT_CALL(personal_data_observer_, 1045 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1046 1047 MessageLoop::current()->Run(); 1048 1049 const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); 1050 1051 // Add multi-valued phone number to expectation. Also, country gets added. 1052 std::vector<string16> values; 1053 expected.GetMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values); 1054 values.push_back(ASCIIToUTF16("1231231234")); 1055 expected.SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, values); 1056 expected.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("United States")); 1057 ASSERT_EQ(1U, results2.size()); 1058 EXPECT_EQ(0, expected.CompareMulti(*results2[0])); 1059 } 1060 1061 TEST_F(PersonalDataManagerTest, AggregateProfileWithMissingInfoInOld) { 1062 FormData form1; 1063 webkit_glue::FormField field; 1064 autofill_test::CreateTestFormField( 1065 "First name:", "first_name", "George", "text", &field); 1066 form1.fields.push_back(field); 1067 autofill_test::CreateTestFormField( 1068 "Last name:", "last_name", "Washington", "text", &field); 1069 form1.fields.push_back(field); 1070 autofill_test::CreateTestFormField( 1071 "Address Line 1:", "address", "190 High Street", "text", &field); 1072 form1.fields.push_back(field); 1073 autofill_test::CreateTestFormField( 1074 "City:", "city", "Philadelphia", "text", &field); 1075 form1.fields.push_back(field); 1076 autofill_test::CreateTestFormField( 1077 "State:", "state", "Pennsylvania", "text", &field); 1078 form1.fields.push_back(field); 1079 autofill_test::CreateTestFormField( 1080 "Zip:", "zipcode", "19106", "text", &field); 1081 form1.fields.push_back(field); 1082 1083 FormStructure form_structure1(form1); 1084 form_structure1.DetermineHeuristicTypes(); 1085 std::vector<const FormStructure*> forms; 1086 forms.push_back(&form_structure1); 1087 const CreditCard* imported_credit_card; 1088 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1089 ASSERT_FALSE(imported_credit_card); 1090 1091 // Wait for the refresh. 1092 EXPECT_CALL(personal_data_observer_, 1093 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1094 1095 MessageLoop::current()->Run(); 1096 1097 AutofillProfile expected; 1098 autofill_test::SetProfileInfo(&expected, "George", NULL, 1099 "Washington", NULL, NULL, "190 High Street", NULL, 1100 "Philadelphia", "Pennsylvania", "19106", NULL, NULL, NULL); 1101 const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); 1102 ASSERT_EQ(1U, results1.size()); 1103 EXPECT_EQ(0, expected.Compare(*results1[0])); 1104 1105 // Submit a form with new data for the first profile. 1106 FormData form2; 1107 autofill_test::CreateTestFormField( 1108 "First name:", "first_name", "George", "text", &field); 1109 form2.fields.push_back(field); 1110 autofill_test::CreateTestFormField( 1111 "Last name:", "last_name", "Washington", "text", &field); 1112 form2.fields.push_back(field); 1113 autofill_test::CreateTestFormField( 1114 "Email:", "email", "theprez (at) gmail.com", "text", &field); 1115 form2.fields.push_back(field); 1116 autofill_test::CreateTestFormField( 1117 "Address Line 1:", "address", "190 High Street", "text", &field); 1118 form2.fields.push_back(field); 1119 autofill_test::CreateTestFormField( 1120 "City:", "city", "Philadelphia", "text", &field); 1121 form2.fields.push_back(field); 1122 autofill_test::CreateTestFormField( 1123 "State:", "state", "Pennsylvania", "text", &field); 1124 form2.fields.push_back(field); 1125 autofill_test::CreateTestFormField( 1126 "Zip:", "zipcode", "19106", "text", &field); 1127 form2.fields.push_back(field); 1128 1129 FormStructure form_structure2(form2); 1130 form_structure2.DetermineHeuristicTypes(); 1131 forms.clear(); 1132 forms.push_back(&form_structure2); 1133 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1134 ASSERT_FALSE(imported_credit_card); 1135 1136 // Wait for the refresh. 1137 EXPECT_CALL(personal_data_observer_, 1138 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1139 1140 MessageLoop::current()->Run(); 1141 1142 const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); 1143 1144 AutofillProfile expected2; 1145 autofill_test::SetProfileInfo(&expected2, "George", NULL, 1146 "Washington", "theprez (at) gmail.com", NULL, "190 High Street", NULL, 1147 "Philadelphia", "Pennsylvania", "19106", NULL, NULL, NULL); 1148 ASSERT_EQ(1U, results2.size()); 1149 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1150 } 1151 1152 TEST_F(PersonalDataManagerTest, AggregateProfileWithMissingInfoInNew) { 1153 FormData form1; 1154 webkit_glue::FormField field; 1155 autofill_test::CreateTestFormField( 1156 "First name:", "first_name", "George", "text", &field); 1157 form1.fields.push_back(field); 1158 autofill_test::CreateTestFormField( 1159 "Last name:", "last_name", "Washington", "text", &field); 1160 form1.fields.push_back(field); 1161 autofill_test::CreateTestFormField( 1162 "Company:", "company", "Government", "text", &field); 1163 form1.fields.push_back(field); 1164 autofill_test::CreateTestFormField( 1165 "Email:", "email", "theprez (at) gmail.com", "text", &field); 1166 form1.fields.push_back(field); 1167 autofill_test::CreateTestFormField( 1168 "Address Line 1:", "address", "190 High Street", "text", &field); 1169 form1.fields.push_back(field); 1170 autofill_test::CreateTestFormField( 1171 "City:", "city", "Philadelphia", "text", &field); 1172 form1.fields.push_back(field); 1173 autofill_test::CreateTestFormField( 1174 "State:", "state", "Pennsylvania", "text", &field); 1175 form1.fields.push_back(field); 1176 autofill_test::CreateTestFormField( 1177 "Zip:", "zipcode", "19106", "text", &field); 1178 form1.fields.push_back(field); 1179 1180 FormStructure form_structure1(form1); 1181 form_structure1.DetermineHeuristicTypes(); 1182 std::vector<const FormStructure*> forms; 1183 forms.push_back(&form_structure1); 1184 const CreditCard* imported_credit_card; 1185 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1186 ASSERT_FALSE(imported_credit_card); 1187 1188 // Wait for the refresh. 1189 EXPECT_CALL(personal_data_observer_, 1190 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1191 1192 MessageLoop::current()->Run(); 1193 1194 AutofillProfile expected; 1195 autofill_test::SetProfileInfo(&expected, "George", NULL, 1196 "Washington", "theprez (at) gmail.com", "Government", "190 High Street", NULL, 1197 "Philadelphia", "Pennsylvania", "19106", NULL, NULL, NULL); 1198 const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); 1199 ASSERT_EQ(1U, results1.size()); 1200 EXPECT_EQ(0, expected.Compare(*results1[0])); 1201 1202 // Submit a form with new data for the first profile. 1203 FormData form2; 1204 autofill_test::CreateTestFormField( 1205 "First name:", "first_name", "George", "text", &field); 1206 form2.fields.push_back(field); 1207 autofill_test::CreateTestFormField( 1208 "Last name:", "last_name", "Washington", "text", &field); 1209 form2.fields.push_back(field); 1210 // Note missing Company field. 1211 autofill_test::CreateTestFormField( 1212 "Email:", "email", "theprez (at) gmail.com", "text", &field); 1213 form2.fields.push_back(field); 1214 autofill_test::CreateTestFormField( 1215 "Address Line 1:", "address", "190 High Street", "text", &field); 1216 form2.fields.push_back(field); 1217 autofill_test::CreateTestFormField( 1218 "City:", "city", "Philadelphia", "text", &field); 1219 form2.fields.push_back(field); 1220 autofill_test::CreateTestFormField( 1221 "State:", "state", "Pennsylvania", "text", &field); 1222 form2.fields.push_back(field); 1223 autofill_test::CreateTestFormField( 1224 "Zip:", "zipcode", "19106", "text", &field); 1225 form2.fields.push_back(field); 1226 1227 FormStructure form_structure2(form2); 1228 form_structure2.DetermineHeuristicTypes(); 1229 forms.clear(); 1230 forms.push_back(&form_structure2); 1231 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1232 ASSERT_FALSE(imported_credit_card); 1233 1234 // Wait for the refresh. 1235 EXPECT_CALL(personal_data_observer_, 1236 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1237 1238 MessageLoop::current()->Run(); 1239 1240 const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); 1241 1242 // Expect no change. 1243 ASSERT_EQ(1U, results2.size()); 1244 EXPECT_EQ(0, expected.Compare(*results2[0])); 1245 } 1246 1247 TEST_F(PersonalDataManagerTest, AggregateProfileWithInsufficientAddress) { 1248 FormData form1; 1249 webkit_glue::FormField field; 1250 autofill_test::CreateTestFormField( 1251 "First name:", "first_name", "George", "text", &field); 1252 form1.fields.push_back(field); 1253 autofill_test::CreateTestFormField( 1254 "Last name:", "last_name", "Washington", "text", &field); 1255 form1.fields.push_back(field); 1256 autofill_test::CreateTestFormField( 1257 "Company:", "company", "Government", "text", &field); 1258 form1.fields.push_back(field); 1259 autofill_test::CreateTestFormField( 1260 "Email:", "email", "theprez (at) gmail.com", "text", &field); 1261 form1.fields.push_back(field); 1262 autofill_test::CreateTestFormField( 1263 "Address Line 1:", "address", "190 High Street", "text", &field); 1264 form1.fields.push_back(field); 1265 autofill_test::CreateTestFormField( 1266 "City:", "city", "Philadelphia", "text", &field); 1267 form1.fields.push_back(field); 1268 1269 FormStructure form_structure1(form1); 1270 form_structure1.DetermineHeuristicTypes(); 1271 std::vector<const FormStructure*> forms; 1272 forms.push_back(&form_structure1); 1273 const CreditCard* imported_credit_card; 1274 EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1275 ASSERT_FALSE(imported_credit_card); 1276 1277 // Wait for the refresh. 1278 EXPECT_CALL(personal_data_observer_, 1279 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1280 1281 MessageLoop::current()->Run(); 1282 1283 const std::vector<AutofillProfile*>& profiles = personal_data_->profiles(); 1284 ASSERT_EQ(0U, profiles.size()); 1285 const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards(); 1286 ASSERT_EQ(0U, credit_cards.size()); 1287 } 1288 1289 1290 TEST_F(PersonalDataManagerTest, AggregateTwoDifferentCreditCards) { 1291 FormData form1; 1292 1293 // Start with a single valid credit card form. 1294 webkit_glue::FormField field; 1295 autofill_test::CreateTestFormField( 1296 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1297 form1.fields.push_back(field); 1298 autofill_test::CreateTestFormField( 1299 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1300 form1.fields.push_back(field); 1301 autofill_test::CreateTestFormField( 1302 "Exp Month:", "exp_month", "01", "text", &field); 1303 form1.fields.push_back(field); 1304 autofill_test::CreateTestFormField( 1305 "Exp Year:", "exp_year", "2011", "text", &field); 1306 form1.fields.push_back(field); 1307 1308 FormStructure form_structure1(form1); 1309 form_structure1.DetermineHeuristicTypes(); 1310 std::vector<const FormStructure*> forms; 1311 forms.push_back(&form_structure1); 1312 const CreditCard* imported_credit_card; 1313 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1314 ASSERT_TRUE(imported_credit_card); 1315 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1316 delete imported_credit_card; 1317 1318 // Wait for the refresh. 1319 EXPECT_CALL(personal_data_observer_, 1320 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1321 1322 MessageLoop::current()->Run(); 1323 1324 CreditCard expected; 1325 autofill_test::SetCreditCardInfo(&expected, 1326 "Biggie Smalls", "4111111111111111", "01", "2011"); 1327 const std::vector<CreditCard*>& results = personal_data_->credit_cards(); 1328 ASSERT_EQ(1U, results.size()); 1329 EXPECT_EQ(0, expected.Compare(*results[0])); 1330 1331 // Add a second different valid credit card. 1332 FormData form2; 1333 autofill_test::CreateTestFormField( 1334 "Name on card:", "name_on_card", "Jim Johansen", "text", &field); 1335 form2.fields.push_back(field); 1336 autofill_test::CreateTestFormField( 1337 "Card Number:", "card_number", "5500 0000 0000 0004", "text", &field); 1338 form2.fields.push_back(field); 1339 autofill_test::CreateTestFormField( 1340 "Exp Month:", "exp_month", "02", "text", &field); 1341 form2.fields.push_back(field); 1342 autofill_test::CreateTestFormField( 1343 "Exp Year:", "exp_year", "2012", "text", &field); 1344 form2.fields.push_back(field); 1345 1346 FormStructure form_structure2(form2); 1347 form_structure2.DetermineHeuristicTypes(); 1348 forms.clear(); 1349 forms.push_back(&form_structure2); 1350 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1351 ASSERT_TRUE(imported_credit_card); 1352 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1353 delete imported_credit_card; 1354 1355 // Wait for the refresh. 1356 EXPECT_CALL(personal_data_observer_, 1357 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1358 1359 MessageLoop::current()->Run(); 1360 1361 CreditCard expected2; 1362 autofill_test::SetCreditCardInfo(&expected2, 1363 "Jim Johansen", "5500000000000004", "02", "2012"); 1364 const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); 1365 ASSERT_EQ(2U, results2.size()); 1366 EXPECT_EQ(0, expected.Compare(*results2[0])); 1367 EXPECT_EQ(0, expected2.Compare(*results2[1])); 1368 } 1369 1370 TEST_F(PersonalDataManagerTest, AggregateInvalidCreditCard) { 1371 FormData form1; 1372 1373 // Start with a single valid credit card form. 1374 webkit_glue::FormField field; 1375 autofill_test::CreateTestFormField( 1376 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1377 form1.fields.push_back(field); 1378 autofill_test::CreateTestFormField( 1379 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1380 form1.fields.push_back(field); 1381 autofill_test::CreateTestFormField( 1382 "Exp Month:", "exp_month", "01", "text", &field); 1383 form1.fields.push_back(field); 1384 autofill_test::CreateTestFormField( 1385 "Exp Year:", "exp_year", "2011", "text", &field); 1386 form1.fields.push_back(field); 1387 1388 FormStructure form_structure1(form1); 1389 form_structure1.DetermineHeuristicTypes(); 1390 std::vector<const FormStructure*> forms; 1391 forms.push_back(&form_structure1); 1392 const CreditCard* imported_credit_card; 1393 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1394 ASSERT_TRUE(imported_credit_card); 1395 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1396 delete imported_credit_card; 1397 1398 // Wait for the refresh. 1399 EXPECT_CALL(personal_data_observer_, 1400 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1401 1402 MessageLoop::current()->Run(); 1403 1404 CreditCard expected; 1405 autofill_test::SetCreditCardInfo(&expected, 1406 "Biggie Smalls", "4111111111111111", "01", "2011"); 1407 const std::vector<CreditCard*>& results = personal_data_->credit_cards(); 1408 ASSERT_EQ(1U, results.size()); 1409 EXPECT_EQ(0, expected.Compare(*results[0])); 1410 1411 // Add a second different invalid credit card. 1412 FormData form2; 1413 autofill_test::CreateTestFormField( 1414 "Name on card:", "name_on_card", "Jim Johansen", "text", &field); 1415 form2.fields.push_back(field); 1416 autofill_test::CreateTestFormField( 1417 "Card Number:", "card_number", "1000000000000000", "text", &field); 1418 form2.fields.push_back(field); 1419 autofill_test::CreateTestFormField( 1420 "Exp Month:", "exp_month", "02", "text", &field); 1421 form2.fields.push_back(field); 1422 autofill_test::CreateTestFormField( 1423 "Exp Year:", "exp_year", "2012", "text", &field); 1424 form2.fields.push_back(field); 1425 1426 FormStructure form_structure2(form2); 1427 form_structure2.DetermineHeuristicTypes(); 1428 forms.clear(); 1429 forms.push_back(&form_structure2); 1430 EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1431 ASSERT_FALSE(imported_credit_card); 1432 1433 // Note: no refresh here. 1434 1435 const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); 1436 ASSERT_EQ(1U, results2.size()); 1437 EXPECT_EQ(0, expected.Compare(*results2[0])); 1438 } 1439 1440 TEST_F(PersonalDataManagerTest, AggregateSameCreditCardWithConflict) { 1441 FormData form1; 1442 1443 // Start with a single valid credit card form. 1444 webkit_glue::FormField field; 1445 autofill_test::CreateTestFormField( 1446 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1447 form1.fields.push_back(field); 1448 autofill_test::CreateTestFormField( 1449 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1450 form1.fields.push_back(field); 1451 autofill_test::CreateTestFormField( 1452 "Exp Month:", "exp_month", "01", "text", &field); 1453 form1.fields.push_back(field); 1454 autofill_test::CreateTestFormField( 1455 "Exp Year:", "exp_year", "2011", "text", &field); 1456 form1.fields.push_back(field); 1457 1458 FormStructure form_structure1(form1); 1459 form_structure1.DetermineHeuristicTypes(); 1460 std::vector<const FormStructure*> forms; 1461 forms.push_back(&form_structure1); 1462 const CreditCard* imported_credit_card; 1463 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1464 ASSERT_TRUE(imported_credit_card); 1465 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1466 delete imported_credit_card; 1467 1468 // Wait for the refresh. 1469 EXPECT_CALL(personal_data_observer_, 1470 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1471 1472 MessageLoop::current()->Run(); 1473 1474 CreditCard expected; 1475 autofill_test::SetCreditCardInfo(&expected, 1476 "Biggie Smalls", "4111111111111111", "01", "2011"); 1477 const std::vector<CreditCard*>& results = personal_data_->credit_cards(); 1478 ASSERT_EQ(1U, results.size()); 1479 EXPECT_EQ(0, expected.Compare(*results[0])); 1480 1481 // Add a second different valid credit card where the year is different but 1482 // the credit card number matches. 1483 FormData form2; 1484 autofill_test::CreateTestFormField( 1485 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1486 form2.fields.push_back(field); 1487 autofill_test::CreateTestFormField( 1488 "Card Number:", "card_number", "4111 1111 1111 1111", "text", &field); 1489 form2.fields.push_back(field); 1490 autofill_test::CreateTestFormField( 1491 "Exp Month:", "exp_month", "01", "text", &field); 1492 form2.fields.push_back(field); 1493 autofill_test::CreateTestFormField( 1494 "Exp Year:", "exp_year", "2012", "text", &field); 1495 form2.fields.push_back(field); 1496 1497 FormStructure form_structure2(form2); 1498 form_structure2.DetermineHeuristicTypes(); 1499 forms.clear(); 1500 forms.push_back(&form_structure2); 1501 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1502 ASSERT_TRUE(imported_credit_card); 1503 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1504 delete imported_credit_card; 1505 1506 // Wait for the refresh. 1507 EXPECT_CALL(personal_data_observer_, 1508 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1509 1510 MessageLoop::current()->Run(); 1511 1512 // Expect that the newer information is saved. In this case the year is 1513 // updated to "2012". 1514 CreditCard expected2; 1515 autofill_test::SetCreditCardInfo(&expected2, 1516 "Biggie Smalls", "4111111111111111", "01", "2012"); 1517 const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); 1518 ASSERT_EQ(1U, results2.size()); 1519 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1520 } 1521 1522 TEST_F(PersonalDataManagerTest, AggregateEmptyCreditCardWithConflict) { 1523 FormData form1; 1524 1525 // Start with a single valid credit card form. 1526 webkit_glue::FormField field; 1527 autofill_test::CreateTestFormField( 1528 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1529 form1.fields.push_back(field); 1530 autofill_test::CreateTestFormField( 1531 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1532 form1.fields.push_back(field); 1533 autofill_test::CreateTestFormField( 1534 "Exp Month:", "exp_month", "01", "text", &field); 1535 form1.fields.push_back(field); 1536 autofill_test::CreateTestFormField( 1537 "Exp Year:", "exp_year", "2011", "text", &field); 1538 form1.fields.push_back(field); 1539 1540 FormStructure form_structure1(form1); 1541 form_structure1.DetermineHeuristicTypes(); 1542 std::vector<const FormStructure*> forms; 1543 forms.push_back(&form_structure1); 1544 const CreditCard* imported_credit_card; 1545 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1546 ASSERT_TRUE(imported_credit_card); 1547 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1548 delete imported_credit_card; 1549 1550 // Wait for the refresh. 1551 EXPECT_CALL(personal_data_observer_, 1552 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1553 1554 MessageLoop::current()->Run(); 1555 1556 CreditCard expected; 1557 autofill_test::SetCreditCardInfo(&expected, 1558 "Biggie Smalls", "4111111111111111", "01", "2011"); 1559 const std::vector<CreditCard*>& results = personal_data_->credit_cards(); 1560 ASSERT_EQ(1U, results.size()); 1561 EXPECT_EQ(0, expected.Compare(*results[0])); 1562 1563 // Add a second credit card with no number. 1564 FormData form2; 1565 autofill_test::CreateTestFormField( 1566 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1567 form2.fields.push_back(field); 1568 autofill_test::CreateTestFormField( 1569 "Exp Month:", "exp_month", "01", "text", &field); 1570 form2.fields.push_back(field); 1571 autofill_test::CreateTestFormField( 1572 "Exp Year:", "exp_year", "2012", "text", &field); 1573 form2.fields.push_back(field); 1574 1575 FormStructure form_structure2(form2); 1576 form_structure2.DetermineHeuristicTypes(); 1577 forms.clear(); 1578 forms.push_back(&form_structure2); 1579 EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1580 EXPECT_FALSE(imported_credit_card); 1581 1582 // Note: no refresh here. 1583 1584 // No change is expected. 1585 CreditCard expected2; 1586 autofill_test::SetCreditCardInfo(&expected2, 1587 "Biggie Smalls", "4111111111111111", "01", "2011"); 1588 const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); 1589 ASSERT_EQ(1U, results2.size()); 1590 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1591 } 1592 1593 TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInNew) { 1594 FormData form1; 1595 1596 // Start with a single valid credit card form. 1597 webkit_glue::FormField field; 1598 autofill_test::CreateTestFormField( 1599 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1600 form1.fields.push_back(field); 1601 autofill_test::CreateTestFormField( 1602 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1603 form1.fields.push_back(field); 1604 autofill_test::CreateTestFormField( 1605 "Exp Month:", "exp_month", "01", "text", &field); 1606 form1.fields.push_back(field); 1607 autofill_test::CreateTestFormField( 1608 "Exp Year:", "exp_year", "2011", "text", &field); 1609 form1.fields.push_back(field); 1610 1611 FormStructure form_structure1(form1); 1612 form_structure1.DetermineHeuristicTypes(); 1613 std::vector<const FormStructure*> forms; 1614 forms.push_back(&form_structure1); 1615 const CreditCard* imported_credit_card; 1616 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1617 ASSERT_TRUE(imported_credit_card); 1618 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1619 delete imported_credit_card; 1620 1621 // Wait for the refresh. 1622 EXPECT_CALL(personal_data_observer_, 1623 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1624 1625 MessageLoop::current()->Run(); 1626 1627 CreditCard expected; 1628 autofill_test::SetCreditCardInfo(&expected, 1629 "Biggie Smalls", "4111111111111111", "01", "2011"); 1630 const std::vector<CreditCard*>& results = personal_data_->credit_cards(); 1631 ASSERT_EQ(1U, results.size()); 1632 EXPECT_EQ(0, expected.Compare(*results[0])); 1633 1634 // Add a second different valid credit card where the name is missing but 1635 // the credit card number matches. 1636 FormData form2; 1637 // Note missing name. 1638 autofill_test::CreateTestFormField( 1639 "Card Number:", "card_number", "4111111111111111", "text", &field); 1640 form2.fields.push_back(field); 1641 autofill_test::CreateTestFormField( 1642 "Exp Month:", "exp_month", "01", "text", &field); 1643 form2.fields.push_back(field); 1644 autofill_test::CreateTestFormField( 1645 "Exp Year:", "exp_year", "2011", "text", &field); 1646 form2.fields.push_back(field); 1647 1648 FormStructure form_structure2(form2); 1649 form_structure2.DetermineHeuristicTypes(); 1650 forms.clear(); 1651 forms.push_back(&form_structure2); 1652 EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1653 ASSERT_FALSE(imported_credit_card); 1654 1655 // Note: no refresh here. 1656 1657 // No change is expected. 1658 CreditCard expected2; 1659 autofill_test::SetCreditCardInfo(&expected2, 1660 "Biggie Smalls", "4111111111111111", "01", "2011"); 1661 const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); 1662 ASSERT_EQ(1U, results2.size()); 1663 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1664 } 1665 1666 TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInOld) { 1667 FormData form1; 1668 1669 // Start with a single valid credit card form. 1670 webkit_glue::FormField field; 1671 // Note missing name. 1672 autofill_test::CreateTestFormField( 1673 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1674 form1.fields.push_back(field); 1675 autofill_test::CreateTestFormField( 1676 "Exp Month:", "exp_month", "01", "text", &field); 1677 form1.fields.push_back(field); 1678 autofill_test::CreateTestFormField( 1679 "Exp Year:", "exp_year", "2011", "text", &field); 1680 form1.fields.push_back(field); 1681 1682 FormStructure form_structure1(form1); 1683 form_structure1.DetermineHeuristicTypes(); 1684 std::vector<const FormStructure*> forms; 1685 forms.push_back(&form_structure1); 1686 const CreditCard* imported_credit_card; 1687 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1688 ASSERT_TRUE(imported_credit_card); 1689 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1690 delete imported_credit_card; 1691 1692 // Wait for the refresh. 1693 EXPECT_CALL(personal_data_observer_, 1694 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1695 1696 MessageLoop::current()->Run(); 1697 1698 CreditCard expected; 1699 autofill_test::SetCreditCardInfo(&expected, 1700 NULL, "4111111111111111", "01", "2011"); 1701 const std::vector<CreditCard*>& results = personal_data_->credit_cards(); 1702 ASSERT_EQ(1U, results.size()); 1703 EXPECT_EQ(0, expected.Compare(*results[0])); 1704 1705 // Add a second different valid credit card where the year is different but 1706 // the credit card number matches. 1707 FormData form2; 1708 autofill_test::CreateTestFormField( 1709 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1710 form2.fields.push_back(field); 1711 autofill_test::CreateTestFormField( 1712 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1713 form2.fields.push_back(field); 1714 autofill_test::CreateTestFormField( 1715 "Exp Month:", "exp_month", "01", "text", &field); 1716 form2.fields.push_back(field); 1717 autofill_test::CreateTestFormField( 1718 "Exp Year:", "exp_year", "2011", "text", &field); 1719 form2.fields.push_back(field); 1720 1721 FormStructure form_structure2(form2); 1722 form_structure2.DetermineHeuristicTypes(); 1723 forms.clear(); 1724 forms.push_back(&form_structure2); 1725 EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); 1726 ASSERT_TRUE(imported_credit_card); 1727 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1728 delete imported_credit_card; 1729 1730 // Wait for the refresh. 1731 EXPECT_CALL(personal_data_observer_, 1732 OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); 1733 1734 MessageLoop::current()->Run(); 1735 1736 // Expect that the newer information is saved. In this case the year is 1737 // added to the existing credit card. 1738 CreditCard expected2; 1739 autofill_test::SetCreditCardInfo(&expected2, 1740 "Biggie Smalls", "4111111111111111", "01", "2011"); 1741 const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); 1742 ASSERT_EQ(1U, results2.size()); 1743 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1744 } 1745
