[Autofill] Set basic information when adding a new profiles and credit cards.

components/autofill/core/browser/personal_data_manager_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/autofill/core/browser/personal_data_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 341 matching lines @@
   // Reload the database.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   // Verify the addition.
   std::vector<AutofillProfile*> profiles;
   profiles.push_back(&profile0);
   profiles.push_back(&profile1);
   ExpectSameElements(profiles, personal_data_->GetProfiles());
 }
 
+// Test that a new profile has its basic information set.
+TEST_F(PersonalDataManagerTest, AddProfile_BasicInformation) {
+  // Add a profile to the database.
+  AutofillProfile profile(test::GetFullProfile());
+  profile.SetRawInfo(EMAIL_ADDRESS, ASCIIToUTF16("j@s.com"));
+  personal_data_->AddProfile(profile);
+
+  // Reload the database.
+  ResetPersonalDataManager(USER_MODE_NORMAL);
+
+  // Verify the addition.
+  const std::vector<AutofillProfile*>& results = personal_data_->GetProfiles();
+  ASSERT_EQ(1U, results.size());
+  EXPECT_EQ(0, profile.Compare(*results[0]));
+
+  // Make sure the use count and use date were set.
+  EXPECT_EQ(1U, results[0]->use_count());
+  EXPECT_NE(base::Time(), results[0]->use_date());
+  EXPECT_NE(base::Time(), results[0]->modification_date());
+}
+
 TEST_F(PersonalDataManagerTest, DontDuplicateServerProfile) {
   EnableWalletCardImport();
 
   std::vector<AutofillProfile> server_profiles;
   server_profiles.push_back(
       AutofillProfile(AutofillProfile::SERVER_PROFILE, "a123"));
   test::SetProfileInfo(&server_profiles.back(), "John", "", "Doe", "",
                        "ACME Corp", "500 Oak View", "Apt 8", "Houston", "TX",
                        "77401", "US", "");
   // Wallet only provides a full name, so the above first and last names
@@ skipping 27 matching lines @@
 
   // Verify that the server profile's use date was updated.
   const AutofillProfile* server_profile = personal_data_->GetProfiles()[0];
   EXPECT_GT(base::TimeDelta::FromMilliseconds(500),
             base::Time::Now() - server_profile->use_date());
 }
 
 // Tests that SaveImportedProfile sets the modification date on new profiles.
 TEST_F(PersonalDataManagerTest, SaveImportedProfileSetModificationDate) {
   AutofillProfile profile(test::GetFullProfile());
-  EXPECT_EQ(base::Time(), profile.modification_date());
+  EXPECT_NE(base::Time(), profile.modification_date());
 
   personal_data_->SaveImportedProfile(profile);
   const std::vector<AutofillProfile*>& profiles = personal_data_->GetProfiles();
   ASSERT_EQ(1U, profiles.size());
   EXPECT_GT(base::TimeDelta::FromMilliseconds(500),
             base::Time::Now() - profiles[0]->modification_date());
 }
 
 TEST_F(PersonalDataManagerTest, AddUpdateRemoveProfiles) {
   AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com");
@@ skipping 101 matching lines @@
   // database.
   ResetPersonalDataManager(USER_MODE_NORMAL);
 
   // Verify that we've loaded the credit cards from the web database.
   cards.clear();
   cards.push_back(&credit_card0);
   cards.push_back(&credit_card2);
   ExpectSameElements(cards, personal_data_->GetCreditCards());
 }
 
