// Copyright (c) 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include <string> #include "base/basictypes.h" #include "base/memory/ref_counted.h" #include "base/memory/scoped_ptr.h" #include "base/message_loop.h" #include "base/utf_string_conversions.h" #include "chrome/browser/autofill/autofill_common_test.h" #include "chrome/browser/autofill/autofill_profile.h" #include "chrome/browser/autofill/form_structure.h" #include "chrome/browser/autofill/personal_data_manager.h" #include "chrome/browser/password_manager/encryptor.h" #include "chrome/common/guid.h" #include "chrome/test/testing_browser_process.h" #include "chrome/test/testing_profile.h" #include "content/browser/browser_thread.h" #include "content/common/notification_details.h" #include "content/common/notification_observer_mock.h" #include "content/common/notification_registrar.h" #include "content/common/notification_source.h" #include "content/common/notification_type.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" #include "webkit/glue/form_data.h" #include "webkit/glue/form_data.h" using webkit_glue::FormData; ACTION(QuitUIMessageLoop) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); MessageLoop::current()->Quit(); } class PersonalDataLoadedObserverMock : public PersonalDataManager::Observer { public: PersonalDataLoadedObserverMock() {} virtual ~PersonalDataLoadedObserverMock() {} MOCK_METHOD0(OnPersonalDataLoaded, void()); }; class PersonalDataManagerTest : public testing::Test { protected: PersonalDataManagerTest() : ui_thread_(BrowserThread::UI, &message_loop_), db_thread_(BrowserThread::DB) { } virtual void SetUp() { db_thread_.Start(); profile_.reset(new TestingProfile); profile_->CreateWebDataService(false); autofill_test::DisableSystemServices(profile_.get()); ResetPersonalDataManager(); } virtual void TearDown() { personal_data_ = NULL; if (profile_.get()) profile_.reset(NULL); db_thread_.Stop(); MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask); MessageLoop::current()->Run(); } void ResetPersonalDataManager() { personal_data_ = new PersonalDataManager(); personal_data_->Init(profile_.get()); personal_data_->SetObserver(&personal_data_observer_); } ScopedTestingBrowserProcess browser_process_; MessageLoopForUI message_loop_; BrowserThread ui_thread_; BrowserThread db_thread_; scoped_ptr<TestingProfile> profile_; scoped_refptr<PersonalDataManager> personal_data_; NotificationRegistrar registrar_; NotificationObserverMock observer_; PersonalDataLoadedObserverMock personal_data_observer_; }; // TODO(jhawkins): Test SetProfiles w/out a WebDataService in the profile. TEST_F(PersonalDataManagerTest, SetProfiles) { AutofillProfile profile0; autofill_test::SetProfileInfo(&profile0, "Marion", "Mitchell", "Morrison", "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", "91601", "US", "12345678910", "01987654321"); AutofillProfile profile1; autofill_test::SetProfileInfo(&profile1, "Josephine", "Alicia", "Saenz", "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", "US", "19482937549", "13502849239"); AutofillProfile profile2; autofill_test::SetProfileInfo(&profile2, "Josephine", "Alicia", "Saenz", "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL", "32801", "US", "19482937549", "13502849239"); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the mock observer is notified. MessageLoop::current()->Run(); // Add two test profiles to the database. std::vector<AutofillProfile> update; update.push_back(profile0); update.push_back(profile1); personal_data_->SetProfiles(&update); const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); ASSERT_EQ(2U, results1.size()); EXPECT_EQ(0, profile0.Compare(*results1.at(0))); EXPECT_EQ(0, profile1.Compare(*results1.at(1))); // Three operations in one: // - Update profile0 // - Remove profile1 // - Add profile2 profile0.SetInfo(NAME_FIRST, ASCIIToUTF16("John")); update.clear(); update.push_back(profile0); update.push_back(profile2); personal_data_->SetProfiles(&update); const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); ASSERT_EQ(2U, results2.size()); EXPECT_EQ(0, profile0.Compare(*results2.at(0))); EXPECT_EQ(0, profile2.Compare(*results2.at(1))); // Reset the PersonalDataManager. This tests that the personal data was saved // to the web database, and that we can load the profiles from the web // database. ResetPersonalDataManager(); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the PersonalDataLoadedObserver is notified. MessageLoop::current()->Run(); // Verify that we've loaded the profiles from the web database. const std::vector<AutofillProfile*>& results3 = personal_data_->profiles(); ASSERT_EQ(2U, results3.size()); EXPECT_EQ(0, profile0.Compare(*results3.at(0))); EXPECT_EQ(0, profile2.Compare(*results3.at(1))); } // TODO(jhawkins): Test SetCreditCards w/out a WebDataService in the profile. TEST_F(PersonalDataManagerTest, SetCreditCards) { CreditCard creditcard0; autofill_test::SetCreditCardInfo(&creditcard0, "John Dillinger", "423456789012" /* Visa */, "01", "2010"); CreditCard creditcard1; autofill_test::SetCreditCardInfo(&creditcard1, "Bonnie Parker", "518765432109" /* Mastercard */, "12", "2012"); CreditCard creditcard2; autofill_test::SetCreditCardInfo(&creditcard2, "Clyde Barrow", "347666888555" /* American Express */, "04", "2015"); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the mock observer is notified. MessageLoop::current()->Run(); // Add two test credit cards to the database. std::vector<CreditCard> update; update.push_back(creditcard0); update.push_back(creditcard1); personal_data_->SetCreditCards(&update); const std::vector<CreditCard*>& results1 = personal_data_->credit_cards(); ASSERT_EQ(2U, results1.size()); EXPECT_EQ(0, creditcard0.Compare(*results1.at(0))); EXPECT_EQ(0, creditcard1.Compare(*results1.at(1))); // Three operations in one: // - Update creditcard0 // - Remove creditcard1 // - Add creditcard2 creditcard0.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Joe")); update.clear(); update.push_back(creditcard0); update.push_back(creditcard2); personal_data_->SetCreditCards(&update); const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); ASSERT_EQ(2U, results2.size()); EXPECT_EQ(creditcard0, *results2.at(0)); EXPECT_EQ(creditcard2, *results2.at(1)); // Reset the PersonalDataManager. This tests that the personal data was saved // to the web database, and that we can load the credit cards from the web // database. ResetPersonalDataManager(); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the PersonalDataLoadedObserver is notified. MessageLoop::current()->Run(); // Verify that we've loaded the credit cards from the web database. const std::vector<CreditCard*>& results3 = personal_data_->credit_cards(); ASSERT_EQ(2U, results3.size()); EXPECT_EQ(creditcard0, *results3.at(0)); EXPECT_EQ(creditcard2, *results3.at(1)); } TEST_F(PersonalDataManagerTest, SetProfilesAndCreditCards) { AutofillProfile profile0; autofill_test::SetProfileInfo(&profile0, "Marion", "Mitchell", "Morrison", "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", "91601", "US", "12345678910", "01987654321"); AutofillProfile profile1; autofill_test::SetProfileInfo(&profile1, "Josephine", "Alicia", "Saenz", "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", "US", "19482937549", "13502849239"); CreditCard creditcard0; autofill_test::SetCreditCardInfo(&creditcard0, "John Dillinger", "423456789012" /* Visa */, "01", "2010"); CreditCard creditcard1; autofill_test::SetCreditCardInfo(&creditcard1, "Bonnie Parker", "518765432109" /* Mastercard */, "12", "2012"); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL( personal_data_observer_, OnPersonalDataLoaded()).Times(2).WillRepeatedly(QuitUIMessageLoop()); // The message loop will exit when the mock observer is notified. MessageLoop::current()->Run(); // Add two test profiles to the database. std::vector<AutofillProfile> update; update.push_back(profile0); update.push_back(profile1); personal_data_->SetProfiles(&update); const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); ASSERT_EQ(2U, results1.size()); EXPECT_EQ(0, profile0.Compare(*results1.at(0))); EXPECT_EQ(0, profile1.Compare(*results1.at(1))); MessageLoop::current()->Run(); // Add two test credit cards to the database. std::vector<CreditCard> update_cc; update_cc.push_back(creditcard0); update_cc.push_back(creditcard1); personal_data_->SetCreditCards(&update_cc); const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); ASSERT_EQ(2U, results2.size()); EXPECT_EQ(creditcard0, *results2.at(0)); EXPECT_EQ(creditcard1, *results2.at(1)); // Determine uniqueness by inserting all of the GUIDs into a set and verifying // the size of the set matches the number of GUIDs. std::set<std::string> guids; guids.insert(profile0.guid()); guids.insert(profile1.guid()); guids.insert(creditcard0.guid()); guids.insert(creditcard1.guid()); EXPECT_EQ(4U, guids.size()); } // Test care for 50047. Makes sure that unique_ids_ is populated correctly on // load. TEST_F(PersonalDataManagerTest, PopulateUniqueIDsOnLoad) { AutofillProfile profile0; autofill_test::SetProfileInfo(&profile0, "y", "", "", "", "", "", "", "", "", "", "", "", ""); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillRepeatedly(QuitUIMessageLoop()); // The message loop will exit when the mock observer is notified. MessageLoop::current()->Run(); // Add the profile0 to the db. std::vector<AutofillProfile> update; update.push_back(profile0); personal_data_->SetProfiles(&update); // Reset the PersonalDataManager. This recreates PersonalDataManager, which // should populate unique_ids_. ResetPersonalDataManager(); // The message loop will exit when the PersonalDataLoadedObserver is notified. MessageLoop::current()->Run(); // Verify that we've loaded the profiles from the web database. const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); ASSERT_EQ(1U, results2.size()); // Add a new profile. AutofillProfile profile1; autofill_test::SetProfileInfo(&profile1, "y", "", "", "", "", "", "", "", "", "", "", "", ""); update.clear(); update.push_back(*results2[0]); update.push_back(profile1); personal_data_->SetProfiles(&update); // Make sure the two profiles have different ids (and neither equal to 0, // which is an invalid id). const std::vector<AutofillProfile*>& results3 = personal_data_->profiles(); ASSERT_EQ(2U, results3.size()); EXPECT_NE(results3[0]->guid(), results3[1]->guid()); EXPECT_TRUE(guid::IsValidGUID(results3[0]->guid())); EXPECT_TRUE(guid::IsValidGUID(results3[1]->guid())); } TEST_F(PersonalDataManagerTest, SetEmptyProfile) { AutofillProfile profile0; autofill_test::SetProfileInfo(&profile0, "", "", "", "", "", "", "", "", "", "", "", "", ""); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the mock observer is notified. MessageLoop::current()->Run(); // Add the empty profile to the database. std::vector<AutofillProfile> update; update.push_back(profile0); personal_data_->SetProfiles(&update); // Check the local store of profiles, not yet saved to the web database. const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); ASSERT_EQ(0U, results1.size()); // Reset the PersonalDataManager. This tests that the personal data was saved // to the web database, and that we can load the profiles from the web // database. ResetPersonalDataManager(); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the PersonalDataLoadedObserver is notified. MessageLoop::current()->Run(); // Verify that we've loaded the profiles from the web database. const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); ASSERT_EQ(0U, results2.size()); } TEST_F(PersonalDataManagerTest, SetEmptyCreditCard) { CreditCard creditcard0; autofill_test::SetCreditCardInfo(&creditcard0, "", "", "", ""); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the mock observer is notified. MessageLoop::current()->Run(); // Add the empty credit card to the database. std::vector<CreditCard> update; update.push_back(creditcard0); personal_data_->SetCreditCards(&update); // Check the local store of credit cards, not yet saved to the web database. const std::vector<CreditCard*>& results1 = personal_data_->credit_cards(); ASSERT_EQ(0U, results1.size()); // Reset the PersonalDataManager. This tests that the personal data was saved // to the web database, and that we can load the credit cards from the web // database. ResetPersonalDataManager(); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the PersonalDataLoadedObserver is notified. MessageLoop::current()->Run(); // Verify that we've loaded the credit cards from the web database. const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); ASSERT_EQ(0U, results2.size()); } TEST_F(PersonalDataManagerTest, Refresh) { AutofillProfile profile0; autofill_test::SetProfileInfo(&profile0, "Marion", "Mitchell", "Morrison", "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", "91601", "US", "12345678910", "01987654321"); AutofillProfile profile1; autofill_test::SetProfileInfo(&profile1, "Josephine", "Alicia", "Saenz", "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", "US", "19482937549", "13502849239"); EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); // Add the test profiles to the database. std::vector<AutofillProfile> update; update.push_back(profile0); update.push_back(profile1); personal_data_->SetProfiles(&update); // Labels depend on other profiles in the list - update labels manually. std::vector<AutofillProfile *> profile_pointers; profile_pointers.push_back(&profile0); profile_pointers.push_back(&profile1); AutofillProfile::AdjustInferredLabels(&profile_pointers); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); ASSERT_EQ(2U, results1.size()); EXPECT_EQ(profile0, *results1.at(0)); EXPECT_EQ(profile1, *results1.at(1)); AutofillProfile profile2; autofill_test::SetProfileInfo(&profile2, "Josephine", "Alicia", "Saenz", "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL", "32801", "US", "19482937549", "13502849239"); // Adjust all labels. profile_pointers.push_back(&profile2); AutofillProfile::AdjustInferredLabels(&profile_pointers); WebDataService* wds = profile_->GetWebDataService(Profile::EXPLICIT_ACCESS); ASSERT_TRUE(wds); wds->AddAutofillProfile(profile2); personal_data_->Refresh(); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); ASSERT_EQ(3U, results2.size()); EXPECT_EQ(profile0, *results2.at(0)); EXPECT_EQ(profile1, *results2.at(1)); EXPECT_EQ(profile2, *results2.at(2)); wds->RemoveAutofillProfile(profile1.guid()); wds->RemoveAutofillProfile(profile2.guid()); // Before telling the PDM to refresh, simulate an edit to one of the profiles // via a SetProfile update (this would happen if the Autofill window was // open with a previous snapshot of the profiles, and something [e.g. sync] // removed a profile from the browser. In this edge case, we will end up // in a consistent state by dropping the write). profile2.SetInfo(NAME_FIRST, ASCIIToUTF16("Jo")); update.clear(); update.push_back(profile0); update.push_back(profile1); update.push_back(profile2); personal_data_->SetProfiles(&update); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& results3 = personal_data_->profiles(); ASSERT_EQ(1U, results3.size()); EXPECT_EQ(profile0, *results2.at(0)); } TEST_F(PersonalDataManagerTest, ImportFormData) { FormData form; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "theprez@gmail.com", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Address:", "address1", "21 Laussat St", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "San Francisco", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "California", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zip", "94102", "text", &field); form.fields.push_back(field); FormStructure form_structure(form); form_structure.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); AutofillProfile expected; autofill_test::SetProfileInfo(&expected, "George", NULL, "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL, "San Francisco", "California", "94102", NULL, NULL, NULL); const std::vector<AutofillProfile*>& results = personal_data_->profiles(); ASSERT_EQ(1U, results.size()); EXPECT_EQ(0, expected.Compare(*results[0])); } TEST_F(PersonalDataManagerTest, ImportFormDataBadEmail) { FormData form; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "bogus", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Address:", "address1", "21 Laussat St", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "San Francisco", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "California", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zip", "94102", "text", &field); form.fields.push_back(field); FormStructure form_structure(form); form_structure.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure); const CreditCard* imported_credit_card; EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_EQ(static_cast<CreditCard*>(NULL), imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& results = personal_data_->profiles(); ASSERT_EQ(0U, results.size()); } TEST_F(PersonalDataManagerTest, ImportFormDataNotEnoughFilledFields) { FormData form; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Card number:", "card_number", "4111 1111 1111 1111", "text", &field); form.fields.push_back(field); FormStructure form_structure(form); form_structure.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure); const CreditCard* imported_credit_card; EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& profiles = personal_data_->profiles(); ASSERT_EQ(0U, profiles.size()); const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards(); ASSERT_EQ(0U, credit_cards.size()); } TEST_F(PersonalDataManagerTest, ImportPhoneNumberSplitAcrossMultipleFields) { FormData form; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Phone #:", "home_phone_area_code", "650", "text", &field); field.max_length = 3; form.fields.push_back(field); autofill_test::CreateTestFormField( "Phone #:", "home_phone_prefix", "555", "text", &field); field.max_length = 3; form.fields.push_back(field); autofill_test::CreateTestFormField( "Phone #:", "home_phone_suffix", "0000", "text", &field); field.max_length = 4; form.fields.push_back(field); autofill_test::CreateTestFormField( "Address:", "address1", "21 Laussat St", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "San Francisco", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "California", "text", &field); form.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zip", "94102", "text", &field); form.fields.push_back(field); FormStructure form_structure(form); form_structure.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); AutofillProfile expected; autofill_test::SetProfileInfo(&expected, "George", NULL, "Washington", NULL, NULL, "21 Laussat St", NULL, "San Francisco", "California", "94102", NULL, "6505550000", NULL); const std::vector<AutofillProfile*>& results = personal_data_->profiles(); ASSERT_EQ(1U, results.size()); EXPECT_EQ(0, expected.Compare(*results[0])); } TEST_F(PersonalDataManagerTest, SetUniqueCreditCardLabels) { CreditCard credit_card0; credit_card0.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("John")); CreditCard credit_card1; credit_card1.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Paul")); CreditCard credit_card2; credit_card2.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Ringo")); CreditCard credit_card3; credit_card3.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Other")); CreditCard credit_card4; credit_card4.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Ozzy")); CreditCard credit_card5; credit_card5.SetInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Dio")); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the mock observer is notified. MessageLoop::current()->Run(); // Add the test credit cards to the database. std::vector<CreditCard> update; update.push_back(credit_card0); update.push_back(credit_card1); update.push_back(credit_card2); update.push_back(credit_card3); update.push_back(credit_card4); update.push_back(credit_card5); personal_data_->SetCreditCards(&update); // Reset the PersonalDataManager. This tests that the personal data was saved // to the web database, and that we can load the credit cards from the web // database. ResetPersonalDataManager(); // This will verify that the web database has been loaded and the notification // sent out. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); // The message loop will exit when the mock observer is notified. MessageLoop::current()->Run(); const std::vector<CreditCard*>& results = personal_data_->credit_cards(); ASSERT_EQ(6U, results.size()); EXPECT_EQ(credit_card0.guid(), results[0]->guid()); EXPECT_EQ(credit_card1.guid(), results[1]->guid()); EXPECT_EQ(credit_card2.guid(), results[2]->guid()); EXPECT_EQ(credit_card3.guid(), results[3]->guid()); EXPECT_EQ(credit_card4.guid(), results[4]->guid()); EXPECT_EQ(credit_card5.guid(), results[5]->guid()); } TEST_F(PersonalDataManagerTest, AggregateTwoDifferentProfiles) { FormData form1; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "theprez@gmail.com", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Address:", "address1", "21 Laussat St", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "San Francisco", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "California", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zip", "94102", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); AutofillProfile expected; autofill_test::SetProfileInfo(&expected, "George", NULL, "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL, "San Francisco", "California", "94102", NULL, NULL, NULL); const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); ASSERT_EQ(1U, results1.size()); EXPECT_EQ(0, expected.Compare(*results1[0])); // Now create a completely different profile. FormData form2; autofill_test::CreateTestFormField( "First name:", "first_name", "John", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Adams", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "second@gmail.com", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Address:", "address1", "22 Laussat St", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "San Francisco", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "California", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zip", "94102", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); AutofillProfile expected2; autofill_test::SetProfileInfo(&expected2, "John", NULL, "Adams", "second@gmail.com", NULL, "22 Laussat St", NULL, "San Francisco", "California", "94102", NULL, NULL, NULL); ASSERT_EQ(2U, results2.size()); EXPECT_EQ(0, expected.Compare(*results2[0])); EXPECT_EQ(0, expected2.Compare(*results2[1])); } TEST_F(PersonalDataManagerTest, AggregateTwoProfilesWithMultiValue) { FormData form1; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "theprez@gmail.com", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Address:", "address1", "21 Laussat St", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "San Francisco", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "California", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zip", "94102", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); AutofillProfile expected; autofill_test::SetProfileInfo(&expected, "George", NULL, "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL, "San Francisco", "California", "94102", NULL, NULL, NULL); const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); ASSERT_EQ(1U, results1.size()); EXPECT_EQ(0, expected.Compare(*results1[0])); // Now create a completely different profile. FormData form2; autofill_test::CreateTestFormField( "First name:", "first_name", "John", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Adams", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "second@gmail.com", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Address:", "address1", "21 Laussat St", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "San Francisco", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "California", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zip", "94102", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); // Modify expected to include multi-valued fields. std::vector<string16> values; expected.GetMultiInfo(NAME_FULL, &values); values.push_back(ASCIIToUTF16("John Adams")); expected.SetMultiInfo(NAME_FULL, values); expected.GetMultiInfo(EMAIL_ADDRESS, &values); values.push_back(ASCIIToUTF16("second@gmail.com")); expected.SetMultiInfo(EMAIL_ADDRESS, values); ASSERT_EQ(1U, results2.size()); EXPECT_EQ(0, expected.CompareMulti(*results2[0])); } TEST_F(PersonalDataManagerTest, AggregateSameProfileWithConflict) { FormData form1; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Address:", "address", "1600 Pennsylvania Avenue", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Address Line 2:", "address2", "Suite A", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "San Francisco", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "California", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zip", "94102", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "theprez@gmail.com", "text", &field); form1.fields.push_back(field); // Phone gets updated. autofill_test::CreateTestFormField( "Phone:", "phone", "4445556666", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); AutofillProfile expected; autofill_test::SetProfileInfo(&expected, "George", NULL, "Washington", "theprez@gmail.com", NULL, "1600 Pennsylvania Avenue", "Suite A", "San Francisco", "California", "94102", NULL, "4445556666", NULL); const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); ASSERT_EQ(1U, results1.size()); EXPECT_EQ(0, expected.Compare(*results1[0])); // Now create an updated profile. FormData form2; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Address:", "address", "1600 Pennsylvania Avenue", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Address Line 2:", "address2", "Suite A", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "San Francisco", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "California", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zip", "94102", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "theprez@gmail.com", "text", &field); form2.fields.push_back(field); // Country gets added. autofill_test::CreateTestFormField( "Country:", "country", "USA", "text", &field); form2.fields.push_back(field); // Phone gets updated. autofill_test::CreateTestFormField( "Phone:", "phone", "1231231234", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); // Add multi-valued phone number to expectation. Also, country gets added. std::vector<string16> values; expected.GetMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values); values.push_back(ASCIIToUTF16("1231231234")); expected.SetMultiInfo(PHONE_HOME_WHOLE_NUMBER, values); expected.SetInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("United States")); ASSERT_EQ(1U, results2.size()); EXPECT_EQ(0, expected.CompareMulti(*results2[0])); } TEST_F(PersonalDataManagerTest, AggregateProfileWithMissingInfoInOld) { FormData form1; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Address Line 1:", "address", "190 High Street", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "Philadelphia", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "Pennsylvania", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zipcode", "19106", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); AutofillProfile expected; autofill_test::SetProfileInfo(&expected, "George", NULL, "Washington", NULL, NULL, "190 High Street", NULL, "Philadelphia", "Pennsylvania", "19106", NULL, NULL, NULL); const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); ASSERT_EQ(1U, results1.size()); EXPECT_EQ(0, expected.Compare(*results1[0])); // Submit a form with new data for the first profile. FormData form2; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "theprez@gmail.com", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Address Line 1:", "address", "190 High Street", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "Philadelphia", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "Pennsylvania", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zipcode", "19106", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); AutofillProfile expected2; autofill_test::SetProfileInfo(&expected2, "George", NULL, "Washington", "theprez@gmail.com", NULL, "190 High Street", NULL, "Philadelphia", "Pennsylvania", "19106", NULL, NULL, NULL); ASSERT_EQ(1U, results2.size()); EXPECT_EQ(0, expected2.Compare(*results2[0])); } TEST_F(PersonalDataManagerTest, AggregateProfileWithMissingInfoInNew) { FormData form1; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Company:", "company", "Government", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "theprez@gmail.com", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Address Line 1:", "address", "190 High Street", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "Philadelphia", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "Pennsylvania", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zipcode", "19106", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); AutofillProfile expected; autofill_test::SetProfileInfo(&expected, "George", NULL, "Washington", "theprez@gmail.com", "Government", "190 High Street", NULL, "Philadelphia", "Pennsylvania", "19106", NULL, NULL, NULL); const std::vector<AutofillProfile*>& results1 = personal_data_->profiles(); ASSERT_EQ(1U, results1.size()); EXPECT_EQ(0, expected.Compare(*results1[0])); // Submit a form with new data for the first profile. FormData form2; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form2.fields.push_back(field); // Note missing Company field. autofill_test::CreateTestFormField( "Email:", "email", "theprez@gmail.com", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Address Line 1:", "address", "190 High Street", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "Philadelphia", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "State:", "state", "Pennsylvania", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Zip:", "zipcode", "19106", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& results2 = personal_data_->profiles(); // Expect no change. ASSERT_EQ(1U, results2.size()); EXPECT_EQ(0, expected.Compare(*results2[0])); } TEST_F(PersonalDataManagerTest, AggregateProfileWithInsufficientAddress) { FormData form1; webkit_glue::FormField field; autofill_test::CreateTestFormField( "First name:", "first_name", "George", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Last name:", "last_name", "Washington", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Company:", "company", "Government", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Email:", "email", "theprez@gmail.com", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Address Line 1:", "address", "190 High Street", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "City:", "city", "Philadelphia", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); const std::vector<AutofillProfile*>& profiles = personal_data_->profiles(); ASSERT_EQ(0U, profiles.size()); const std::vector<CreditCard*>& credit_cards = personal_data_->credit_cards(); ASSERT_EQ(0U, credit_cards.size()); } TEST_F(PersonalDataManagerTest, AggregateTwoDifferentCreditCards) { FormData form1; // Start with a single valid credit card form. webkit_glue::FormField field; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2011", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_TRUE(imported_credit_card); personal_data_->SaveImportedCreditCard(*imported_credit_card); delete imported_credit_card; // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); CreditCard expected; autofill_test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01", "2011"); const std::vector<CreditCard*>& results = personal_data_->credit_cards(); ASSERT_EQ(1U, results.size()); EXPECT_EQ(0, expected.Compare(*results[0])); // Add a second different valid credit card. FormData form2; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Jim Johansen", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Card Number:", "card_number", "5500 0000 0000 0004", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "02", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2012", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_TRUE(imported_credit_card); personal_data_->SaveImportedCreditCard(*imported_credit_card); delete imported_credit_card; // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); CreditCard expected2; autofill_test::SetCreditCardInfo(&expected2, "Jim Johansen", "5500000000000004", "02", "2012"); const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); ASSERT_EQ(2U, results2.size()); EXPECT_EQ(0, expected.Compare(*results2[0])); EXPECT_EQ(0, expected2.Compare(*results2[1])); } TEST_F(PersonalDataManagerTest, AggregateInvalidCreditCard) { FormData form1; // Start with a single valid credit card form. webkit_glue::FormField field; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2011", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_TRUE(imported_credit_card); personal_data_->SaveImportedCreditCard(*imported_credit_card); delete imported_credit_card; // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); CreditCard expected; autofill_test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01", "2011"); const std::vector<CreditCard*>& results = personal_data_->credit_cards(); ASSERT_EQ(1U, results.size()); EXPECT_EQ(0, expected.Compare(*results[0])); // Add a second different invalid credit card. FormData form2; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Jim Johansen", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Card Number:", "card_number", "1000000000000000", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "02", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2012", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Note: no refresh here. const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); ASSERT_EQ(1U, results2.size()); EXPECT_EQ(0, expected.Compare(*results2[0])); } TEST_F(PersonalDataManagerTest, AggregateSameCreditCardWithConflict) { FormData form1; // Start with a single valid credit card form. webkit_glue::FormField field; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2011", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_TRUE(imported_credit_card); personal_data_->SaveImportedCreditCard(*imported_credit_card); delete imported_credit_card; // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); CreditCard expected; autofill_test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01", "2011"); const std::vector<CreditCard*>& results = personal_data_->credit_cards(); ASSERT_EQ(1U, results.size()); EXPECT_EQ(0, expected.Compare(*results[0])); // Add a second different valid credit card where the year is different but // the credit card number matches. FormData form2; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Card Number:", "card_number", "4111 1111 1111 1111", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2012", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_TRUE(imported_credit_card); personal_data_->SaveImportedCreditCard(*imported_credit_card); delete imported_credit_card; // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); // Expect that the newer information is saved. In this case the year is // updated to "2012". CreditCard expected2; autofill_test::SetCreditCardInfo(&expected2, "Biggie Smalls", "4111111111111111", "01", "2012"); const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); ASSERT_EQ(1U, results2.size()); EXPECT_EQ(0, expected2.Compare(*results2[0])); } TEST_F(PersonalDataManagerTest, AggregateEmptyCreditCardWithConflict) { FormData form1; // Start with a single valid credit card form. webkit_glue::FormField field; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2011", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_TRUE(imported_credit_card); personal_data_->SaveImportedCreditCard(*imported_credit_card); delete imported_credit_card; // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); CreditCard expected; autofill_test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01", "2011"); const std::vector<CreditCard*>& results = personal_data_->credit_cards(); ASSERT_EQ(1U, results.size()); EXPECT_EQ(0, expected.Compare(*results[0])); // Add a second credit card with no number. FormData form2; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2012", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); EXPECT_FALSE(imported_credit_card); // Note: no refresh here. // No change is expected. CreditCard expected2; autofill_test::SetCreditCardInfo(&expected2, "Biggie Smalls", "4111111111111111", "01", "2011"); const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); ASSERT_EQ(1U, results2.size()); EXPECT_EQ(0, expected2.Compare(*results2[0])); } TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInNew) { FormData form1; // Start with a single valid credit card form. webkit_glue::FormField field; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2011", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_TRUE(imported_credit_card); personal_data_->SaveImportedCreditCard(*imported_credit_card); delete imported_credit_card; // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); CreditCard expected; autofill_test::SetCreditCardInfo(&expected, "Biggie Smalls", "4111111111111111", "01", "2011"); const std::vector<CreditCard*>& results = personal_data_->credit_cards(); ASSERT_EQ(1U, results.size()); EXPECT_EQ(0, expected.Compare(*results[0])); // Add a second different valid credit card where the name is missing but // the credit card number matches. FormData form2; // Note missing name. autofill_test::CreateTestFormField( "Card Number:", "card_number", "4111111111111111", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2011", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_FALSE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_FALSE(imported_credit_card); // Note: no refresh here. // No change is expected. CreditCard expected2; autofill_test::SetCreditCardInfo(&expected2, "Biggie Smalls", "4111111111111111", "01", "2011"); const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); ASSERT_EQ(1U, results2.size()); EXPECT_EQ(0, expected2.Compare(*results2[0])); } TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInOld) { FormData form1; // Start with a single valid credit card form. webkit_glue::FormField field; // Note missing name. autofill_test::CreateTestFormField( "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form1.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2011", "text", &field); form1.fields.push_back(field); FormStructure form_structure1(form1); form_structure1.DetermineHeuristicTypes(); std::vector<const FormStructure*> forms; forms.push_back(&form_structure1); const CreditCard* imported_credit_card; EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_TRUE(imported_credit_card); personal_data_->SaveImportedCreditCard(*imported_credit_card); delete imported_credit_card; // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); CreditCard expected; autofill_test::SetCreditCardInfo(&expected, NULL, "4111111111111111", "01", "2011"); const std::vector<CreditCard*>& results = personal_data_->credit_cards(); ASSERT_EQ(1U, results.size()); EXPECT_EQ(0, expected.Compare(*results[0])); // Add a second different valid credit card where the year is different but // the credit card number matches. FormData form2; autofill_test::CreateTestFormField( "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Month:", "exp_month", "01", "text", &field); form2.fields.push_back(field); autofill_test::CreateTestFormField( "Exp Year:", "exp_year", "2011", "text", &field); form2.fields.push_back(field); FormStructure form_structure2(form2); form_structure2.DetermineHeuristicTypes(); forms.clear(); forms.push_back(&form_structure2); EXPECT_TRUE(personal_data_->ImportFormData(forms, &imported_credit_card)); ASSERT_TRUE(imported_credit_card); personal_data_->SaveImportedCreditCard(*imported_credit_card); delete imported_credit_card; // Wait for the refresh. EXPECT_CALL(personal_data_observer_, OnPersonalDataLoaded()).WillOnce(QuitUIMessageLoop()); MessageLoop::current()->Run(); // Expect that the newer information is saved. In this case the year is // added to the existing credit card. CreditCard expected2; autofill_test::SetCreditCardInfo(&expected2, "Biggie Smalls", "4111111111111111", "01", "2011"); const std::vector<CreditCard*>& results2 = personal_data_->credit_cards(); ASSERT_EQ(1U, results2.size()); EXPECT_EQ(0, expected2.Compare(*results2[0])); }