personal_data_manager_unittest.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9
1// Copyright 2013 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include <string> 6 7#include "base/basictypes.h" 8#include "base/files/scoped_temp_dir.h" 9#include "base/guid.h" 10#include "base/memory/scoped_ptr.h" 11#include "base/message_loop/message_loop.h" 12#include "base/prefs/pref_service.h" 13#include "base/strings/utf_string_conversions.h" 14#include "base/synchronization/waitable_event.h" 15#include "components/autofill/core/browser/autofill_metrics.h" 16#include "components/autofill/core/browser/autofill_profile.h" 17#include "components/autofill/core/browser/autofill_test_utils.h" 18#include "components/autofill/core/browser/form_structure.h" 19#include "components/autofill/core/browser/personal_data_manager.h" 20#include "components/autofill/core/browser/personal_data_manager_observer.h" 21#include "components/autofill/core/browser/webdata/autofill_table.h" 22#include "components/autofill/core/browser/webdata/autofill_webdata_service.h" 23#include "components/autofill/core/common/autofill_pref_names.h" 24#include "components/autofill/core/common/form_data.h" 25#include "components/webdata/common/web_data_service_base.h" 26#include "components/webdata/common/web_database_service.h" 27#include "testing/gmock/include/gmock/gmock.h" 28#include "testing/gtest/include/gtest/gtest.h" 29 30using base::ASCIIToUTF16; 31 32namespace autofill { 33namespace { 34 35enum UserMode { USER_MODE_NORMAL, USER_MODE_INCOGNITO }; 36 37ACTION(QuitMainMessageLoop) { base::MessageLoop::current()->Quit(); } 38 39class PersonalDataLoadedObserverMock : public PersonalDataManagerObserver { 40 public: 41 PersonalDataLoadedObserverMock() {} 42 virtual ~PersonalDataLoadedObserverMock() {} 43 44 MOCK_METHOD0(OnPersonalDataChanged, void()); 45}; 46 47// Unlike the base AutofillMetrics, exposes copy and assignment constructors, 48// which are handy for briefer test code. The AutofillMetrics class is 49// stateless, so this is safe. 50class TestAutofillMetrics : public AutofillMetrics { 51 public: 52 TestAutofillMetrics() {} 53 virtual ~TestAutofillMetrics() {} 54}; 55 56} // anonymous namespace 57 58class PersonalDataManagerTest : public testing::Test { 59 protected: 60 PersonalDataManagerTest() {} 61 62 virtual void SetUp() { 63 64 prefs_ = test::PrefServiceForTesting(); 65 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 66 base::FilePath path = temp_dir_.path().AppendASCII("TestWebDB"); 67 web_database_ = new WebDatabaseService(path, 68 base::MessageLoopProxy::current(), 69 base::MessageLoopProxy::current()); 70 web_database_->AddTable( 71 scoped_ptr<WebDatabaseTable>(new AutofillTable("en-US"))); 72 web_database_->LoadDatabase(); 73 autofill_database_service_ = 74 new AutofillWebDataService(web_database_, 75 base::MessageLoopProxy::current(), 76 base::MessageLoopProxy::current(), 77 WebDataServiceBase::ProfileErrorCallback()); 78 autofill_database_service_->Init(); 79 80 test::DisableSystemServices(prefs_.get()); 81 ResetPersonalDataManager(USER_MODE_NORMAL); 82 } 83 84 virtual void TearDown() { 85 // Destruction order is imposed explicitly here. 86 personal_data_.reset(NULL); 87 88 autofill_database_service_->ShutdownOnUIThread(); 89 web_database_->ShutdownDatabase(); 90 autofill_database_service_ = NULL; 91 web_database_ = NULL; 92 } 93 94 void ResetPersonalDataManager(UserMode user_mode) { 95 bool is_incognito = (user_mode == USER_MODE_INCOGNITO); 96 personal_data_.reset(new PersonalDataManager("en-US")); 97 personal_data_->Init( 98 scoped_refptr<AutofillWebDataService>(autofill_database_service_), 99 prefs_.get(), 100 is_incognito); 101 personal_data_->AddObserver(&personal_data_observer_); 102 103 // Verify that the web database has been updated and the notification sent. 104 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 105 .WillOnce(QuitMainMessageLoop()); 106 base::MessageLoop::current()->Run(); 107 } 108 109 base::MessageLoopForUI message_loop_; 110 scoped_ptr<PrefService> prefs_; 111 scoped_refptr<AutofillWebDataService> autofill_database_service_; 112 scoped_refptr<WebDatabaseService> web_database_; 113 base::ScopedTempDir temp_dir_; 114 scoped_ptr<PersonalDataManager> personal_data_; 115 PersonalDataLoadedObserverMock personal_data_observer_; 116}; 117 118TEST_F(PersonalDataManagerTest, AddProfile) { 119 // Add profile0 to the database. 120 AutofillProfile profile0(autofill::test::GetFullProfile()); 121 profile0.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("j@s.com")); 122 personal_data_->AddProfile(profile0); 123 124 // Reload the database. 125 ResetPersonalDataManager(USER_MODE_NORMAL); 126 127 // Verify the addition. 128 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 129 ASSERT_EQ(1U, results1.size()); 130 EXPECT_EQ(0, profile0.Compare(*results1[0])); 131 132 // Add profile with identical values. Duplicates should not get saved. 133 AutofillProfile profile0a = profile0; 134 profile0a.set_guid(base::GenerateGUID()); 135 personal_data_->AddProfile(profile0a); 136 137 // Reload the database. 138 ResetPersonalDataManager(USER_MODE_NORMAL); 139 140 // Verify the non-addition. 141 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 142 ASSERT_EQ(1U, results2.size()); 143 EXPECT_EQ(0, profile0.Compare(*results2[0])); 144 145 // New profile with different email. 146 AutofillProfile profile1 = profile0; 147 profile1.set_guid(base::GenerateGUID()); 148 profile1.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("john@smith.com")); 149 150 // Add the different profile. This should save as a separate profile. 151 // Note that if this same profile was "merged" it would collapse to one 152 // profile with a multi-valued entry for email. 153 personal_data_->AddProfile(profile1); 154 155 // Reload the database. 156 ResetPersonalDataManager(USER_MODE_NORMAL); 157 158 // Verify the addition. 159 const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles(); 160 ASSERT_EQ(2U, results3.size()); 161 EXPECT_EQ(0, profile0.Compare(*results3[0])); 162 EXPECT_EQ(0, profile1.Compare(*results3[1])); 163} 164 165TEST_F(PersonalDataManagerTest, AddUpdateRemoveProfiles) { 166 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com"); 167 test::SetProfileInfo(&profile0, 168 "Marion", "Mitchell", "Morrison", 169 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 170 "91601", "US", "12345678910"); 171 172 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com"); 173 test::SetProfileInfo(&profile1, 174 "Josephine", "Alicia", "Saenz", 175 "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", 176 "US", "19482937549"); 177 178 AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com"); 179 test::SetProfileInfo(&profile2, 180 "Josephine", "Alicia", "Saenz", 181 "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL", 182 "32801", "US", "19482937549"); 183 184 // Add two test profiles to the database. 185 personal_data_->AddProfile(profile0); 186 personal_data_->AddProfile(profile1); 187 188 // Verify that the web database has been updated and the notification sent. 189 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 190 .WillOnce(QuitMainMessageLoop()); 191 base::MessageLoop::current()->Run(); 192 193 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 194 ASSERT_EQ(2U, results1.size()); 195 EXPECT_EQ(0, profile0.Compare(*results1[0])); 196 EXPECT_EQ(0, profile1.Compare(*results1[1])); 197 198 // Update, remove, and add. 199 profile0.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John")); 200 personal_data_->UpdateProfile(profile0); 201 personal_data_->RemoveByGUID(profile1.guid()); 202 personal_data_->AddProfile(profile2); 203 204 // Verify that the web database has been updated and the notification sent. 205 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 206 .WillOnce(QuitMainMessageLoop()); 207 base::MessageLoop::current()->Run(); 208 209 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 210 ASSERT_EQ(2U, results2.size()); 211 EXPECT_EQ(0, profile0.Compare(*results2[0])); 212 EXPECT_EQ(0, profile2.Compare(*results2[1])); 213 214 // Reset the PersonalDataManager. This tests that the personal data was saved 215 // to the web database, and that we can load the profiles from the web 216 // database. 217 ResetPersonalDataManager(USER_MODE_NORMAL); 218 219 // Verify that we've loaded the profiles from the web database. 220 const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles(); 221 ASSERT_EQ(2U, results3.size()); 222 EXPECT_EQ(0, profile0.Compare(*results3[0])); 223 EXPECT_EQ(0, profile2.Compare(*results3[1])); 224} 225 226TEST_F(PersonalDataManagerTest, AddUpdateRemoveCreditCards) { 227 CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com"); 228 test::SetCreditCardInfo(&credit_card0, 229 "John Dillinger", "423456789012" /* Visa */, "01", "2010"); 230 231 CreditCard credit_card1(base::GenerateGUID(), "https://www.example.com"); 232 test::SetCreditCardInfo(&credit_card1, 233 "Bonnie Parker", "518765432109" /* Mastercard */, "12", "2012"); 234 235 CreditCard credit_card2(base::GenerateGUID(), "https://www.example.com"); 236 test::SetCreditCardInfo(&credit_card2, 237 "Clyde Barrow", "347666888555" /* American Express */, "04", "2015"); 238 239 // Add two test credit cards to the database. 240 personal_data_->AddCreditCard(credit_card0); 241 personal_data_->AddCreditCard(credit_card1); 242 243 // Verify that the web database has been updated and the notification sent. 244 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 245 .WillOnce(QuitMainMessageLoop()); 246 base::MessageLoop::current()->Run(); 247 248 const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards(); 249 ASSERT_EQ(2U, results1.size()); 250 EXPECT_EQ(0, credit_card0.Compare(*results1[0])); 251 EXPECT_EQ(0, credit_card1.Compare(*results1[1])); 252 253 // Update, remove, and add. 254 credit_card0.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Joe")); 255 personal_data_->UpdateCreditCard(credit_card0); 256 personal_data_->RemoveByGUID(credit_card1.guid()); 257 personal_data_->AddCreditCard(credit_card2); 258 259 // Verify that the web database has been updated and the notification sent. 260 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 261 .WillOnce(QuitMainMessageLoop()); 262 base::MessageLoop::current()->Run(); 263 264 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 265 ASSERT_EQ(2U, results2.size()); 266 EXPECT_EQ(credit_card0, *results2[0]); 267 EXPECT_EQ(credit_card2, *results2[1]); 268 269 // Reset the PersonalDataManager. This tests that the personal data was saved 270 // to the web database, and that we can load the credit cards from the web 271 // database. 272 ResetPersonalDataManager(USER_MODE_NORMAL); 273 274 // Verify that we've loaded the credit cards from the web database. 275 const std::vector<CreditCard*>& results3 = personal_data_->GetCreditCards(); 276 ASSERT_EQ(2U, results3.size()); 277 EXPECT_EQ(credit_card0, *results3[0]); 278 EXPECT_EQ(credit_card2, *results3[1]); 279} 280 281TEST_F(PersonalDataManagerTest, UpdateUnverifiedProfilesAndCreditCards) { 282 // Start with unverified data. 283 AutofillProfile profile(base::GenerateGUID(), "https://www.example.com/"); 284 test::SetProfileInfo(&profile, 285 "Marion", "Mitchell", "Morrison", 286 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 287 "91601", "US", "12345678910"); 288 EXPECT_FALSE(profile.IsVerified()); 289 290 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/"); 291 test::SetCreditCardInfo(&credit_card, 292 "John Dillinger", "423456789012" /* Visa */, "01", "2010"); 293 EXPECT_FALSE(credit_card.IsVerified()); 294 295 // Add the data to the database. 296 personal_data_->AddProfile(profile); 297 personal_data_->AddCreditCard(credit_card); 298 299 // Verify that the web database has been updated and the notification sent. 300 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 301 .WillOnce(QuitMainMessageLoop()); 302 base::MessageLoop::current()->Run(); 303 304 const std::vector<AutofillProfile*>& profiles1 = 305 personal_data_->GetProfiles(); 306 const std::vector<CreditCard*>& cards1 = personal_data_->GetCreditCards(); 307 ASSERT_EQ(1U, profiles1.size()); 308 ASSERT_EQ(1U, cards1.size()); 309 EXPECT_EQ(0, profile.Compare(*profiles1[0])); 310 EXPECT_EQ(0, credit_card.Compare(*cards1[0])); 311 312 // Try to update with just the origin changed. 313 AutofillProfile original_profile(profile); 314 CreditCard original_credit_card(credit_card); 315 profile.set_origin("Chrome settings"); 316 credit_card.set_origin("Chrome settings"); 317 318 EXPECT_TRUE(profile.IsVerified()); 319 EXPECT_TRUE(credit_card.IsVerified()); 320 321 personal_data_->UpdateProfile(profile); 322 personal_data_->UpdateCreditCard(credit_card); 323 324 // Note: No refresh, as no update is expected. 325 326 const std::vector<AutofillProfile*>& profiles2 = 327 personal_data_->GetProfiles(); 328 const std::vector<CreditCard*>& cards2 = personal_data_->GetCreditCards(); 329 ASSERT_EQ(1U, profiles2.size()); 330 ASSERT_EQ(1U, cards2.size()); 331 EXPECT_NE(profile.origin(), profiles2[0]->origin()); 332 EXPECT_NE(credit_card.origin(), cards2[0]->origin()); 333 EXPECT_EQ(original_profile.origin(), profiles2[0]->origin()); 334 EXPECT_EQ(original_credit_card.origin(), cards2[0]->origin()); 335 336 // Try to update with data changed as well. 337 profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John")); 338 credit_card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Joe")); 339 340 personal_data_->UpdateProfile(profile); 341 personal_data_->UpdateCreditCard(credit_card); 342 343 // Verify that the web database has been updated and the notification sent. 344 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 345 .WillOnce(QuitMainMessageLoop()); 346 base::MessageLoop::current()->Run(); 347 348 const std::vector<AutofillProfile*>& profiles3 = 349 personal_data_->GetProfiles(); 350 const std::vector<CreditCard*>& cards3 = personal_data_->GetCreditCards(); 351 ASSERT_EQ(1U, profiles3.size()); 352 ASSERT_EQ(1U, cards3.size()); 353 EXPECT_EQ(0, profile.Compare(*profiles3[0])); 354 EXPECT_EQ(0, credit_card.Compare(*cards3[0])); 355 EXPECT_EQ(profile.origin(), profiles3[0]->origin()); 356 EXPECT_EQ(credit_card.origin(), cards3[0]->origin()); 357} 358 359TEST_F(PersonalDataManagerTest, AddProfilesAndCreditCards) { 360 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com"); 361 test::SetProfileInfo(&profile0, 362 "Marion", "Mitchell", "Morrison", 363 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 364 "91601", "US", "12345678910"); 365 366 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com"); 367 test::SetProfileInfo(&profile1, 368 "Josephine", "Alicia", "Saenz", 369 "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", 370 "US", "19482937549"); 371 372 CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com"); 373 test::SetCreditCardInfo(&credit_card0, 374 "John Dillinger", "423456789012" /* Visa */, "01", "2010"); 375 376 CreditCard credit_card1(base::GenerateGUID(), "https://www.example.com"); 377 test::SetCreditCardInfo(&credit_card1, 378 "Bonnie Parker", "518765432109" /* Mastercard */, "12", "2012"); 379 380 // Add two test profiles to the database. 381 personal_data_->AddProfile(profile0); 382 personal_data_->AddProfile(profile1); 383 384 // Verify that the web database has been updated and the notification sent. 385 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 386 .WillOnce(QuitMainMessageLoop()); 387 base::MessageLoop::current()->Run(); 388 389 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 390 ASSERT_EQ(2U, results1.size()); 391 EXPECT_EQ(0, profile0.Compare(*results1[0])); 392 EXPECT_EQ(0, profile1.Compare(*results1[1])); 393 394 // Add two test credit cards to the database. 395 personal_data_->AddCreditCard(credit_card0); 396 personal_data_->AddCreditCard(credit_card1); 397 398 // Verify that the web database has been updated and the notification sent. 399 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 400 .WillOnce(QuitMainMessageLoop()); 401 base::MessageLoop::current()->Run(); 402 403 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 404 ASSERT_EQ(2U, results2.size()); 405 EXPECT_EQ(credit_card0, *results2[0]); 406 EXPECT_EQ(credit_card1, *results2[1]); 407 408 // Determine uniqueness by inserting all of the GUIDs into a set and verifying 409 // the size of the set matches the number of GUIDs. 410 std::set<std::string> guids; 411 guids.insert(profile0.guid()); 412 guids.insert(profile1.guid()); 413 guids.insert(credit_card0.guid()); 414 guids.insert(credit_card1.guid()); 415 EXPECT_EQ(4U, guids.size()); 416} 417 418// Test for http://crbug.com/50047. Makes sure that guids are populated 419// correctly on load. 420TEST_F(PersonalDataManagerTest, PopulateUniqueIDsOnLoad) { 421 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com"); 422 test::SetProfileInfo(&profile0, 423 "y", "", "", "", "", "", "", "", "", "", "", ""); 424 425 // Add the profile0 to the db. 426 personal_data_->AddProfile(profile0); 427 428 // Verify that the web database has been updated and the notification sent. 429 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 430 .WillOnce(QuitMainMessageLoop()); 431 base::MessageLoop::current()->Run(); 432 433 // Verify that we've loaded the profiles from the web database. 434 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 435 ASSERT_EQ(1U, results2.size()); 436 EXPECT_EQ(0, profile0.Compare(*results2[0])); 437 438 // Add a new profile. 439 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com"); 440 test::SetProfileInfo(&profile1, 441 "z", "", "", "", "", "", "", "", "", "", "", ""); 442 personal_data_->AddProfile(profile1); 443 444 // Verify that the web database has been updated and the notification sent. 445 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 446 .WillOnce(QuitMainMessageLoop()); 447 base::MessageLoop::current()->Run(); 448 449 // Make sure the two profiles have different GUIDs, both valid. 450 const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles(); 451 ASSERT_EQ(2U, results3.size()); 452 EXPECT_NE(results3[0]->guid(), results3[1]->guid()); 453 EXPECT_TRUE(base::IsValidGUID(results3[0]->guid())); 454 EXPECT_TRUE(base::IsValidGUID(results3[1]->guid())); 455} 456 457TEST_F(PersonalDataManagerTest, SetEmptyProfile) { 458 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com"); 459 test::SetProfileInfo(&profile0, 460 "", "", "", "", "", "", "", "", "", "", "", ""); 461 462 // Add the empty profile to the database. 463 personal_data_->AddProfile(profile0); 464 465 // Note: no refresh here. 466 467 // Reset the PersonalDataManager. This tests that the personal data was saved 468 // to the web database, and that we can load the profiles from the web 469 // database. 470 ResetPersonalDataManager(USER_MODE_NORMAL); 471 472 // Verify that we've loaded the profiles from the web database. 473 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 474 ASSERT_EQ(0U, results2.size()); 475} 476 477TEST_F(PersonalDataManagerTest, SetEmptyCreditCard) { 478 CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com"); 479 test::SetCreditCardInfo(&credit_card0, "", "", "", ""); 480 481 // Add the empty credit card to the database. 482 personal_data_->AddCreditCard(credit_card0); 483 484 // Note: no refresh here. 485 486 // Reset the PersonalDataManager. This tests that the personal data was saved 487 // to the web database, and that we can load the credit cards from the web 488 // database. 489 ResetPersonalDataManager(USER_MODE_NORMAL); 490 491 // Verify that we've loaded the credit cards from the web database. 492 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 493 ASSERT_EQ(0U, results2.size()); 494} 495 496TEST_F(PersonalDataManagerTest, Refresh) { 497 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com"); 498 test::SetProfileInfo(&profile0, 499 "Marion", "Mitchell", "Morrison", 500 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 501 "91601", "US", "12345678910"); 502 503 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com"); 504 test::SetProfileInfo(&profile1, 505 "Josephine", "Alicia", "Saenz", 506 "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", 507 "US", "19482937549"); 508 509 // Add the test profiles to the database. 510 personal_data_->AddProfile(profile0); 511 personal_data_->AddProfile(profile1); 512 513 // Verify that the web database has been updated and the notification sent. 514 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 515 .WillOnce(QuitMainMessageLoop()); 516 base::MessageLoop::current()->Run(); 517 518 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 519 ASSERT_EQ(2U, results1.size()); 520 EXPECT_EQ(profile0, *results1[0]); 521 EXPECT_EQ(profile1, *results1[1]); 522 523 AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com"); 524 test::SetProfileInfo(&profile2, 525 "Josephine", "Alicia", "Saenz", 526 "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL", 527 "32801", "US", "19482937549"); 528 529 autofill_database_service_->AddAutofillProfile(profile2); 530 531 personal_data_->Refresh(); 532 533 // Verify that the web database has been updated and the notification sent. 534 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 535 .WillOnce(QuitMainMessageLoop()); 536 base::MessageLoop::current()->Run(); 537 538 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 539 ASSERT_EQ(3U, results2.size()); 540 EXPECT_EQ(profile0, *results2[0]); 541 EXPECT_EQ(profile1, *results2[1]); 542 EXPECT_EQ(profile2, *results2[2]); 543 544 autofill_database_service_->RemoveAutofillProfile(profile1.guid()); 545 autofill_database_service_->RemoveAutofillProfile(profile2.guid()); 546 547 // Before telling the PDM to refresh, simulate an edit to one of the deleted 548 // profiles via a SetProfile update (this would happen if the Autofill window 549 // was open with a previous snapshot of the profiles, and something 550 // [e.g. sync] removed a profile from the browser. In this edge case, we will 551 // end up in a consistent state by dropping the write). 552 profile0.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Mar")); 553 profile2.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jo")); 554 personal_data_->UpdateProfile(profile0); 555 personal_data_->AddProfile(profile1); 556 personal_data_->AddProfile(profile2); 557 558 // Verify that the web database has been updated and the notification sent. 559 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 560 .WillOnce(QuitMainMessageLoop()); 561 base::MessageLoop::current()->Run(); 562 563 const std::vector<AutofillProfile*>& results3 = personal_data_->GetProfiles(); 564 ASSERT_EQ(1U, results3.size()); 565 EXPECT_EQ(profile0, *results2[0]); 566} 567 568TEST_F(PersonalDataManagerTest, ImportFormData) { 569 FormData form; 570 FormFieldData field; 571 test::CreateTestFormField( 572 "First name:", "first_name", "George", "text", &field); 573 form.fields.push_back(field); 574 test::CreateTestFormField( 575 "Last name:", "last_name", "Washington", "text", &field); 576 form.fields.push_back(field); 577 test::CreateTestFormField( 578 "Email:", "email", "theprez@gmail.com", "text", &field); 579 form.fields.push_back(field); 580 test::CreateTestFormField( 581 "Address:", "address1", "21 Laussat St", "text", &field); 582 form.fields.push_back(field); 583 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 584 form.fields.push_back(field); 585 test::CreateTestFormField("State:", "state", "California", "text", &field); 586 form.fields.push_back(field); 587 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 588 form.fields.push_back(field); 589 FormStructure form_structure(form); 590 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 591 scoped_ptr<CreditCard> imported_credit_card; 592 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 593 &imported_credit_card)); 594 ASSERT_FALSE(imported_credit_card); 595 596 // Verify that the web database has been updated and the notification sent. 597 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 598 .WillOnce(QuitMainMessageLoop()); 599 base::MessageLoop::current()->Run(); 600 601 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com"); 602 test::SetProfileInfo(&expected, "George", NULL, 603 "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL, 604 "San Francisco", "California", "94102", NULL, NULL); 605 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles(); 606 ASSERT_EQ(1U, results.size()); 607 EXPECT_EQ(0, expected.Compare(*results[0])); 608} 609 610TEST_F(PersonalDataManagerTest, ImportFormDataBadEmail) { 611 FormData form; 612 FormFieldData field; 613 test::CreateTestFormField( 614 "First name:", "first_name", "George", "text", &field); 615 form.fields.push_back(field); 616 test::CreateTestFormField( 617 "Last name:", "last_name", "Washington", "text", &field); 618 form.fields.push_back(field); 619 test::CreateTestFormField("Email:", "email", "bogus", "text", &field); 620 form.fields.push_back(field); 621 test::CreateTestFormField( 622 "Address:", "address1", "21 Laussat St", "text", &field); 623 form.fields.push_back(field); 624 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 625 form.fields.push_back(field); 626 test::CreateTestFormField("State:", "state", "California", "text", &field); 627 form.fields.push_back(field); 628 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 629 form.fields.push_back(field); 630 FormStructure form_structure(form); 631 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 632 scoped_ptr<CreditCard> imported_credit_card; 633 EXPECT_FALSE(personal_data_->ImportFormData(form_structure, 634 &imported_credit_card)); 635 ASSERT_EQ(static_cast<CreditCard*>(NULL), imported_credit_card.get()); 636 637 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles(); 638 ASSERT_EQ(0U, results.size()); 639} 640 641// Tests that a 'confirm email' field does not block profile import. 642TEST_F(PersonalDataManagerTest, ImportFormDataTwoEmails) { 643 FormData form; 644 FormFieldData field; 645 test::CreateTestFormField( 646 "Name:", "name", "George Washington", "text", &field); 647 form.fields.push_back(field); 648 test::CreateTestFormField( 649 "Address:", "address1", "21 Laussat St", "text", &field); 650 form.fields.push_back(field); 651 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 652 form.fields.push_back(field); 653 test::CreateTestFormField("State:", "state", "California", "text", &field); 654 form.fields.push_back(field); 655 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 656 form.fields.push_back(field); 657 test::CreateTestFormField( 658 "Email:", "email", "example@example.com", "text", &field); 659 form.fields.push_back(field); 660 test::CreateTestFormField( 661 "Confirm email:", "confirm_email", "example@example.com", "text", &field); 662 form.fields.push_back(field); 663 FormStructure form_structure(form); 664 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 665 scoped_ptr<CreditCard> imported_credit_card; 666 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 667 &imported_credit_card)); 668 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles(); 669 ASSERT_EQ(1U, results.size()); 670} 671 672// Tests two email fields containing different values blocks provile import. 673TEST_F(PersonalDataManagerTest, ImportFormDataTwoDifferentEmails) { 674 FormData form; 675 FormFieldData field; 676 test::CreateTestFormField( 677 "Name:", "name", "George Washington", "text", &field); 678 form.fields.push_back(field); 679 test::CreateTestFormField( 680 "Address:", "address1", "21 Laussat St", "text", &field); 681 form.fields.push_back(field); 682 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 683 form.fields.push_back(field); 684 test::CreateTestFormField("State:", "state", "California", "text", &field); 685 form.fields.push_back(field); 686 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 687 form.fields.push_back(field); 688 test::CreateTestFormField( 689 "Email:", "email", "example@example.com", "text", &field); 690 form.fields.push_back(field); 691 test::CreateTestFormField( 692 "Email:", "email2", "example2@example.com", "text", &field); 693 form.fields.push_back(field); 694 FormStructure form_structure(form); 695 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 696 scoped_ptr<CreditCard> imported_credit_card; 697 EXPECT_FALSE(personal_data_->ImportFormData(form_structure, 698 &imported_credit_card)); 699 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles(); 700 ASSERT_EQ(0U, results.size()); 701} 702 703TEST_F(PersonalDataManagerTest, ImportFormDataNotEnoughFilledFields) { 704 FormData form; 705 FormFieldData field; 706 test::CreateTestFormField( 707 "First name:", "first_name", "George", "text", &field); 708 form.fields.push_back(field); 709 test::CreateTestFormField( 710 "Last name:", "last_name", "Washington", "text", &field); 711 form.fields.push_back(field); 712 test::CreateTestFormField( 713 "Card number:", "card_number", "4111 1111 1111 1111", "text", &field); 714 form.fields.push_back(field); 715 FormStructure form_structure(form); 716 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 717 scoped_ptr<CreditCard> imported_credit_card; 718 EXPECT_FALSE(personal_data_->ImportFormData(form_structure, 719 &imported_credit_card)); 720 ASSERT_FALSE(imported_credit_card); 721 722 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles(); 723 ASSERT_EQ(0U, profiles.size()); 724 const std::vector<CreditCard*>& cards = personal_data_->GetCreditCards(); 725 ASSERT_EQ(0U, cards.size()); 726} 727 728TEST_F(PersonalDataManagerTest, ImportFormMinimumAddressUSA) { 729 // United States addresses must specifiy one address line, a city, state and 730 // zip code. 731 FormData form; 732 FormFieldData field; 733 test::CreateTestFormField("Name:", "name", "Barack Obama", "text", &field); 734 form.fields.push_back(field); 735 test::CreateTestFormField( 736 "Address:", "address", "1600 Pennsylvania Avenue", "text", &field); 737 form.fields.push_back(field); 738 test::CreateTestFormField("City:", "city", "Washington", "text", &field); 739 form.fields.push_back(field); 740 test::CreateTestFormField("State:", "state", "DC", "text", &field); 741 form.fields.push_back(field); 742 test::CreateTestFormField("Zip:", "zip", "20500", "text", &field); 743 form.fields.push_back(field); 744 test::CreateTestFormField("Country:", "country", "USA", "text", &field); 745 form.fields.push_back(field); 746 FormStructure form_structure(form); 747 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 748 scoped_ptr<CreditCard> imported_credit_card; 749 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 750 &imported_credit_card)); 751 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles(); 752 ASSERT_EQ(1U, profiles.size()); 753} 754 755TEST_F(PersonalDataManagerTest, ImportFormMinimumAddressGB) { 756 // British addresses do not require a state/province as the county is usually 757 // not requested on forms. 758 FormData form; 759 FormFieldData field; 760 test::CreateTestFormField("Name:", "name", "David Cameron", "text", &field); 761 form.fields.push_back(field); 762 test::CreateTestFormField( 763 "Address:", "address", "10 Downing Street", "text", &field); 764 form.fields.push_back(field); 765 test::CreateTestFormField("City:", "city", "London", "text", &field); 766 form.fields.push_back(field); 767 test::CreateTestFormField( 768 "Postcode:", "postcode", "SW1A 2AA", "text", &field); 769 form.fields.push_back(field); 770 test::CreateTestFormField( 771 "Country:", "country", "United Kingdom", "text", &field); 772 form.fields.push_back(field); 773 FormStructure form_structure(form); 774 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 775 scoped_ptr<CreditCard> imported_credit_card; 776 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 777 &imported_credit_card)); 778 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles(); 779 ASSERT_EQ(1U, profiles.size()); 780} 781 782TEST_F(PersonalDataManagerTest, ImportFormMinimumAddressGI) { 783 // Gibraltar has the most minimal set of requirements for a valid address. 784 // There are no cities or provinces and no postal/zip code system. 785 FormData form; 786 FormFieldData field; 787 test::CreateTestFormField( 788 "Name:", "name", "Sir Adrian Johns", "text", &field); 789 form.fields.push_back(field); 790 test::CreateTestFormField( 791 "Address:", "address", "The Convent, Main Street", "text", &field); 792 form.fields.push_back(field); 793 test::CreateTestFormField("Country:", "country", "Gibraltar", "text", &field); 794 form.fields.push_back(field); 795 FormStructure form_structure(form); 796 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 797 scoped_ptr<CreditCard> imported_credit_card; 798 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 799 &imported_credit_card)); 800 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles(); 801 ASSERT_EQ(1U, profiles.size()); 802} 803 804TEST_F(PersonalDataManagerTest, ImportPhoneNumberSplitAcrossMultipleFields) { 805 FormData form; 806 FormFieldData field; 807 test::CreateTestFormField( 808 "First name:", "first_name", "George", "text", &field); 809 form.fields.push_back(field); 810 test::CreateTestFormField( 811 "Last name:", "last_name", "Washington", "text", &field); 812 form.fields.push_back(field); 813 test::CreateTestFormField( 814 "Phone #:", "home_phone_area_code", "650", "text", &field); 815 field.max_length = 3; 816 form.fields.push_back(field); 817 test::CreateTestFormField( 818 "Phone #:", "home_phone_prefix", "555", "text", &field); 819 field.max_length = 3; 820 form.fields.push_back(field); 821 test::CreateTestFormField( 822 "Phone #:", "home_phone_suffix", "0000", "text", &field); 823 field.max_length = 4; 824 form.fields.push_back(field); 825 test::CreateTestFormField( 826 "Address:", "address1", "21 Laussat St", "text", &field); 827 form.fields.push_back(field); 828 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 829 form.fields.push_back(field); 830 test::CreateTestFormField("State:", "state", "California", "text", &field); 831 form.fields.push_back(field); 832 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 833 form.fields.push_back(field); 834 FormStructure form_structure(form); 835 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 836 scoped_ptr<CreditCard> imported_credit_card; 837 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 838 &imported_credit_card)); 839 ASSERT_FALSE(imported_credit_card); 840 841 // Verify that the web database has been updated and the notification sent. 842 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 843 .WillOnce(QuitMainMessageLoop()); 844 base::MessageLoop::current()->Run(); 845 846 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com"); 847 test::SetProfileInfo(&expected, "George", NULL, 848 "Washington", NULL, NULL, "21 Laussat St", NULL, 849 "San Francisco", "California", "94102", NULL, "(650) 555-0000"); 850 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles(); 851 ASSERT_EQ(1U, results.size()); 852 EXPECT_EQ(0, expected.Compare(*results[0])); 853} 854 855TEST_F(PersonalDataManagerTest, ImportFormDataMultilineAddress) { 856 FormData form; 857 FormFieldData field; 858 test::CreateTestFormField( 859 "First name:", "first_name", "George", "text", &field); 860 form.fields.push_back(field); 861 test::CreateTestFormField( 862 "Last name:", "last_name", "Washington", "text", &field); 863 form.fields.push_back(field); 864 test::CreateTestFormField( 865 "Email:", "email", "theprez@gmail.com", "text", &field); 866 form.fields.push_back(field); 867 test::CreateTestFormField( 868 "Address:", 869 "street_address", 870 "21 Laussat St\n" 871 "Apt. #42", 872 "textarea", 873 &field); 874 form.fields.push_back(field); 875 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 876 form.fields.push_back(field); 877 test::CreateTestFormField("State:", "state", "California", "text", &field); 878 form.fields.push_back(field); 879 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 880 form.fields.push_back(field); 881 FormStructure form_structure(form); 882 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 883 scoped_ptr<CreditCard> imported_credit_card; 884 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 885 &imported_credit_card)); 886 ASSERT_FALSE(imported_credit_card); 887 888 // Verify that the web database has been updated and the notification sent. 889 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 890 .WillOnce(QuitMainMessageLoop()); 891 base::MessageLoop::current()->Run(); 892 893 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com"); 894 test::SetProfileInfo(&expected, "George", NULL, 895 "Washington", "theprez@gmail.com", NULL, "21 Laussat St", "Apt. #42", 896 "San Francisco", "California", "94102", NULL, NULL); 897 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles(); 898 ASSERT_EQ(1U, results.size()); 899 EXPECT_EQ(0, expected.Compare(*results[0])); 900} 901 902TEST_F(PersonalDataManagerTest, SetUniqueCreditCardLabels) { 903 CreditCard credit_card0(base::GenerateGUID(), "https://www.example.com"); 904 credit_card0.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("John")); 905 CreditCard credit_card1(base::GenerateGUID(), "https://www.example.com"); 906 credit_card1.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Paul")); 907 CreditCard credit_card2(base::GenerateGUID(), "https://www.example.com"); 908 credit_card2.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Ringo")); 909 CreditCard credit_card3(base::GenerateGUID(), "https://www.example.com"); 910 credit_card3.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Other")); 911 CreditCard credit_card4(base::GenerateGUID(), "https://www.example.com"); 912 credit_card4.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Ozzy")); 913 CreditCard credit_card5(base::GenerateGUID(), "https://www.example.com"); 914 credit_card5.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Dio")); 915 916 // Add the test credit cards to the database. 917 personal_data_->AddCreditCard(credit_card0); 918 personal_data_->AddCreditCard(credit_card1); 919 personal_data_->AddCreditCard(credit_card2); 920 personal_data_->AddCreditCard(credit_card3); 921 personal_data_->AddCreditCard(credit_card4); 922 personal_data_->AddCreditCard(credit_card5); 923 924 // Reset the PersonalDataManager. This tests that the personal data was saved 925 // to the web database, and that we can load the credit cards from the web 926 // database. 927 ResetPersonalDataManager(USER_MODE_NORMAL); 928 929 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards(); 930 ASSERT_EQ(6U, results.size()); 931 EXPECT_EQ(credit_card0.guid(), results[0]->guid()); 932 EXPECT_EQ(credit_card1.guid(), results[1]->guid()); 933 EXPECT_EQ(credit_card2.guid(), results[2]->guid()); 934 EXPECT_EQ(credit_card3.guid(), results[3]->guid()); 935 EXPECT_EQ(credit_card4.guid(), results[4]->guid()); 936 EXPECT_EQ(credit_card5.guid(), results[5]->guid()); 937} 938 939TEST_F(PersonalDataManagerTest, AggregateTwoDifferentProfiles) { 940 FormData form1; 941 FormFieldData field; 942 test::CreateTestFormField( 943 "First name:", "first_name", "George", "text", &field); 944 form1.fields.push_back(field); 945 test::CreateTestFormField( 946 "Last name:", "last_name", "Washington", "text", &field); 947 form1.fields.push_back(field); 948 test::CreateTestFormField( 949 "Email:", "email", "theprez@gmail.com", "text", &field); 950 form1.fields.push_back(field); 951 test::CreateTestFormField( 952 "Address:", "address1", "21 Laussat St", "text", &field); 953 form1.fields.push_back(field); 954 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 955 form1.fields.push_back(field); 956 test::CreateTestFormField("State:", "state", "California", "text", &field); 957 form1.fields.push_back(field); 958 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 959 form1.fields.push_back(field); 960 961 FormStructure form_structure1(form1); 962 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 963 scoped_ptr<CreditCard> imported_credit_card; 964 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 965 &imported_credit_card)); 966 ASSERT_FALSE(imported_credit_card); 967 968 // Verify that the web database has been updated and the notification sent. 969 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 970 .WillOnce(QuitMainMessageLoop()); 971 base::MessageLoop::current()->Run(); 972 973 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com"); 974 test::SetProfileInfo(&expected, "George", NULL, 975 "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL, 976 "San Francisco", "California", "94102", NULL, NULL); 977 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 978 ASSERT_EQ(1U, results1.size()); 979 EXPECT_EQ(0, expected.Compare(*results1[0])); 980 981 // Now create a completely different profile. 982 FormData form2; 983 test::CreateTestFormField( 984 "First name:", "first_name", "John", "text", &field); 985 form2.fields.push_back(field); 986 test::CreateTestFormField( 987 "Last name:", "last_name", "Adams", "text", &field); 988 form2.fields.push_back(field); 989 test::CreateTestFormField( 990 "Email:", "email", "second@gmail.com", "text", &field); 991 form2.fields.push_back(field); 992 test::CreateTestFormField( 993 "Address:", "address1", "22 Laussat St", "text", &field); 994 form2.fields.push_back(field); 995 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 996 form2.fields.push_back(field); 997 test::CreateTestFormField("State:", "state", "California", "text", &field); 998 form2.fields.push_back(field); 999 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 1000 form2.fields.push_back(field); 1001 1002 FormStructure form_structure2(form2); 1003 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1004 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2, 1005 &imported_credit_card)); 1006 ASSERT_FALSE(imported_credit_card); 1007 1008 // Verify that the web database has been updated and the notification sent. 1009 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1010 .WillOnce(QuitMainMessageLoop()); 1011 base::MessageLoop::current()->Run(); 1012 1013 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 1014 1015 AutofillProfile expected2(base::GenerateGUID(), "https://www.example.com"); 1016 test::SetProfileInfo(&expected2, "John", NULL, 1017 "Adams", "second@gmail.com", NULL, "22 Laussat St", NULL, 1018 "San Francisco", "California", "94102", NULL, NULL); 1019 ASSERT_EQ(2U, results2.size()); 1020 EXPECT_EQ(0, expected.Compare(*results2[0])); 1021 EXPECT_EQ(0, expected2.Compare(*results2[1])); 1022} 1023 1024TEST_F(PersonalDataManagerTest, AggregateTwoProfilesWithMultiValue) { 1025 FormData form1; 1026 FormFieldData field; 1027 test::CreateTestFormField( 1028 "First name:", "first_name", "George", "text", &field); 1029 form1.fields.push_back(field); 1030 test::CreateTestFormField( 1031 "Last name:", "last_name", "Washington", "text", &field); 1032 form1.fields.push_back(field); 1033 test::CreateTestFormField( 1034 "Email:", "email", "theprez@gmail.com", "text", &field); 1035 form1.fields.push_back(field); 1036 test::CreateTestFormField( 1037 "Address:", "address1", "21 Laussat St", "text", &field); 1038 form1.fields.push_back(field); 1039 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 1040 form1.fields.push_back(field); 1041 test::CreateTestFormField("State:", "state", "California", "text", &field); 1042 form1.fields.push_back(field); 1043 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 1044 form1.fields.push_back(field); 1045 1046 FormStructure form_structure1(form1); 1047 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1048 scoped_ptr<CreditCard> imported_credit_card; 1049 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 1050 &imported_credit_card)); 1051 ASSERT_FALSE(imported_credit_card); 1052 1053 // Verify that the web database has been updated and the notification sent. 1054 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1055 .WillOnce(QuitMainMessageLoop()); 1056 base::MessageLoop::current()->Run(); 1057 1058 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com"); 1059 test::SetProfileInfo(&expected, "George", NULL, 1060 "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL, 1061 "San Francisco", "California", "94102", NULL, NULL); 1062 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 1063 ASSERT_EQ(1U, results1.size()); 1064 EXPECT_EQ(0, expected.Compare(*results1[0])); 1065 1066 // Now create a completely different profile. 1067 FormData form2; 1068 test::CreateTestFormField( 1069 "First name:", "first_name", "John", "text", &field); 1070 form2.fields.push_back(field); 1071 test::CreateTestFormField("Last name:", "last_name", "Adams", "text", &field); 1072 form2.fields.push_back(field); 1073 test::CreateTestFormField( 1074 "Email:", "email", "second@gmail.com", "text", &field); 1075 form2.fields.push_back(field); 1076 test::CreateTestFormField( 1077 "Address:", "address1", "21 Laussat St", "text", &field); 1078 form2.fields.push_back(field); 1079 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 1080 form2.fields.push_back(field); 1081 test::CreateTestFormField("State:", "state", "California", "text", &field); 1082 form2.fields.push_back(field); 1083 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 1084 form2.fields.push_back(field); 1085 1086 FormStructure form_structure2(form2); 1087 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1088 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2, 1089 &imported_credit_card)); 1090 ASSERT_FALSE(imported_credit_card); 1091 1092 // Verify that the web database has been updated and the notification sent. 1093 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1094 .WillOnce(QuitMainMessageLoop()); 1095 base::MessageLoop::current()->Run(); 1096 1097 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 1098 1099 // Modify expected to include multi-valued fields. 1100 std::vector<base::string16> values; 1101 expected.GetRawMultiInfo(NAME_FULL, &values); 1102 values.push_back(ASCIIToUTF16("John Adams")); 1103 expected.SetRawMultiInfo(NAME_FULL, values); 1104 expected.GetRawMultiInfo(EMAIL_ADDRESS, &values); 1105 values.push_back(ASCIIToUTF16("second@gmail.com")); 1106 expected.SetRawMultiInfo(EMAIL_ADDRESS, values); 1107 1108 ASSERT_EQ(1U, results2.size()); 1109 EXPECT_EQ(0, expected.Compare(*results2[0])); 1110} 1111 1112TEST_F(PersonalDataManagerTest, AggregateSameProfileWithConflict) { 1113 FormData form1; 1114 FormFieldData field; 1115 test::CreateTestFormField( 1116 "First name:", "first_name", "George", "text", &field); 1117 form1.fields.push_back(field); 1118 test::CreateTestFormField( 1119 "Last name:", "last_name", "Washington", "text", &field); 1120 form1.fields.push_back(field); 1121 test::CreateTestFormField( 1122 "Address:", "address", "1600 Pennsylvania Avenue", "text", &field); 1123 form1.fields.push_back(field); 1124 test::CreateTestFormField( 1125 "Address Line 2:", "address2", "Suite A", "text", &field); 1126 form1.fields.push_back(field); 1127 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 1128 form1.fields.push_back(field); 1129 test::CreateTestFormField("State:", "state", "California", "text", &field); 1130 form1.fields.push_back(field); 1131 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 1132 form1.fields.push_back(field); 1133 test::CreateTestFormField( 1134 "Email:", "email", "theprez@gmail.com", "text", &field); 1135 form1.fields.push_back(field); 1136 test::CreateTestFormField("Phone:", "phone", "6505556666", "text", &field); 1137 form1.fields.push_back(field); 1138 1139 FormStructure form_structure1(form1); 1140 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1141 scoped_ptr<CreditCard> imported_credit_card; 1142 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 1143 &imported_credit_card)); 1144 ASSERT_FALSE(imported_credit_card); 1145 1146 // Verify that the web database has been updated and the notification sent. 1147 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1148 .WillOnce(QuitMainMessageLoop()); 1149 base::MessageLoop::current()->Run(); 1150 1151 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com"); 1152 test::SetProfileInfo( 1153 &expected, "George", NULL, "Washington", "theprez@gmail.com", NULL, 1154 "1600 Pennsylvania Avenue", "Suite A", "San Francisco", "California", 1155 "94102", NULL, "(650) 555-6666"); 1156 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 1157 ASSERT_EQ(1U, results1.size()); 1158 EXPECT_EQ(0, expected.Compare(*results1[0])); 1159 1160 // Now create an updated profile. 1161 FormData form2; 1162 test::CreateTestFormField( 1163 "First name:", "first_name", "George", "text", &field); 1164 form2.fields.push_back(field); 1165 test::CreateTestFormField( 1166 "Last name:", "last_name", "Washington", "text", &field); 1167 form2.fields.push_back(field); 1168 test::CreateTestFormField( 1169 "Address:", "address", "1600 Pennsylvania Avenue", "text", &field); 1170 form2.fields.push_back(field); 1171 test::CreateTestFormField( 1172 "Address Line 2:", "address2", "Suite A", "text", &field); 1173 form2.fields.push_back(field); 1174 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 1175 form2.fields.push_back(field); 1176 test::CreateTestFormField("State:", "state", "California", "text", &field); 1177 form2.fields.push_back(field); 1178 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 1179 form2.fields.push_back(field); 1180 test::CreateTestFormField( 1181 "Email:", "email", "theprez@gmail.com", "text", &field); 1182 form2.fields.push_back(field); 1183 // Country gets added. 1184 test::CreateTestFormField("Country:", "country", "USA", "text", &field); 1185 form2.fields.push_back(field); 1186 // Phone gets updated. 1187 test::CreateTestFormField("Phone:", "phone", "6502231234", "text", &field); 1188 form2.fields.push_back(field); 1189 1190 FormStructure form_structure2(form2); 1191 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1192 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2, 1193 &imported_credit_card)); 1194 ASSERT_FALSE(imported_credit_card); 1195 1196 // Verify that the web database has been updated and the notification sent. 1197 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1198 .WillOnce(QuitMainMessageLoop()); 1199 base::MessageLoop::current()->Run(); 1200 1201 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 1202 1203 // Add multi-valued phone number to expectation. Also, country gets added. 1204 std::vector<base::string16> values; 1205 expected.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values); 1206 values.push_back(ASCIIToUTF16("(650) 223-1234")); 1207 expected.SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, values); 1208 expected.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US")); 1209 ASSERT_EQ(1U, results2.size()); 1210 EXPECT_EQ(0, expected.Compare(*results2[0])); 1211} 1212 1213TEST_F(PersonalDataManagerTest, AggregateProfileWithMissingInfoInOld) { 1214 FormData form1; 1215 FormFieldData field; 1216 test::CreateTestFormField( 1217 "First name:", "first_name", "George", "text", &field); 1218 form1.fields.push_back(field); 1219 test::CreateTestFormField( 1220 "Last name:", "last_name", "Washington", "text", &field); 1221 form1.fields.push_back(field); 1222 test::CreateTestFormField( 1223 "Address Line 1:", "address", "190 High Street", "text", &field); 1224 form1.fields.push_back(field); 1225 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field); 1226 form1.fields.push_back(field); 1227 test::CreateTestFormField("State:", "state", "Pennsylvania", "text", &field); 1228 form1.fields.push_back(field); 1229 test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field); 1230 form1.fields.push_back(field); 1231 1232 FormStructure form_structure1(form1); 1233 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1234 scoped_ptr<CreditCard> imported_credit_card; 1235 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 1236 &imported_credit_card)); 1237 EXPECT_FALSE(imported_credit_card); 1238 1239 // Verify that the web database has been updated and the notification sent. 1240 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1241 .WillOnce(QuitMainMessageLoop()); 1242 base::MessageLoop::current()->Run(); 1243 1244 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com"); 1245 test::SetProfileInfo(&expected, "George", NULL, 1246 "Washington", NULL, NULL, "190 High Street", NULL, 1247 "Philadelphia", "Pennsylvania", "19106", NULL, NULL); 1248 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 1249 ASSERT_EQ(1U, results1.size()); 1250 EXPECT_EQ(0, expected.Compare(*results1[0])); 1251 1252 // Submit a form with new data for the first profile. 1253 FormData form2; 1254 test::CreateTestFormField( 1255 "First name:", "first_name", "George", "text", &field); 1256 form2.fields.push_back(field); 1257 test::CreateTestFormField( 1258 "Last name:", "last_name", "Washington", "text", &field); 1259 form2.fields.push_back(field); 1260 test::CreateTestFormField( 1261 "Email:", "email", "theprez@gmail.com", "text", &field); 1262 form2.fields.push_back(field); 1263 test::CreateTestFormField( 1264 "Address Line 1:", "address", "190 High Street", "text", &field); 1265 form2.fields.push_back(field); 1266 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field); 1267 form2.fields.push_back(field); 1268 test::CreateTestFormField("State:", "state", "Pennsylvania", "text", &field); 1269 form2.fields.push_back(field); 1270 test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field); 1271 form2.fields.push_back(field); 1272 1273 FormStructure form_structure2(form2); 1274 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1275 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2, 1276 &imported_credit_card)); 1277 ASSERT_FALSE(imported_credit_card); 1278 1279 // Verify that the web database has been updated and the notification sent. 1280 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1281 .WillOnce(QuitMainMessageLoop()); 1282 base::MessageLoop::current()->Run(); 1283 1284 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 1285 1286 AutofillProfile expected2(base::GenerateGUID(), "https://www.example.com"); 1287 test::SetProfileInfo(&expected2, "George", NULL, 1288 "Washington", "theprez@gmail.com", NULL, "190 High Street", NULL, 1289 "Philadelphia", "Pennsylvania", "19106", NULL, NULL); 1290 ASSERT_EQ(1U, results2.size()); 1291 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1292} 1293 1294TEST_F(PersonalDataManagerTest, AggregateProfileWithMissingInfoInNew) { 1295 FormData form1; 1296 FormFieldData field; 1297 test::CreateTestFormField( 1298 "First name:", "first_name", "George", "text", &field); 1299 form1.fields.push_back(field); 1300 test::CreateTestFormField( 1301 "Last name:", "last_name", "Washington", "text", &field); 1302 form1.fields.push_back(field); 1303 test::CreateTestFormField( 1304 "Company:", "company", "Government", "text", &field); 1305 form1.fields.push_back(field); 1306 test::CreateTestFormField( 1307 "Email:", "email", "theprez@gmail.com", "text", &field); 1308 form1.fields.push_back(field); 1309 test::CreateTestFormField( 1310 "Address Line 1:", "address", "190 High Street", "text", &field); 1311 form1.fields.push_back(field); 1312 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field); 1313 form1.fields.push_back(field); 1314 test::CreateTestFormField("State:", "state", "Pennsylvania", "text", &field); 1315 form1.fields.push_back(field); 1316 test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field); 1317 form1.fields.push_back(field); 1318 1319 FormStructure form_structure1(form1); 1320 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1321 scoped_ptr<CreditCard> imported_credit_card; 1322 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 1323 &imported_credit_card)); 1324 ASSERT_FALSE(imported_credit_card); 1325 1326 // Verify that the web database has been updated and the notification sent. 1327 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1328 .WillOnce(QuitMainMessageLoop()); 1329 base::MessageLoop::current()->Run(); 1330 1331 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com"); 1332 test::SetProfileInfo(&expected, "George", NULL, 1333 "Washington", "theprez@gmail.com", "Government", "190 High Street", NULL, 1334 "Philadelphia", "Pennsylvania", "19106", NULL, NULL); 1335 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 1336 ASSERT_EQ(1U, results1.size()); 1337 EXPECT_EQ(0, expected.Compare(*results1[0])); 1338 1339 // Submit a form with new data for the first profile. 1340 FormData form2; 1341 test::CreateTestFormField( 1342 "First name:", "first_name", "George", "text", &field); 1343 form2.fields.push_back(field); 1344 test::CreateTestFormField( 1345 "Last name:", "last_name", "Washington", "text", &field); 1346 form2.fields.push_back(field); 1347 // Note missing Company field. 1348 test::CreateTestFormField( 1349 "Email:", "email", "theprez@gmail.com", "text", &field); 1350 form2.fields.push_back(field); 1351 test::CreateTestFormField( 1352 "Address Line 1:", "address", "190 High Street", "text", &field); 1353 form2.fields.push_back(field); 1354 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field); 1355 form2.fields.push_back(field); 1356 test::CreateTestFormField("State:", "state", "Pennsylvania", "text", &field); 1357 form2.fields.push_back(field); 1358 test::CreateTestFormField("Zip:", "zipcode", "19106", "text", &field); 1359 form2.fields.push_back(field); 1360 1361 FormStructure form_structure2(form2); 1362 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1363 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2, 1364 &imported_credit_card)); 1365 ASSERT_FALSE(imported_credit_card); 1366 1367 // Verify that the web database has been updated and the notification sent. 1368 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1369 .WillOnce(QuitMainMessageLoop()); 1370 base::MessageLoop::current()->Run(); 1371 1372 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 1373 1374 // Expect no change. 1375 ASSERT_EQ(1U, results2.size()); 1376 EXPECT_EQ(0, expected.Compare(*results2[0])); 1377} 1378 1379TEST_F(PersonalDataManagerTest, AggregateProfileWithInsufficientAddress) { 1380 FormData form1; 1381 FormFieldData field; 1382 test::CreateTestFormField( 1383 "First name:", "first_name", "George", "text", &field); 1384 form1.fields.push_back(field); 1385 test::CreateTestFormField( 1386 "Last name:", "last_name", "Washington", "text", &field); 1387 form1.fields.push_back(field); 1388 test::CreateTestFormField( 1389 "Company:", "company", "Government", "text", &field); 1390 form1.fields.push_back(field); 1391 test::CreateTestFormField( 1392 "Email:", "email", "theprez@gmail.com", "text", &field); 1393 form1.fields.push_back(field); 1394 test::CreateTestFormField( 1395 "Address Line 1:", "address", "190 High Street", "text", &field); 1396 form1.fields.push_back(field); 1397 test::CreateTestFormField("City:", "city", "Philadelphia", "text", &field); 1398 form1.fields.push_back(field); 1399 1400 FormStructure form_structure1(form1); 1401 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1402 scoped_ptr<CreditCard> imported_credit_card; 1403 EXPECT_FALSE(personal_data_->ImportFormData(form_structure1, 1404 &imported_credit_card)); 1405 ASSERT_FALSE(imported_credit_card); 1406 1407 // Since no refresh is expected, reload the data from the database to make 1408 // sure no changes were written out. 1409 ResetPersonalDataManager(USER_MODE_NORMAL); 1410 1411 const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles(); 1412 ASSERT_EQ(0U, profiles.size()); 1413 const std::vector<CreditCard*>& cards = personal_data_->GetCreditCards(); 1414 ASSERT_EQ(0U, cards.size()); 1415} 1416 1417TEST_F(PersonalDataManagerTest, AggregateExistingAuxiliaryProfile) { 1418 // Simulate having access to an auxiliary profile. 1419 // |auxiliary_profile| will be owned by |personal_data_|. 1420 AutofillProfile* auxiliary_profile = 1421 new AutofillProfile(base::GenerateGUID(), "https://www.example.com"); 1422 test::SetProfileInfo(auxiliary_profile, 1423 "Tester", "Frederick", "McAddressBookTesterson", 1424 "tester@example.com", "Acme Inc.", "1 Main", "Apt A", "San Francisco", 1425 "CA", "94102", "US", "1.415.888.9999"); 1426 ScopedVector<AutofillProfile>& auxiliary_profiles = 1427 personal_data_->auxiliary_profiles_; 1428 auxiliary_profiles.push_back(auxiliary_profile); 1429 1430 // Simulate a form submission with a subset of the info. 1431 // Note that the phone number format is different from the saved format. 1432 FormData form; 1433 FormFieldData field; 1434 test::CreateTestFormField( 1435 "First name:", "first_name", "Tester", "text", &field); 1436 form.fields.push_back(field); 1437 test::CreateTestFormField( 1438 "Last name:", "last_name", "McAddressBookTesterson", "text", &field); 1439 form.fields.push_back(field); 1440 test::CreateTestFormField( 1441 "Email:", "email", "tester@example.com", "text", &field); 1442 form.fields.push_back(field); 1443 test::CreateTestFormField("Address:", "address1", "1 Main", "text", &field); 1444 form.fields.push_back(field); 1445 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 1446 form.fields.push_back(field); 1447 test::CreateTestFormField("State:", "state", "CA", "text", &field); 1448 form.fields.push_back(field); 1449 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 1450 form.fields.push_back(field); 1451 test::CreateTestFormField("Phone:", "phone", "4158889999", "text", &field); 1452 form.fields.push_back(field); 1453 1454 FormStructure form_structure(form); 1455 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 1456 scoped_ptr<CreditCard> imported_credit_card; 1457 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 1458 &imported_credit_card)); 1459 EXPECT_FALSE(imported_credit_card); 1460 1461 // Note: No refresh. 1462 1463 // Expect no change. 1464 const std::vector<AutofillProfile*>& web_profiles = 1465 personal_data_->web_profiles(); 1466 EXPECT_EQ(0U, web_profiles.size()); 1467 ASSERT_EQ(1U, auxiliary_profiles.size()); 1468 EXPECT_EQ(0, auxiliary_profile->Compare(*auxiliary_profiles[0])); 1469} 1470 1471TEST_F(PersonalDataManagerTest, AggregateTwoDifferentCreditCards) { 1472 FormData form1; 1473 1474 // Start with a single valid credit card form. 1475 FormFieldData field; 1476 test::CreateTestFormField( 1477 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1478 form1.fields.push_back(field); 1479 test::CreateTestFormField( 1480 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1481 form1.fields.push_back(field); 1482 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1483 form1.fields.push_back(field); 1484 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field); 1485 form1.fields.push_back(field); 1486 1487 FormStructure form_structure1(form1); 1488 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1489 scoped_ptr<CreditCard> imported_credit_card; 1490 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 1491 &imported_credit_card)); 1492 ASSERT_TRUE(imported_credit_card); 1493 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1494 1495 // Verify that the web database has been updated and the notification sent. 1496 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1497 .WillOnce(QuitMainMessageLoop()); 1498 base::MessageLoop::current()->Run(); 1499 1500 CreditCard expected(base::GenerateGUID(), "https://www.example.com"); 1501 test::SetCreditCardInfo(&expected, 1502 "Biggie Smalls", "4111111111111111", "01", "2011"); 1503 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards(); 1504 ASSERT_EQ(1U, results.size()); 1505 EXPECT_EQ(0, expected.Compare(*results[0])); 1506 1507 // Add a second different valid credit card. 1508 FormData form2; 1509 test::CreateTestFormField( 1510 "Name on card:", "name_on_card", "", "text", &field); 1511 form2.fields.push_back(field); 1512 test::CreateTestFormField( 1513 "Card Number:", "card_number", "5500 0000 0000 0004", "text", &field); 1514 form2.fields.push_back(field); 1515 test::CreateTestFormField("Exp Month:", "exp_month", "02", "text", &field); 1516 form2.fields.push_back(field); 1517 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field); 1518 form2.fields.push_back(field); 1519 1520 FormStructure form_structure2(form2); 1521 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1522 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2, 1523 &imported_credit_card)); 1524 ASSERT_TRUE(imported_credit_card); 1525 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1526 1527 // Verify that the web database has been updated and the notification sent. 1528 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1529 .WillOnce(QuitMainMessageLoop()); 1530 base::MessageLoop::current()->Run(); 1531 1532 CreditCard expected2(base::GenerateGUID(), "https://www.example.com"); 1533 test::SetCreditCardInfo(&expected2,"", "5500000000000004", "02", "2012"); 1534 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 1535 ASSERT_EQ(2U, results2.size()); 1536 EXPECT_EQ(0, expected.Compare(*results2[0])); 1537 EXPECT_EQ(0, expected2.Compare(*results2[1])); 1538} 1539 1540TEST_F(PersonalDataManagerTest, AggregateInvalidCreditCard) { 1541 FormData form1; 1542 1543 // Start with a single valid credit card form. 1544 FormFieldData field; 1545 test::CreateTestFormField( 1546 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1547 form1.fields.push_back(field); 1548 test::CreateTestFormField( 1549 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1550 form1.fields.push_back(field); 1551 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1552 form1.fields.push_back(field); 1553 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field); 1554 form1.fields.push_back(field); 1555 1556 FormStructure form_structure1(form1); 1557 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1558 scoped_ptr<CreditCard> imported_credit_card; 1559 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 1560 &imported_credit_card)); 1561 ASSERT_TRUE(imported_credit_card); 1562 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1563 1564 // Verify that the web database has been updated and the notification sent. 1565 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1566 .WillOnce(QuitMainMessageLoop()); 1567 base::MessageLoop::current()->Run(); 1568 1569 CreditCard expected(base::GenerateGUID(), "https://www.example.com"); 1570 test::SetCreditCardInfo(&expected, 1571 "Biggie Smalls", "4111111111111111", "01", "2011"); 1572 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards(); 1573 ASSERT_EQ(1U, results.size()); 1574 EXPECT_EQ(0, expected.Compare(*results[0])); 1575 1576 // Add a second different invalid credit card. 1577 FormData form2; 1578 test::CreateTestFormField( 1579 "Name on card:", "name_on_card", "Jim Johansen", "text", &field); 1580 form2.fields.push_back(field); 1581 test::CreateTestFormField( 1582 "Card Number:", "card_number", "1000000000000000", "text", &field); 1583 form2.fields.push_back(field); 1584 test::CreateTestFormField("Exp Month:", "exp_month", "02", "text", &field); 1585 form2.fields.push_back(field); 1586 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field); 1587 form2.fields.push_back(field); 1588 1589 FormStructure form_structure2(form2); 1590 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1591 EXPECT_FALSE(personal_data_->ImportFormData(form_structure2, 1592 &imported_credit_card)); 1593 ASSERT_FALSE(imported_credit_card); 1594 1595 // Since no refresh is expected, reload the data from the database to make 1596 // sure no changes were written out. 1597 ResetPersonalDataManager(USER_MODE_NORMAL); 1598 1599 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 1600 ASSERT_EQ(1U, results2.size()); 1601 EXPECT_EQ(0, expected.Compare(*results2[0])); 1602} 1603 1604TEST_F(PersonalDataManagerTest, AggregateSameCreditCardWithConflict) { 1605 FormData form1; 1606 1607 // Start with a single valid credit card form. 1608 FormFieldData field; 1609 test::CreateTestFormField( 1610 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1611 form1.fields.push_back(field); 1612 test::CreateTestFormField( 1613 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1614 form1.fields.push_back(field); 1615 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1616 form1.fields.push_back(field); 1617 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field); 1618 form1.fields.push_back(field); 1619 1620 FormStructure form_structure1(form1); 1621 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1622 scoped_ptr<CreditCard> imported_credit_card; 1623 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 1624 &imported_credit_card)); 1625 ASSERT_TRUE(imported_credit_card); 1626 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1627 1628 // Verify that the web database has been updated and the notification sent. 1629 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1630 .WillOnce(QuitMainMessageLoop()); 1631 base::MessageLoop::current()->Run(); 1632 1633 CreditCard expected(base::GenerateGUID(), "https://www.example.com"); 1634 test::SetCreditCardInfo(&expected, 1635 "Biggie Smalls", "4111111111111111", "01", "2011"); 1636 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards(); 1637 ASSERT_EQ(1U, results.size()); 1638 EXPECT_EQ(0, expected.Compare(*results[0])); 1639 1640 // Add a second different valid credit card where the year is different but 1641 // the credit card number matches. 1642 FormData form2; 1643 test::CreateTestFormField( 1644 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1645 form2.fields.push_back(field); 1646 test::CreateTestFormField( 1647 "Card Number:", "card_number", "4111 1111 1111 1111", "text", &field); 1648 form2.fields.push_back(field); 1649 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1650 form2.fields.push_back(field); 1651 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field); 1652 form2.fields.push_back(field); 1653 1654 FormStructure form_structure2(form2); 1655 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1656 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2, 1657 &imported_credit_card)); 1658 EXPECT_FALSE(imported_credit_card); 1659 1660 // Verify that the web database has been updated and the notification sent. 1661 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1662 .WillOnce(QuitMainMessageLoop()); 1663 base::MessageLoop::current()->Run(); 1664 1665 // Expect that the newer information is saved. In this case the year is 1666 // updated to "2012". 1667 CreditCard expected2(base::GenerateGUID(), "https://www.example.com"); 1668 test::SetCreditCardInfo(&expected2, 1669 "Biggie Smalls", "4111111111111111", "01", "2012"); 1670 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 1671 ASSERT_EQ(1U, results2.size()); 1672 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1673} 1674 1675TEST_F(PersonalDataManagerTest, AggregateEmptyCreditCardWithConflict) { 1676 FormData form1; 1677 1678 // Start with a single valid credit card form. 1679 FormFieldData field; 1680 test::CreateTestFormField( 1681 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1682 form1.fields.push_back(field); 1683 test::CreateTestFormField( 1684 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1685 form1.fields.push_back(field); 1686 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1687 form1.fields.push_back(field); 1688 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field); 1689 form1.fields.push_back(field); 1690 1691 FormStructure form_structure1(form1); 1692 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1693 scoped_ptr<CreditCard> imported_credit_card; 1694 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 1695 &imported_credit_card)); 1696 ASSERT_TRUE(imported_credit_card); 1697 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1698 1699 // Verify that the web database has been updated and the notification sent. 1700 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1701 .WillOnce(QuitMainMessageLoop()); 1702 base::MessageLoop::current()->Run(); 1703 1704 CreditCard expected(base::GenerateGUID(), "https://www.example.com"); 1705 test::SetCreditCardInfo(&expected, 1706 "Biggie Smalls", "4111111111111111", "01", "2011"); 1707 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards(); 1708 ASSERT_EQ(1U, results.size()); 1709 EXPECT_EQ(0, expected.Compare(*results[0])); 1710 1711 // Add a second credit card with no number. 1712 FormData form2; 1713 test::CreateTestFormField( 1714 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1715 form2.fields.push_back(field); 1716 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1717 form2.fields.push_back(field); 1718 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field); 1719 form2.fields.push_back(field); 1720 1721 FormStructure form_structure2(form2); 1722 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1723 EXPECT_FALSE(personal_data_->ImportFormData(form_structure2, 1724 &imported_credit_card)); 1725 EXPECT_FALSE(imported_credit_card); 1726 1727 // Since no refresh is expected, reload the data from the database to make 1728 // sure no changes were written out. 1729 ResetPersonalDataManager(USER_MODE_NORMAL); 1730 1731 // No change is expected. 1732 CreditCard expected2(base::GenerateGUID(), "https://www.example.com"); 1733 test::SetCreditCardInfo(&expected2, 1734 "Biggie Smalls", "4111111111111111", "01", "2011"); 1735 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 1736 ASSERT_EQ(1U, results2.size()); 1737 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1738} 1739 1740TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInNew) { 1741 FormData form1; 1742 1743 // Start with a single valid credit card form. 1744 FormFieldData field; 1745 test::CreateTestFormField( 1746 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1747 form1.fields.push_back(field); 1748 test::CreateTestFormField( 1749 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1750 form1.fields.push_back(field); 1751 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1752 form1.fields.push_back(field); 1753 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field); 1754 form1.fields.push_back(field); 1755 1756 FormStructure form_structure1(form1); 1757 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 1758 scoped_ptr<CreditCard> imported_credit_card; 1759 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 1760 &imported_credit_card)); 1761 ASSERT_TRUE(imported_credit_card); 1762 personal_data_->SaveImportedCreditCard(*imported_credit_card); 1763 1764 // Verify that the web database has been updated and the notification sent. 1765 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1766 .WillOnce(QuitMainMessageLoop()); 1767 base::MessageLoop::current()->Run(); 1768 1769 CreditCard expected(base::GenerateGUID(), "https://www.example.com"); 1770 test::SetCreditCardInfo(&expected, 1771 "Biggie Smalls", "4111111111111111", "01", "2011"); 1772 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards(); 1773 ASSERT_EQ(1U, results.size()); 1774 EXPECT_EQ(0, expected.Compare(*results[0])); 1775 1776 // Add a second different valid credit card where the name is missing but 1777 // the credit card number matches. 1778 FormData form2; 1779 // Note missing name. 1780 test::CreateTestFormField( 1781 "Card Number:", "card_number", "4111111111111111", "text", &field); 1782 form2.fields.push_back(field); 1783 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1784 form2.fields.push_back(field); 1785 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field); 1786 form2.fields.push_back(field); 1787 1788 FormStructure form_structure2(form2); 1789 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 1790 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2, 1791 &imported_credit_card)); 1792 EXPECT_FALSE(imported_credit_card); 1793 1794 // Since no refresh is expected, reload the data from the database to make 1795 // sure no changes were written out. 1796 ResetPersonalDataManager(USER_MODE_NORMAL); 1797 1798 // No change is expected. 1799 CreditCard expected2(base::GenerateGUID(), "https://www.example.com"); 1800 test::SetCreditCardInfo(&expected2, 1801 "Biggie Smalls", "4111111111111111", "01", "2011"); 1802 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 1803 ASSERT_EQ(1U, results2.size()); 1804 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1805 1806 // Add a third credit card where the expiration date is missing. 1807 FormData form3; 1808 test::CreateTestFormField( 1809 "Name on card:", "name_on_card", "Johnny McEnroe", "text", &field); 1810 form3.fields.push_back(field); 1811 test::CreateTestFormField( 1812 "Card Number:", "card_number", "5555555555554444", "text", &field); 1813 form3.fields.push_back(field); 1814 // Note missing expiration month and year.. 1815 1816 FormStructure form_structure3(form3); 1817 form_structure3.DetermineHeuristicTypes(TestAutofillMetrics()); 1818 EXPECT_FALSE(personal_data_->ImportFormData(form_structure3, 1819 &imported_credit_card)); 1820 ASSERT_FALSE(imported_credit_card); 1821 1822 // Since no refresh is expected, reload the data from the database to make 1823 // sure no changes were written out. 1824 ResetPersonalDataManager(USER_MODE_NORMAL); 1825 1826 // No change is expected. 1827 CreditCard expected3(base::GenerateGUID(), "https://www.example.com"); 1828 test::SetCreditCardInfo(&expected3, 1829 "Biggie Smalls", "4111111111111111", "01", "2011"); 1830 const std::vector<CreditCard*>& results3 = personal_data_->GetCreditCards(); 1831 ASSERT_EQ(1U, results3.size()); 1832 EXPECT_EQ(0, expected3.Compare(*results3[0])); 1833} 1834 1835TEST_F(PersonalDataManagerTest, AggregateCreditCardWithMissingInfoInOld) { 1836 // Start with a single valid credit card stored via the preferences. 1837 // Note the empty name. 1838 CreditCard saved_credit_card(base::GenerateGUID(), "https://www.example.com"); 1839 test::SetCreditCardInfo(&saved_credit_card, 1840 "", "4111111111111111" /* Visa */, "01", "2011"); 1841 personal_data_->AddCreditCard(saved_credit_card); 1842 1843 // Verify that the web database has been updated and the notification sent. 1844 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1845 .WillOnce(QuitMainMessageLoop()); 1846 base::MessageLoop::current()->Run(); 1847 1848 const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards(); 1849 ASSERT_EQ(1U, results1.size()); 1850 EXPECT_EQ(saved_credit_card, *results1[0]); 1851 1852 1853 // Add a second different valid credit card where the year is different but 1854 // the credit card number matches. 1855 FormData form; 1856 FormFieldData field; 1857 test::CreateTestFormField( 1858 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1859 form.fields.push_back(field); 1860 test::CreateTestFormField( 1861 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1862 form.fields.push_back(field); 1863 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1864 form.fields.push_back(field); 1865 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field); 1866 form.fields.push_back(field); 1867 1868 FormStructure form_structure(form); 1869 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 1870 scoped_ptr<CreditCard> imported_credit_card; 1871 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 1872 &imported_credit_card)); 1873 EXPECT_FALSE(imported_credit_card); 1874 1875 // Verify that the web database has been updated and the notification sent. 1876 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1877 .WillOnce(QuitMainMessageLoop()); 1878 base::MessageLoop::current()->Run(); 1879 1880 // Expect that the newer information is saved. In this case the year is 1881 // added to the existing credit card. 1882 CreditCard expected2(base::GenerateGUID(), "https://www.example.com"); 1883 test::SetCreditCardInfo(&expected2, 1884 "Biggie Smalls", "4111111111111111", "01", "2012"); 1885 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 1886 ASSERT_EQ(1U, results2.size()); 1887 EXPECT_EQ(0, expected2.Compare(*results2[0])); 1888} 1889 1890// We allow the user to store a credit card number with separators via the UI. 1891// We should not try to re-aggregate the same card with the separators stripped. 1892TEST_F(PersonalDataManagerTest, AggregateSameCreditCardWithSeparators) { 1893 // Start with a single valid credit card stored via the preferences. 1894 // Note the separators in the credit card number. 1895 CreditCard saved_credit_card(base::GenerateGUID(), "https://www.example.com"); 1896 test::SetCreditCardInfo(&saved_credit_card, 1897 "Biggie Smalls", "4111 1111 1111 1111" /* Visa */, "01", "2011"); 1898 personal_data_->AddCreditCard(saved_credit_card); 1899 1900 // Verify that the web database has been updated and the notification sent. 1901 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1902 .WillOnce(QuitMainMessageLoop()); 1903 base::MessageLoop::current()->Run(); 1904 1905 const std::vector<CreditCard*>& results1 = personal_data_->GetCreditCards(); 1906 ASSERT_EQ(1U, results1.size()); 1907 EXPECT_EQ(0, saved_credit_card.Compare(*results1[0])); 1908 1909 // Import the same card info, but with different separators in the number. 1910 FormData form; 1911 FormFieldData field; 1912 test::CreateTestFormField( 1913 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 1914 form.fields.push_back(field); 1915 test::CreateTestFormField( 1916 "Card Number:", "card_number", "4111-1111-1111-1111", "text", &field); 1917 form.fields.push_back(field); 1918 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 1919 form.fields.push_back(field); 1920 test::CreateTestFormField("Exp Year:", "exp_year", "2011", "text", &field); 1921 form.fields.push_back(field); 1922 1923 FormStructure form_structure(form); 1924 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 1925 scoped_ptr<CreditCard> imported_credit_card; 1926 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 1927 &imported_credit_card)); 1928 EXPECT_FALSE(imported_credit_card); 1929 1930 // Since no refresh is expected, reload the data from the database to make 1931 // sure no changes were written out. 1932 ResetPersonalDataManager(USER_MODE_NORMAL); 1933 1934 // Expect that no new card is saved. 1935 const std::vector<CreditCard*>& results2 = personal_data_->GetCreditCards(); 1936 ASSERT_EQ(1U, results2.size()); 1937 EXPECT_EQ(0, saved_credit_card.Compare(*results2[0])); 1938} 1939 1940// Ensure that if a verified profile already exists, aggregated profiles cannot 1941// modify it in any way. 1942TEST_F(PersonalDataManagerTest, AggregateExistingVerifiedProfileWithConflict) { 1943 // Start with a verified profile. 1944 AutofillProfile profile(base::GenerateGUID(), "Chrome settings"); 1945 test::SetProfileInfo(&profile, 1946 "Marion", "Mitchell", "Morrison", 1947 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 1948 "91601", "US", "12345678910"); 1949 EXPECT_TRUE(profile.IsVerified()); 1950 1951 // Add the profile to the database. 1952 personal_data_->AddProfile(profile); 1953 1954 // Verify that the web database has been updated and the notification sent. 1955 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1956 .WillOnce(QuitMainMessageLoop()); 1957 base::MessageLoop::current()->Run(); 1958 1959 // Simulate a form submission with conflicting info. 1960 FormData form; 1961 FormFieldData field; 1962 test::CreateTestFormField( 1963 "First name:", "first_name", "Marion", "text", &field); 1964 form.fields.push_back(field); 1965 test::CreateTestFormField( 1966 "Last name:", "last_name", "Morrison", "text", &field); 1967 form.fields.push_back(field); 1968 test::CreateTestFormField( 1969 "Email:", "email", "other.email@example.com", "text", &field); 1970 form.fields.push_back(field); 1971 test::CreateTestFormField( 1972 "Address:", "address1", "123 Zoo St.", "text", &field); 1973 form.fields.push_back(field); 1974 test::CreateTestFormField("City:", "city", "Hollywood", "text", &field); 1975 form.fields.push_back(field); 1976 test::CreateTestFormField("State:", "state", "CA", "text", &field); 1977 form.fields.push_back(field); 1978 test::CreateTestFormField("Zip:", "zip", "91601", "text", &field); 1979 form.fields.push_back(field); 1980 1981 FormStructure form_structure(form); 1982 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 1983 scoped_ptr<CreditCard> imported_credit_card; 1984 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 1985 &imported_credit_card)); 1986 EXPECT_FALSE(imported_credit_card); 1987 1988 // Wait for the refresh, which in this case is a no-op. 1989 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 1990 .WillOnce(QuitMainMessageLoop()); 1991 base::MessageLoop::current()->Run(); 1992 1993 // Expect that no new profile is saved. 1994 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles(); 1995 ASSERT_EQ(1U, results.size()); 1996 EXPECT_EQ(0, profile.Compare(*results[0])); 1997} 1998 1999// Ensure that if a verified credit card already exists, aggregated credit cards 2000// cannot modify it in any way. 2001TEST_F(PersonalDataManagerTest, 2002 AggregateExistingVerifiedCreditCardWithConflict) { 2003 // Start with a verified credit card. 2004 CreditCard credit_card(base::GenerateGUID(), "Chrome settings"); 2005 test::SetCreditCardInfo(&credit_card, 2006 "Biggie Smalls", "4111 1111 1111 1111" /* Visa */, "01", "2011"); 2007 EXPECT_TRUE(credit_card.IsVerified()); 2008 2009 // Add the credit card to the database. 2010 personal_data_->AddCreditCard(credit_card); 2011 2012 // Verify that the web database has been updated and the notification sent. 2013 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2014 .WillOnce(QuitMainMessageLoop()); 2015 base::MessageLoop::current()->Run(); 2016 2017 // Simulate a form submission with conflicting expiration year. 2018 FormData form; 2019 FormFieldData field; 2020 test::CreateTestFormField( 2021 "Name on card:", "name_on_card", "Biggie Smalls", "text", &field); 2022 form.fields.push_back(field); 2023 test::CreateTestFormField( 2024 "Card Number:", "card_number", "4111 1111 1111 1111", "text", &field); 2025 form.fields.push_back(field); 2026 test::CreateTestFormField("Exp Month:", "exp_month", "01", "text", &field); 2027 form.fields.push_back(field); 2028 test::CreateTestFormField("Exp Year:", "exp_year", "2012", "text", &field); 2029 form.fields.push_back(field); 2030 2031 FormStructure form_structure(form); 2032 form_structure.DetermineHeuristicTypes(TestAutofillMetrics()); 2033 scoped_ptr<CreditCard> imported_credit_card; 2034 EXPECT_TRUE(personal_data_->ImportFormData(form_structure, 2035 &imported_credit_card)); 2036 ASSERT_FALSE(imported_credit_card); 2037 2038 // Since no refresh is expected, reload the data from the database to make 2039 // sure no changes were written out. 2040 ResetPersonalDataManager(USER_MODE_NORMAL); 2041 2042 // Expect that the saved credit card is not modified. 2043 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards(); 2044 ASSERT_EQ(1U, results.size()); 2045 EXPECT_EQ(0, credit_card.Compare(*results[0])); 2046} 2047 2048// Ensure that verified profiles can be saved via SaveImportedProfile, 2049// overwriting existing unverified profiles. 2050TEST_F(PersonalDataManagerTest, SaveImportedProfileWithVerifiedData) { 2051 // Start with an unverified profile. 2052 AutofillProfile profile(base::GenerateGUID(), "https://www.example.com"); 2053 test::SetProfileInfo(&profile, 2054 "Marion", "Mitchell", "Morrison", 2055 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 2056 "91601", "US", "12345678910"); 2057 EXPECT_FALSE(profile.IsVerified()); 2058 2059 // Add the profile to the database. 2060 personal_data_->AddProfile(profile); 2061 2062 // Verify that the web database has been updated and the notification sent. 2063 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2064 .WillOnce(QuitMainMessageLoop()); 2065 base::MessageLoop::current()->Run(); 2066 2067 AutofillProfile new_verified_profile = profile; 2068 new_verified_profile.set_guid(base::GenerateGUID()); 2069 new_verified_profile.set_origin("Chrome settings"); 2070 new_verified_profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Fizzbang, Inc.")); 2071 EXPECT_TRUE(new_verified_profile.IsVerified()); 2072 2073 personal_data_->SaveImportedProfile(new_verified_profile); 2074 2075 // Verify that the web database has been updated and the notification sent. 2076 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2077 .WillOnce(QuitMainMessageLoop()); 2078 base::MessageLoop::current()->Run(); 2079 2080 // Expect that the existing profile is not modified, and instead the new 2081 // profile is added. 2082 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles(); 2083 ASSERT_EQ(1U, results.size()); 2084 EXPECT_EQ(0, new_verified_profile.Compare(*results[0])); 2085} 2086 2087// Ensure that verified profiles can be saved via SaveImportedProfile, 2088// overwriting existing verified profiles as well. 2089TEST_F(PersonalDataManagerTest, SaveImportedProfileWithExistingVerifiedData) { 2090 // Start with a verified profile. 2091 AutofillProfile profile(base::GenerateGUID(), "Chrome settings"); 2092 test::SetProfileInfo(&profile, 2093 "Marion", "Mitchell", "Morrison", 2094 "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA", 2095 "91601", "US", "12345678910"); 2096 EXPECT_TRUE(profile.IsVerified()); 2097 2098 // Add the profile to the database. 2099 personal_data_->AddProfile(profile); 2100 2101 // Verify that the web database has been updated and the notification sent. 2102 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2103 .WillOnce(QuitMainMessageLoop()); 2104 base::MessageLoop::current()->Run(); 2105 2106 AutofillProfile new_verified_profile = profile; 2107 new_verified_profile.set_guid(base::GenerateGUID()); 2108 new_verified_profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Fizzbang, Inc.")); 2109 new_verified_profile.SetRawInfo(NAME_MIDDLE, base::string16()); 2110 EXPECT_TRUE(new_verified_profile.IsVerified()); 2111 2112 personal_data_->SaveImportedProfile(new_verified_profile); 2113 2114 // Verify that the web database has been updated and the notification sent. 2115 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2116 .WillOnce(QuitMainMessageLoop()); 2117 base::MessageLoop::current()->Run(); 2118 2119 // The new profile should be merged into the existing one. 2120 AutofillProfile expected_profile = new_verified_profile; 2121 expected_profile.set_guid(profile.guid()); 2122 std::vector<base::string16> names; 2123 expected_profile.GetRawMultiInfo(NAME_FULL, &names); 2124 names.insert(names.begin(), ASCIIToUTF16("Marion Mitchell Morrison")); 2125 expected_profile.SetRawMultiInfo(NAME_FULL, names); 2126 2127 const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles(); 2128 ASSERT_EQ(1U, results.size()); 2129 EXPECT_EQ(expected_profile, *results[0]); 2130} 2131 2132// Ensure that verified credit cards can be saved via SaveImportedCreditCard. 2133TEST_F(PersonalDataManagerTest, SaveImportedCreditCardWithVerifiedData) { 2134 // Start with a verified credit card. 2135 CreditCard credit_card(base::GenerateGUID(), "Chrome settings"); 2136 test::SetCreditCardInfo(&credit_card, 2137 "Biggie Smalls", "4111 1111 1111 1111" /* Visa */, "01", "2011"); 2138 EXPECT_TRUE(credit_card.IsVerified()); 2139 2140 // Add the credit card to the database. 2141 personal_data_->AddCreditCard(credit_card); 2142 2143 // Verify that the web database has been updated and the notification sent. 2144 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2145 .WillOnce(QuitMainMessageLoop()); 2146 base::MessageLoop::current()->Run(); 2147 2148 CreditCard new_verified_card = credit_card; 2149 new_verified_card.set_guid(base::GenerateGUID()); 2150 new_verified_card.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("B. Small")); 2151 EXPECT_TRUE(new_verified_card.IsVerified()); 2152 2153 personal_data_->SaveImportedCreditCard(new_verified_card); 2154 2155 // Verify that the web database has been updated and the notification sent. 2156 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2157 .WillOnce(QuitMainMessageLoop()); 2158 base::MessageLoop::current()->Run(); 2159 2160 // Expect that the saved credit card is updated. 2161 const std::vector<CreditCard*>& results = personal_data_->GetCreditCards(); 2162 ASSERT_EQ(1U, results.size()); 2163 EXPECT_EQ(ASCIIToUTF16("B. Small"), results[0]->GetRawInfo(CREDIT_CARD_NAME)); 2164} 2165 2166TEST_F(PersonalDataManagerTest, GetNonEmptyTypes) { 2167 // Check that there are no available types with no profiles stored. 2168 ServerFieldTypeSet non_empty_types; 2169 personal_data_->GetNonEmptyTypes(&non_empty_types); 2170 EXPECT_EQ(0U, non_empty_types.size()); 2171 2172 // Test with one profile stored. 2173 AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com"); 2174 test::SetProfileInfo(&profile0, 2175 "Marion", NULL, "Morrison", 2176 "johnwayne@me.xyz", NULL, "123 Zoo St.", NULL, "Hollywood", "CA", 2177 "91601", "US", "14155678910"); 2178 2179 personal_data_->AddProfile(profile0); 2180 2181 // Verify that the web database has been updated and the notification sent. 2182 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2183 .WillOnce(QuitMainMessageLoop()); 2184 base::MessageLoop::current()->Run(); 2185 2186 personal_data_->GetNonEmptyTypes(&non_empty_types); 2187 EXPECT_EQ(15U, non_empty_types.size()); 2188 EXPECT_TRUE(non_empty_types.count(NAME_FIRST)); 2189 EXPECT_TRUE(non_empty_types.count(NAME_LAST)); 2190 EXPECT_TRUE(non_empty_types.count(NAME_FULL)); 2191 EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS)); 2192 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1)); 2193 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STREET_ADDRESS)); 2194 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY)); 2195 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STATE)); 2196 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_ZIP)); 2197 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_COUNTRY)); 2198 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_NUMBER)); 2199 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_COUNTRY_CODE)); 2200 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_CODE)); 2201 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_AND_NUMBER)); 2202 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_WHOLE_NUMBER)); 2203 2204 // Test with multiple profiles stored. 2205 AutofillProfile profile1(base::GenerateGUID(), "https://www.example.com"); 2206 test::SetProfileInfo(&profile1, 2207 "Josephine", "Alicia", "Saenz", 2208 "joewayne@me.xyz", "Fox", "903 Apple Ct.", NULL, "Orlando", "FL", "32801", 2209 "US", "16502937549"); 2210 2211 AutofillProfile profile2(base::GenerateGUID(), "https://www.example.com"); 2212 test::SetProfileInfo(&profile2, 2213 "Josephine", "Alicia", "Saenz", 2214 "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL", 2215 "32801", "US", "16502937549"); 2216 2217 personal_data_->AddProfile(profile1); 2218 personal_data_->AddProfile(profile2); 2219 2220 // Verify that the web database has been updated and the notification sent. 2221 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2222 .WillOnce(QuitMainMessageLoop()); 2223 base::MessageLoop::current()->Run(); 2224 2225 personal_data_->GetNonEmptyTypes(&non_empty_types); 2226 EXPECT_EQ(19U, non_empty_types.size()); 2227 EXPECT_TRUE(non_empty_types.count(NAME_FIRST)); 2228 EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE)); 2229 EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE_INITIAL)); 2230 EXPECT_TRUE(non_empty_types.count(NAME_LAST)); 2231 EXPECT_TRUE(non_empty_types.count(NAME_FULL)); 2232 EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS)); 2233 EXPECT_TRUE(non_empty_types.count(COMPANY_NAME)); 2234 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1)); 2235 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE2)); 2236 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STREET_ADDRESS)); 2237 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY)); 2238 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STATE)); 2239 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_ZIP)); 2240 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_COUNTRY)); 2241 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_NUMBER)); 2242 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_CODE)); 2243 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_COUNTRY_CODE)); 2244 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_AND_NUMBER)); 2245 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_WHOLE_NUMBER)); 2246 2247 // Test with credit card information also stored. 2248 CreditCard credit_card(base::GenerateGUID(), "https://www.example.com"); 2249 test::SetCreditCardInfo(&credit_card, 2250 "John Dillinger", "423456789012" /* Visa */, 2251 "01", "2010"); 2252 personal_data_->AddCreditCard(credit_card); 2253 2254 // Verify that the web database has been updated and the notification sent. 2255 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2256 .WillOnce(QuitMainMessageLoop()); 2257 base::MessageLoop::current()->Run(); 2258 2259 personal_data_->GetNonEmptyTypes(&non_empty_types); 2260 EXPECT_EQ(27U, non_empty_types.size()); 2261 EXPECT_TRUE(non_empty_types.count(NAME_FIRST)); 2262 EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE)); 2263 EXPECT_TRUE(non_empty_types.count(NAME_MIDDLE_INITIAL)); 2264 EXPECT_TRUE(non_empty_types.count(NAME_LAST)); 2265 EXPECT_TRUE(non_empty_types.count(NAME_FULL)); 2266 EXPECT_TRUE(non_empty_types.count(EMAIL_ADDRESS)); 2267 EXPECT_TRUE(non_empty_types.count(COMPANY_NAME)); 2268 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE1)); 2269 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_LINE2)); 2270 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STREET_ADDRESS)); 2271 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_CITY)); 2272 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_STATE)); 2273 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_ZIP)); 2274 EXPECT_TRUE(non_empty_types.count(ADDRESS_HOME_COUNTRY)); 2275 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_NUMBER)); 2276 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_CODE)); 2277 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_COUNTRY_CODE)); 2278 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_CITY_AND_NUMBER)); 2279 EXPECT_TRUE(non_empty_types.count(PHONE_HOME_WHOLE_NUMBER)); 2280 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_NAME)); 2281 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_NUMBER)); 2282 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_TYPE)); 2283 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_MONTH)); 2284 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_2_DIGIT_YEAR)); 2285 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_4_DIGIT_YEAR)); 2286 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_DATE_2_DIGIT_YEAR)); 2287 EXPECT_TRUE(non_empty_types.count(CREDIT_CARD_EXP_DATE_4_DIGIT_YEAR)); 2288} 2289 2290TEST_F(PersonalDataManagerTest, CaseInsensitiveMultiValueAggregation) { 2291 FormData form1; 2292 FormFieldData field; 2293 test::CreateTestFormField( 2294 "First name:", "first_name", "George", "text", &field); 2295 form1.fields.push_back(field); 2296 test::CreateTestFormField( 2297 "Last name:", "last_name", "Washington", "text", &field); 2298 form1.fields.push_back(field); 2299 test::CreateTestFormField( 2300 "Email:", "email", "theprez@gmail.com", "text", &field); 2301 form1.fields.push_back(field); 2302 test::CreateTestFormField( 2303 "Address:", "address1", "21 Laussat St", "text", &field); 2304 form1.fields.push_back(field); 2305 test::CreateTestFormField( 2306 "City:", "city", "San Francisco", "text", &field); 2307 form1.fields.push_back(field); 2308 test::CreateTestFormField("State:", "state", "California", "text", &field); 2309 form1.fields.push_back(field); 2310 test::CreateTestFormField( 2311 "Zip:", "zip", "94102", "text", &field); 2312 form1.fields.push_back(field); 2313 test::CreateTestFormField( 2314 "Phone number:", "phone_number", "817-555-6789", "text", &field); 2315 form1.fields.push_back(field); 2316 2317 FormStructure form_structure1(form1); 2318 form_structure1.DetermineHeuristicTypes(TestAutofillMetrics()); 2319 scoped_ptr<CreditCard> imported_credit_card; 2320 EXPECT_TRUE(personal_data_->ImportFormData(form_structure1, 2321 &imported_credit_card)); 2322 ASSERT_FALSE(imported_credit_card); 2323 2324 // Verify that the web database has been updated and the notification sent. 2325 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2326 .WillOnce(QuitMainMessageLoop()); 2327 base::MessageLoop::current()->Run(); 2328 2329 AutofillProfile expected(base::GenerateGUID(), "https://www.example.com"); 2330 test::SetProfileInfo(&expected, "George", NULL, 2331 "Washington", "theprez@gmail.com", NULL, "21 Laussat St", NULL, 2332 "San Francisco", "California", "94102", NULL, "(817) 555-6789"); 2333 const std::vector<AutofillProfile*>& results1 = personal_data_->GetProfiles(); 2334 ASSERT_EQ(1U, results1.size()); 2335 EXPECT_EQ(0, expected.Compare(*results1[0])); 2336 2337 // Upper-case the first name and change the phone number. 2338 FormData form2; 2339 test::CreateTestFormField( 2340 "First name:", "first_name", "GEORGE", "text", &field); 2341 form2.fields.push_back(field); 2342 test::CreateTestFormField( 2343 "Last name:", "last_name", "Washington", "text", &field); 2344 form2.fields.push_back(field); 2345 test::CreateTestFormField( 2346 "Email:", "email", "theprez@gmail.com", "text", &field); 2347 form2.fields.push_back(field); 2348 test::CreateTestFormField( 2349 "Address:", "address1", "21 Laussat St", "text", &field); 2350 form2.fields.push_back(field); 2351 test::CreateTestFormField("City:", "city", "San Francisco", "text", &field); 2352 form2.fields.push_back(field); 2353 test::CreateTestFormField("State:", "state", "California", "text", &field); 2354 form2.fields.push_back(field); 2355 test::CreateTestFormField("Zip:", "zip", "94102", "text", &field); 2356 form2.fields.push_back(field); 2357 test::CreateTestFormField( 2358 "Phone number:", "phone_number", "214-555-1234", "text", &field); 2359 form2.fields.push_back(field); 2360 2361 FormStructure form_structure2(form2); 2362 form_structure2.DetermineHeuristicTypes(TestAutofillMetrics()); 2363 EXPECT_TRUE(personal_data_->ImportFormData(form_structure2, 2364 &imported_credit_card)); 2365 ASSERT_FALSE(imported_credit_card); 2366 2367 // Verify that the web database has been updated and the notification sent. 2368 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2369 .WillOnce(QuitMainMessageLoop()); 2370 base::MessageLoop::current()->Run(); 2371 2372 const std::vector<AutofillProfile*>& results2 = personal_data_->GetProfiles(); 2373 2374 // Modify expected to include multi-valued fields. 2375 std::vector<base::string16> values; 2376 expected.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values); 2377 values.push_back(ASCIIToUTF16("(214) 555-1234")); 2378 expected.SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, values); 2379 2380 ASSERT_EQ(1U, results2.size()); 2381 EXPECT_EQ(0, expected.Compare(*results2[0])); 2382} 2383 2384TEST_F(PersonalDataManagerTest, IncognitoReadOnly) { 2385 ASSERT_TRUE(personal_data_->GetProfiles().empty()); 2386 ASSERT_TRUE(personal_data_->GetCreditCards().empty()); 2387 2388 AutofillProfile steve_jobs(base::GenerateGUID(), "https://www.example.com"); 2389 test::SetProfileInfo(&steve_jobs, "Steven", "Paul", "Jobs", "sjobs@apple.com", 2390 "Apple Computer, Inc.", "1 Infinite Loop", "", "Cupertino", "CA", "95014", 2391 "US", "(800) 275-2273"); 2392 personal_data_->AddProfile(steve_jobs); 2393 2394 CreditCard bill_gates(base::GenerateGUID(), "https://www.example.com"); 2395 test::SetCreditCardInfo( 2396 &bill_gates, "William H. Gates", "5555555555554444", "1", "2020"); 2397 personal_data_->AddCreditCard(bill_gates); 2398 2399 // The personal data manager should be able to read existing profiles in an 2400 // off-the-record context. 2401 ResetPersonalDataManager(USER_MODE_INCOGNITO); 2402 ASSERT_EQ(1U, personal_data_->GetProfiles().size()); 2403 ASSERT_EQ(1U, personal_data_->GetCreditCards().size()); 2404 2405 // No adds, saves, or updates should take effect. 2406 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()).Times(0); 2407 2408 // Add profiles or credit card shouldn't work. 2409 personal_data_->AddProfile(test::GetFullProfile()); 2410 2411 CreditCard larry_page(base::GenerateGUID(), "https://www.example.com"); 2412 test::SetCreditCardInfo( 2413 &larry_page, "Lawrence Page", "4111111111111111", "10", "2025"); 2414 personal_data_->AddCreditCard(larry_page); 2415 2416 ResetPersonalDataManager(USER_MODE_INCOGNITO); 2417 EXPECT_EQ(1U, personal_data_->GetProfiles().size()); 2418 EXPECT_EQ(1U, personal_data_->GetCreditCards().size()); 2419 2420 // Saving or creating profiles from imported profiles shouldn't work. 2421 steve_jobs.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Steve")); 2422 personal_data_->SaveImportedProfile(steve_jobs); 2423 2424 bill_gates.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Bill Gates")); 2425 personal_data_->SaveImportedCreditCard(bill_gates); 2426 2427 ResetPersonalDataManager(USER_MODE_INCOGNITO); 2428 EXPECT_EQ(ASCIIToUTF16("Steven"), 2429 personal_data_->GetProfiles()[0]->GetRawInfo(NAME_FIRST)); 2430 EXPECT_EQ(ASCIIToUTF16("William H. Gates"), 2431 personal_data_->GetCreditCards()[0]->GetRawInfo(CREDIT_CARD_NAME)); 2432 2433 // Updating existing profiles shouldn't work. 2434 steve_jobs.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Steve")); 2435 personal_data_->UpdateProfile(steve_jobs); 2436 2437 bill_gates.SetRawInfo(CREDIT_CARD_NAME, ASCIIToUTF16("Bill Gates")); 2438 personal_data_->UpdateCreditCard(bill_gates); 2439 2440 ResetPersonalDataManager(USER_MODE_INCOGNITO); 2441 EXPECT_EQ(ASCIIToUTF16("Steven"), 2442 personal_data_->GetProfiles()[0]->GetRawInfo(NAME_FIRST)); 2443 EXPECT_EQ(ASCIIToUTF16("William H. Gates"), 2444 personal_data_->GetCreditCards()[0]->GetRawInfo(CREDIT_CARD_NAME)); 2445 2446 // Removing shouldn't work. 2447 personal_data_->RemoveByGUID(steve_jobs.guid()); 2448 personal_data_->RemoveByGUID(bill_gates.guid()); 2449 2450 ResetPersonalDataManager(USER_MODE_INCOGNITO); 2451 EXPECT_EQ(1U, personal_data_->GetProfiles().size()); 2452 EXPECT_EQ(1U, personal_data_->GetCreditCards().size()); 2453} 2454 2455TEST_F(PersonalDataManagerTest, DefaultCountryCodeIsCached) { 2456 // The return value should always be some country code, no matter what. 2457 std::string default_country = 2458 personal_data_->GetDefaultCountryCodeForNewAddress(); 2459 EXPECT_EQ(2U, default_country.size()); 2460 2461 AutofillProfile moose(base::GenerateGUID(), "Chrome settings"); 2462 test::SetProfileInfo(&moose, "Moose", "P", "McMahon", "mpm@example.com", 2463 "", "1 Taiga TKTR", "", "Calgary", "AB", "T2B 2K2", 2464 "CA", "(800) 555-9000"); 2465 personal_data_->AddProfile(moose); 2466 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()) 2467 .WillOnce(QuitMainMessageLoop()); 2468 base::MessageLoop::current()->Run(); 2469 // The value is cached and doesn't change even after adding an address. 2470 EXPECT_EQ(default_country, 2471 personal_data_->GetDefaultCountryCodeForNewAddress()); 2472 2473 EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged()).Times(2); 2474 2475 // Disabling Autofill blows away this cache and shouldn't account for Autofill 2476 // profiles. 2477 prefs_->SetBoolean(prefs::kAutofillEnabled, false); 2478 EXPECT_EQ(default_country, 2479 personal_data_->GetDefaultCountryCodeForNewAddress()); 2480 2481 // Enabling Autofill blows away the cached value and should reflect the new 2482 // value (accounting for profiles). 2483 prefs_->SetBoolean(prefs::kAutofillEnabled, true); 2484 EXPECT_EQ(base::UTF16ToUTF8(moose.GetRawInfo(ADDRESS_HOME_COUNTRY)), 2485 personal_data_->GetDefaultCountryCodeForNewAddress()); 2486} 2487 2488TEST_F(PersonalDataManagerTest, DefaultCountryCodeComesFromProfiles) { 2489 AutofillProfile moose(base::GenerateGUID(), "Chrome settings"); 2490 test::SetProfileInfo(&moose, "Moose", "P", "McMahon", "mpm@example.com", 2491 "", "1 Taiga TKTR", "", "Calgary", "AB", "T2B 2K2", 2492 "CA", "(800) 555-9000"); 2493 personal_data_->AddProfile(moose); 2494 ResetPersonalDataManager(USER_MODE_NORMAL); 2495 EXPECT_EQ("CA", personal_data_->GetDefaultCountryCodeForNewAddress()); 2496 2497 // Multiple profiles cast votes. 2498 AutofillProfile armadillo(base::GenerateGUID(), "Chrome settings"); 2499 test::SetProfileInfo(&armadillo, "Armin", "Dill", "Oh", "ado@example.com", 2500 "", "1 Speed Bump", "", "Lubbock", "TX", "77500", 2501 "MX", "(800) 555-9000"); 2502 AutofillProfile armadillo2(base::GenerateGUID(), "Chrome settings"); 2503 test::SetProfileInfo(&armadillo2, "Armin", "Dill", "Oh", "ado@example.com", 2504 "", "2 Speed Bump", "", "Lubbock", "TX", "77500", 2505 "MX", "(800) 555-9000"); 2506 personal_data_->AddProfile(armadillo); 2507 personal_data_->AddProfile(armadillo2); 2508 ResetPersonalDataManager(USER_MODE_NORMAL); 2509 EXPECT_EQ("MX", personal_data_->GetDefaultCountryCodeForNewAddress()); 2510 2511 personal_data_->RemoveByGUID(armadillo.guid()); 2512 personal_data_->RemoveByGUID(armadillo2.guid()); 2513 ResetPersonalDataManager(USER_MODE_NORMAL); 2514 // Verified profiles count more. 2515 armadillo.set_origin("http://randomwebsite.com"); 2516 armadillo2.set_origin("http://randomwebsite.com"); 2517 personal_data_->AddProfile(armadillo); 2518 personal_data_->AddProfile(armadillo2); 2519 ResetPersonalDataManager(USER_MODE_NORMAL); 2520 EXPECT_EQ("CA", personal_data_->GetDefaultCountryCodeForNewAddress()); 2521 2522 personal_data_->RemoveByGUID(armadillo.guid()); 2523 ResetPersonalDataManager(USER_MODE_NORMAL); 2524 // But unverified profiles can be a tie breaker. 2525 armadillo.set_origin("Chrome settings"); 2526 personal_data_->AddProfile(armadillo); 2527 ResetPersonalDataManager(USER_MODE_NORMAL); 2528 EXPECT_EQ("MX", personal_data_->GetDefaultCountryCodeForNewAddress()); 2529 2530 // Invalid country codes are ignored. 2531 personal_data_->RemoveByGUID(armadillo.guid()); 2532 personal_data_->RemoveByGUID(moose.guid()); 2533 AutofillProfile space_invader(base::GenerateGUID(), "Chrome settings"); 2534 test::SetProfileInfo(&space_invader, "Marty", "", "Martian", 2535 "mm@example.com", "", "1 Flying Object", "", "Valles Marineris", "", 2536 "", "XX", ""); 2537 personal_data_->AddProfile(moose); 2538 ResetPersonalDataManager(USER_MODE_NORMAL); 2539 EXPECT_EQ("MX", personal_data_->GetDefaultCountryCodeForNewAddress()); 2540} 2541 2542} // namespace autofill 2543