+// Test that a new credit card has its basic information set.
+TEST_F(PersonalDataManagerTest, AddCreditCard_BasicInformation) {
+  // Add a credit to the database.
+  CreditCard credit_card(base::GenerateGUID(), "https://www.example.com");
+  test::SetCreditCardInfo(&credit_card, "John Dillinger",
+                          "423456789012" /* Visa */, "01", "2999");
+  personal_data_->AddCreditCard(credit_card);
+
+  // Reload the database.
+  ResetPersonalDataManager(USER_MODE_NORMAL);
+
+  // Verify the addition.
+  const std::vector<CreditCard*>& results = personal_data_->GetCreditCards();
+  ASSERT_EQ(1U, results.size());
+  EXPECT_EQ(0, credit_card.Compare(*results[0]));
+
+  // Make sure the use count and use date were set.
+  EXPECT_EQ(1U, results[0]->use_count());
+  EXPECT_NE(base::Time(), results[0]->use_date());
+  EXPECT_NE(base::Time(), results[0]->modification_date());
+}
+
 TEST_F(PersonalDataManagerTest, UpdateUnverifiedProfilesAndCreditCards) {
   // Start with unverified data.
   AutofillProfile profile(base::GenerateGUID(), "https://www.example.com/");
   test::SetProfileInfo(&profile,
       "Marion", "Mitchell", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910");
   EXPECT_FALSE(profile.IsVerified());
 
   CreditCard credit_card(base::GenerateGUID(), "https://www.example.com/");
@@ skipping 3118 matching lines @@
                           "347666888555" /* American Express */, "04", "3999");
   credit_card5.set_use_count(1);
   credit_card5.set_use_date(base::Time::Now() - base::TimeDelta::FromDays(15));
   credit_cards.push_back(&credit_card5);
 
   PersonalDataManager::DedupeCreditCardToSuggest(&credit_cards);
   EXPECT_EQ(3U, credit_cards.size());
 }
 
 TEST_F(PersonalDataManagerTest, RecordUseOf) {
+  base::Time creation_time = base::Time::FromTimeT(12345);
+
   AutofillProfile profile(test::GetFullProfile());
-  EXPECT_EQ(0U, profile.use_count());
-  EXPECT_EQ(base::Time(), profile.use_date());
-  EXPECT_EQ(base::Time(), profile.modification_date());
+  profile.set_use_date(creation_time);
+  profile.set_modification_date(creation_time);
+  EXPECT_EQ(1U, profile.use_count());
+  EXPECT_EQ(creation_time, profile.use_date());
+  EXPECT_EQ(creation_time, profile.modification_date());
   personal_data_->AddProfile(profile);
 
   CreditCard credit_card(base::GenerateGUID(), "https://www.example.com");
   test::SetCreditCardInfo(&credit_card, "John Dillinger",
                           "423456789012" /* Visa */, "01", "2999");
-  EXPECT_EQ(0U, credit_card.use_count());
-  EXPECT_EQ(base::Time(), credit_card.use_date());
-  EXPECT_EQ(base::Time(), credit_card.modification_date());
+  credit_card.set_use_date(creation_time);
+  credit_card.set_modification_date(creation_time);
+  EXPECT_EQ(1U, credit_card.use_count());
+  EXPECT_EQ(creation_time, credit_card.use_date());
+  EXPECT_EQ(creation_time, credit_card.modification_date());
   personal_data_->AddCreditCard(credit_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::MessageLoop::current()->Run();
 
   // Notify the PDM that the profile and credit card were used.
   AutofillProfile* added_profile =
       personal_data_->GetProfileByGUID(profile.guid());
   ASSERT_TRUE(added_profile);
   EXPECT_EQ(*added_profile, profile);
-  EXPECT_EQ(0U, added_profile->use_count());
-  EXPECT_EQ(base::Time(), added_profile->use_date());
-  EXPECT_NE(base::Time(), added_profile->modification_date());
+  EXPECT_EQ(1U, added_profile->use_count());
+  EXPECT_EQ(creation_time, added_profile->use_date());
+  EXPECT_NE(creation_time, added_profile->modification_date());
   personal_data_->RecordUseOf(profile);
 
   CreditCard* added_card =
       personal_data_->GetCreditCardByGUID(credit_card.guid());
   ASSERT_TRUE(added_card);
   EXPECT_EQ(*added_card, credit_card);
-  EXPECT_EQ(0U, added_card->use_count());
-  EXPECT_EQ(base::Time(), added_card->use_date());
-  EXPECT_NE(base::Time(), added_card->modification_date());
+  EXPECT_EQ(1U, added_card->use_count());
+  EXPECT_EQ(creation_time, added_card->use_date());
+  EXPECT_NE(creation_time, added_card->modification_date());
   personal_data_->RecordUseOf(credit_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::MessageLoop::current()->Run();
 
   // Verify usage stats are updated.
   added_profile = personal_data_->GetProfileByGUID(profile.guid());
   ASSERT_TRUE(added_profile);
-  EXPECT_EQ(1U, added_profile->use_count());
-  EXPECT_NE(base::Time(), added_profile->use_date());
-  EXPECT_NE(base::Time(), added_profile->modification_date());
+  EXPECT_EQ(2U, added_profile->use_count());
+  EXPECT_NE(creation_time, added_profile->use_date());
+  EXPECT_NE(creation_time, added_profile->modification_date());
 
   added_card = personal_data_->GetCreditCardByGUID(credit_card.guid());
   ASSERT_TRUE(added_card);
-  EXPECT_EQ(1U, added_card->use_count());
-  EXPECT_NE(base::Time(), added_card->use_date());
-  EXPECT_NE(base::Time(), added_card->modification_date());
+  EXPECT_EQ(2U, added_card->use_count());
+  EXPECT_NE(creation_time, added_card->use_date());
+  EXPECT_NE(creation_time, added_card->modification_date());
 }
 
 TEST_F(PersonalDataManagerTest, UpdateServerCreditCardUsageStats) {
   EnableWalletCardImport();
 
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "a123"));
   test::SetCreditCardInfo(&server_cards.back(), "John Dillinger",
                           "9012" /* Visa */, "01", "2999");
   server_cards.back().SetTypeForMaskedCard(kVisaCard);
@@ skipping 37 matching lines @@
   personal_data_->UpdateServerCreditCard(*unmasked_card);
 
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::MessageLoop::current()->Run();
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
 
   for (size_t i = 0; i < 3; ++i)
     EXPECT_EQ(0, server_cards[i].Compare(*personal_data_->GetCreditCards()[i]));
 
-  // For an unmasked card, usage data starts out as 1 and Now().
-  EXPECT_EQ(1U, personal_data_->GetCreditCards()[0]->use_count());
+  // For an unmasked card, usage data starts out as 2 because of the unmasking
+  // which is considered a use.
+  EXPECT_EQ(2U, personal_data_->GetCreditCards()[0]->use_count());
   EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[0]->use_date());
 
