Return a list of changed from WebDatabase::RemoveFormElementsAddedBetween()

chrome/browser/webdata/web_database_unittest.cc

 // Copyright (c) 2009 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 "base/file_util.h"
 #include "base/path_service.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/search_engines/template_url.h"
+#include "chrome/browser/webdata/autofill_change.h"
+#include "chrome/browser/webdata/autofill_entry.h"
 #include "chrome/browser/webdata/web_database.h"
 #include "chrome/common/chrome_paths.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/glue/form_field.h"
 #include "webkit/glue/password_form.h"
 
 using base::Time;
 using base::TimeDelta;
 using webkit_glue::FormField;
 using webkit_glue::PasswordForm;
 
+// So we can compare AutofillKeys with EXPECT_EQ().
+std::ostream& operator<<(std::ostream& os, const AutofillKey& key) {
+  return os << UTF16ToASCII(key.name()) << ", " << UTF16ToASCII(key.value());
+}
+
+// So we can compare AutofillChanges with EXPECT_EQ().
+std::ostream& operator<<(std::ostream& os, const AutofillChange& change) {
+  switch (change.type()) {
+    case AutofillChange::ADD: {
+      os << "ADD";
+      break;
+    }
+    case AutofillChange::UPDATE: {
+      os << "UPDATE";
+      break;
+    }
+    case AutofillChange::REMOVE: {
+      os << "REMOVE";
+      break;
+    }
+  }
+  return os << " " << change.key();
+}
+
 class WebDatabaseTest : public testing::Test {
  protected:
 
   virtual void SetUp() {
     PathService::Get(chrome::DIR_TEST_DATA, &file_);
     const std::string test_db = "TestWebDatabase" +
         Int64ToString(base::Time::Now().ToInternalValue()) +
         ".db";
     file_ = file_.AppendASCII(test_db);
     file_util::Delete(file_, false);
@@ skipping 46 matching lines @@
   static void set_prepopulate_id(TemplateURL* url, int id) {
     url->set_prepopulate_id(id);
   }
 
   FilePath file_;
 };
 
 TEST_F(WebDatabaseTest, Keywords) {
   WebDatabase db;
 
-  EXPECT_TRUE(db.Init(file_));
+  ASSERT_TRUE(db.Init(file_));
 
   TemplateURL template_url;
   template_url.set_short_name(L"short_name");
   template_url.set_keyword(L"keyword");
   GURL favicon_url("http://favicon.url/");
   GURL originating_url("http://google.com/");
   template_url.SetFavIconURL(favicon_url);
   template_url.SetURL(L"http://url/", 0, 0);
   template_url.set_safe_for_autoreplace(true);
   template_url.set_show_in_default_list(true);
@@ skipping 40 matching lines @@
   EXPECT_TRUE(db.GetKeywords(&template_urls));
 
   EXPECT_EQ(0U, template_urls.size());
 
   delete restored_url;
 }
 
 TEST_F(WebDatabaseTest, KeywordMisc) {
   WebDatabase db;
 
-  EXPECT_TRUE(db.Init(file_));
+  ASSERT_TRUE(db.Init(file_));
 
   ASSERT_EQ(0, db.GetDefaulSearchProviderID());
   ASSERT_EQ(0, db.GetBuitinKeywordVersion());
 
   db.SetDefaultSearchProviderID(10);
   db.SetBuitinKeywordVersion(11);
 
   ASSERT_EQ(10, db.GetDefaulSearchProviderID());
   ASSERT_EQ(11, db.GetBuitinKeywordVersion());
 }
 
 TEST_F(WebDatabaseTest, UpdateKeyword) {
   WebDatabase db;
 
-  EXPECT_TRUE(db.Init(file_));
+  ASSERT_TRUE(db.Init(file_));
 
   TemplateURL template_url;
   template_url.set_short_name(L"short_name");
   template_url.set_keyword(L"keyword");
   GURL favicon_url("http://favicon.url/");
   GURL originating_url("http://originating.url/");
   template_url.SetFavIconURL(favicon_url);
   template_url.SetURL(L"http://url/", 0, 0);
   template_url.set_safe_for_autoreplace(true);
   template_url.set_show_in_default_list(true);
@@ skipping 41 matching lines @@
   EXPECT_EQ(template_url.id(), restored_url->id());
 
   EXPECT_EQ(template_url.prepopulate_id(), restored_url->prepopulate_id());
 
   delete restored_url;
 }
 
 TEST_F(WebDatabaseTest, KeywordWithNoFavicon) {
   WebDatabase db;
 
-  EXPECT_TRUE(db.Init(file_));
+  ASSERT_TRUE(db.Init(file_));
 
   TemplateURL template_url;
   template_url.set_short_name(L"short_name");
   template_url.set_keyword(L"keyword");
   template_url.SetURL(L"http://url/", 0, 0);
   template_url.set_safe_for_autoreplace(true);
   SetID(-100, &template_url);
 
   EXPECT_TRUE(db.AddKeyword(template_url));
 
   std::vector<TemplateURL*> template_urls;
   EXPECT_TRUE(db.GetKeywords(&template_urls));
   EXPECT_EQ(1U, template_urls.size());
   const TemplateURL* restored_url = template_urls.front();
 
   EXPECT_EQ(template_url.short_name(), restored_url->short_name());
   EXPECT_EQ(template_url.keyword(), restored_url->keyword());
   EXPECT_TRUE(!restored_url->GetFavIconURL().is_valid());
   EXPECT_TRUE(restored_url->safe_for_autoreplace());
   EXPECT_EQ(GetID(&template_url), GetID(restored_url));
   delete restored_url;
 }
 
 TEST_F(WebDatabaseTest, Logins) {
   WebDatabase db;
 
-  EXPECT_TRUE(db.Init(file_));
+  ASSERT_TRUE(db.Init(file_));
 
   std::vector<PasswordForm*> result;
 
   // Verify the database is empty.
   EXPECT_TRUE(db.GetAllLogins(&result, true));
   EXPECT_EQ(0U, result.size());
 
   // Example password form.
   PasswordForm form;
   form.origin = GURL("http://www.google.com/accounts/LoginAuth");
@@ skipping 112 matching lines @@
 
   // Make sure everything can disappear.
   EXPECT_TRUE(db.RemoveLogin(form4));
   EXPECT_TRUE(db.GetAllLogins(&result, true));
   EXPECT_EQ(0U, result.size());
 }
 
 TEST_F(WebDatabaseTest, Autofill) {
   WebDatabase db;
 
-  EXPECT_TRUE(db.Init(file_));
+  ASSERT_TRUE(db.Init(file_));
 
   Time t1 = Time::Now();
 
   // Simulate the submission of a handful of entries in a field called "Name",
   // some more often than others.
   EXPECT_TRUE(db.AddFormFieldValue(
       FormField(string16(),
                 ASCIIToUTF16("Name"),
                 string16(),
                 ASCIIToUTF16("Superman"))));
@@ skipping 79 matching lines @@
   EXPECT_TRUE(db.GetFormValuesForElementName(
       ASCIIToUTF16("Name"), ASCIIToUTF16("cLa"), &v, 6));
   EXPECT_EQ(2U, v.size());
   if (v.size() == 2) {
     EXPECT_EQ(ASCIIToUTF16("Clark Kent"), v[0]);
     EXPECT_EQ(ASCIIToUTF16("Clark Sutter"), v[1]);
   }
 
   // Removing all elements since the beginning of this function should remove
   // everything from the database.
-  EXPECT_TRUE(db.RemoveFormElementsAddedBetween(t1, Time()));
+  std::vector<AutofillChange> changes;
+  EXPECT_TRUE(db.RemoveFormElementsAddedBetween(t1, Time(), &changes));
+
+  const AutofillChange expected_changes[] = {
+    AutofillChange(AutofillChange::REMOVE,
+                   AutofillKey(ASCIIToUTF16("Name"),
+                               ASCIIToUTF16("Superman"))),
+    AutofillChange(AutofillChange::REMOVE,
+                   AutofillKey(ASCIIToUTF16("Name"),
+                               ASCIIToUTF16("Clark Kent"))),
+    AutofillChange(AutofillChange::REMOVE,
+                   AutofillKey(ASCIIToUTF16("Name"),
+                               ASCIIToUTF16("Clark Sutter"))),
+    AutofillChange(AutofillChange::REMOVE,
+                   AutofillKey(ASCIIToUTF16("Favorite Color"),
+                               ASCIIToUTF16("Green"))),
+  };
+  EXPECT_EQ(arraysize(expected_changes), changes.size());
+  for (size_t i = 0; i < arraysize(expected_changes); i++) {
+    EXPECT_EQ(expected_changes[i], changes[i]);
+  }
 
   EXPECT_TRUE(db.GetIDAndCountOfFormElement(
       FormField(string16(),
                 ASCIIToUTF16("Name"),
                 string16(),
                 ASCIIToUTF16("Clark Kent")),
       &pair_id, &count));
   EXPECT_EQ(0, count);
 
   EXPECT_TRUE(
@@ skipping 30 matching lines @@
   db.ClearAutofillEmptyValueElements();
 
   v.clear();
   EXPECT_TRUE(db.GetFormValuesForElementName(ASCIIToUTF16("blank"),
       string16(), &v, 10));
   ASSERT_EQ(1U, v.size());
 
   EXPECT_EQ(kValue, v[0]);
 }
 
+TEST_F(WebDatabaseTest, Autofill_RemoveBetweenChanges) {
+  WebDatabase db;
+  ASSERT_TRUE(db.Init(file_));
+
+  TimeDelta one_day(TimeDelta::FromDays(1));
+  Time t1 = Time::Now();
+  Time t2 = t1 + one_day;
+
+  EXPECT_TRUE(db.AddFormFieldValueTime(
+      FormField(string16(),
+                ASCIIToUTF16("Name"),
+                string16(),
+                ASCIIToUTF16("Superman")),
+      t1));
+  EXPECT_TRUE(db.AddFormFieldValueTime(
+      FormField(string16(),
+                ASCIIToUTF16("Name"),
+                string16(),
+                ASCIIToUTF16("Superman")),
+      t2));
+
+  std::vector<AutofillChange> changes;
+  EXPECT_TRUE(db.RemoveFormElementsAddedBetween(t1, t2, &changes));
+  ASSERT_EQ(1U, changes.size());
+  EXPECT_EQ(AutofillChange(AutofillChange::UPDATE,
+                             AutofillKey(ASCIIToUTF16("Name"),
+                                         ASCIIToUTF16("Superman"))),
+            changes[0]);
+  changes.clear();
+
+  EXPECT_TRUE(db.RemoveFormElementsAddedBetween(t2, t2 + one_day, &changes));
+  ASSERT_EQ(1U, changes.size());
+  EXPECT_EQ(AutofillChange(AutofillChange::REMOVE,
+                             AutofillKey(ASCIIToUTF16("Name"),
+                                         ASCIIToUTF16("Superman"))),
+            changes[0]);
+}
+
 static bool AddTimestampedLogin(WebDatabase* db, std::string url,
                                 const std::string& unique_string,
                                 const Time& time) {
   // Example password form.
   PasswordForm form;
   form.origin = GURL(url + std::string("/LoginAuth"));
   form.username_element = ASCIIToUTF16(unique_string);
   form.username_value = ASCIIToUTF16(unique_string);
   form.password_element = ASCIIToUTF16(unique_string);
   form.submit_element = ASCIIToUTF16("signIn");
   form.signon_realm = url;
   form.date_created = time;
   return db->AddLogin(form);
 }
 
 static void ClearResults(std::vector<PasswordForm*>* results) {
   for (size_t i = 0; i < results->size(); ++i) {
     delete (*results)[i];
   }
   results->clear();
 }
 
 TEST_F(WebDatabaseTest, ClearPrivateData_SavedPasswords) {
   WebDatabase db;
 
-  EXPECT_TRUE(db.Init(file_));
+  ASSERT_TRUE(db.Init(file_));
 
   std::vector<PasswordForm*> result;
 
   // Verify the database is empty.
   EXPECT_TRUE(db.GetAllLogins(&result, true));
   EXPECT_EQ(0U, result.size());
 
   Time now = Time::Now();
   TimeDelta one_day = TimeDelta::FromDays(1);
 
@@ skipping 21 matching lines @@
   db.RemoveLoginsCreatedBetween(Time(), Time());
 
   // Verify nothing is left.
   EXPECT_TRUE(db.GetAllLogins(&result, true));
   EXPECT_EQ(0U, result.size());
 }
 
 TEST_F(WebDatabaseTest, BlacklistedLogins) {
   WebDatabase db;
 
-  EXPECT_TRUE(db.Init(file_));
+  ASSERT_TRUE(db.Init(file_));
   std::vector<PasswordForm*> result;
 
   // Verify the database is empty.
   EXPECT_TRUE(db.GetAllLogins(&result, true));
   ASSERT_EQ(0U, result.size());
 
   // Save a form as blacklisted.
   PasswordForm form;
   form.origin = GURL("http://www.google.com/accounts/LoginAuth");
   form.action = GURL("http://www.google.com/accounts/Login");
@@ skipping 18 matching lines @@
 
   // So should GetAll including blacklisted.
   EXPECT_TRUE(db.GetAllLogins(&result, true));
   EXPECT_EQ(1U, result.size());
   ClearResults(&result);
 }
 
 TEST_F(WebDatabaseTest, WebAppHasAllImages) {
   WebDatabase db;
 
-  EXPECT_TRUE(db.Init(file_));
+  ASSERT_TRUE(db.Init(file_));
   GURL url("http://google.com/");
 
   // Initial value for unknown web app should be false.
   EXPECT_FALSE(db.GetWebAppHasAllImages(url));
 
   // Set the value and make sure it took.
   EXPECT_TRUE(db.SetWebAppHasAllImages(url, true));
   EXPECT_TRUE(db.GetWebAppHasAllImages(url));
 
   // Remove the app and make sure value reverts to default.
@@ skipping 67 matching lines @@
     ASSERT_EQ(16, images[0].height());
     ASSERT_EQ(32, images[1].width());
     ASSERT_EQ(32, images[1].height());
   } else {
     ASSERT_EQ(32, images[0].width());
     ASSERT_EQ(32, images[0].height());
     ASSERT_EQ(16, images[1].width());
     ASSERT_EQ(16, images[1].height());
   }
 }