-  EXPECT_EQ(0U, personal_data_->GetCreditCards()[1]->use_count());
-  EXPECT_EQ(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
+  EXPECT_EQ(1U, personal_data_->GetCreditCards()[1]->use_count());
+  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
 
-  // Having unmasked this card, usage stats should be 1 and Now().
-  EXPECT_EQ(1U, personal_data_->GetCreditCards()[2]->use_count());
+  // Having unmasked this card, usage stats should be 2 and Now().
+  EXPECT_EQ(2U, personal_data_->GetCreditCards()[2]->use_count());
   EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[2]->use_date());
   base::Time initial_use_date = personal_data_->GetCreditCards()[2]->use_date();
 
   server_cards.back().set_guid(personal_data_->GetCreditCards()[2]->guid());
   personal_data_->RecordUseOf(server_cards.back());
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::MessageLoop::current()->Run();
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
 
-  EXPECT_EQ(1U, personal_data_->GetCreditCards()[0]->use_count());
+  EXPECT_EQ(2U, personal_data_->GetCreditCards()[0]->use_count());
   EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[0]->use_date());
 
-  EXPECT_EQ(0U, personal_data_->GetCreditCards()[1]->use_count());
-  EXPECT_EQ(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
+  EXPECT_EQ(1U, personal_data_->GetCreditCards()[1]->use_count());
+  EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
 
-  EXPECT_EQ(2U, personal_data_->GetCreditCards()[2]->use_count());
+  EXPECT_EQ(3U, personal_data_->GetCreditCards()[2]->use_count());
   EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[2]->use_date());
   // Time may or may not have elapsed between unmasking and RecordUseOf.
   EXPECT_LE(initial_use_date, personal_data_->GetCreditCards()[2]->use_date());
 
   // Can record usage stats on masked cards.
   server_cards[1].set_guid(personal_data_->GetCreditCards()[1]->guid());
   personal_data_->RecordUseOf(server_cards[1]);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::MessageLoop::current()->Run();
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
-  EXPECT_EQ(1U, personal_data_->GetCreditCards()[1]->use_count());
+  EXPECT_EQ(2U, personal_data_->GetCreditCards()[1]->use_count());
   EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
 
   // Upgrading to unmasked retains the usage stats (and increments them).
   CreditCard* unmasked_card2 = &server_cards[1];
   unmasked_card2->set_record_type(CreditCard::FULL_SERVER_CARD);
   unmasked_card2->SetNumber(ASCIIToUTF16("5555555555554444"));
   personal_data_->UpdateServerCreditCard(*unmasked_card2);
 
   server_cards[1].set_guid(personal_data_->GetCreditCards()[1]->guid());
   personal_data_->RecordUseOf(server_cards[1]);
   EXPECT_CALL(personal_data_observer_, OnPersonalDataChanged())
       .WillOnce(QuitMainMessageLoop());
   base::MessageLoop::current()->Run();
   ASSERT_EQ(3U, personal_data_->GetCreditCards().size());
-  EXPECT_EQ(2U, personal_data_->GetCreditCards()[1]->use_count());
+  EXPECT_EQ(3U, personal_data_->GetCreditCards()[1]->use_count());
   EXPECT_NE(base::Time(), personal_data_->GetCreditCards()[1]->use_date());
 }
 
 TEST_F(PersonalDataManagerTest, ClearAllServerData) {
   // Add a server card.
   std::vector<CreditCard> server_cards;
   server_cards.push_back(CreditCard(CreditCard::MASKED_SERVER_CARD, "a123"));
   test::SetCreditCardInfo(&server_cards.back(), "John Dillinger",
                           "9012" /* Visa */, "01", "2999");
   server_cards.back().SetTypeForMaskedCard(kVisaCard);
@@ skipping 262 matching lines @@
       EXPECT_GT(base::TimeDelta::FromMilliseconds(500),
                 base::Time::Now() - saved_profiles.front()->use_date());
     }
 
     // Erase the profiles for the next test.
     ResetProfiles();
   }
 }
 
 }  // namespace autofill