Password Login Database: report correct changes from UpdateLogin().

components/password_manager/core/browser/login_database_unittest.cc

 // Copyright 2014 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/password_manager/core/browser/login_database.h"
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 11 matching lines @@
 using ::testing::Eq;
 
 namespace password_manager {
 namespace {
 PasswordStoreChangeList AddChangeForForm(const PasswordForm& form) {
   return PasswordStoreChangeList(1,
                                  PasswordStoreChange(PasswordStoreChange::ADD,
                                                      form));
 }
 
+PasswordStoreChangeList UpdateChangeForForm(const PasswordForm& form) {
+  return PasswordStoreChangeList(1, PasswordStoreChange(
+      PasswordStoreChange::UPDATE, form));
+}
+
 }  // namespace
 
 // Serialization routines for vectors implemented in login_database.cc.
 Pickle SerializeVector(const std::vector<base::string16>& vec);
 std::vector<base::string16> DeserializeVector(const Pickle& pickle);
 
 class LoginDatabaseTest : public testing::Test {
  protected:
   virtual void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
@@ skipping 165 matching lines @@
   delete result[0];
   result.clear();
 
   // User changes his password.
   PasswordForm form6(form5);
   form6.password_value = ASCIIToUTF16("test6");
   form6.preferred = true;
 
   // We update, and check to make sure it matches the
   // old form, and there is only one record.
-  int rows_changed = 0;
-  EXPECT_TRUE(db_.UpdateLogin(form6, &rows_changed));
-  EXPECT_EQ(1, rows_changed);
+  EXPECT_EQ(UpdateChangeForForm(form6), db_.UpdateLogin(form6));
   // matches
   EXPECT_TRUE(db_.GetLogins(form5, &result));
   EXPECT_EQ(1U, result.size());
   delete result[0];
   result.clear();
   // Only one record.
   EXPECT_TRUE(db_.GetAutofillableLogins(&result));
   EXPECT_EQ(1U, result.size());
   // Password element was updated.
 #if defined(OS_MACOSX) && !defined(OS_IOS)
@@ skipping 511 matching lines @@
   ClearResults(&result);
 
   // Let's say this login form worked. Now update the stored credentials with
   // 'action', 'username_element', 'password_element' and 'submit_element' from
   // the encountered form.
   PasswordForm completed_form(incomplete_form);
   completed_form.action = encountered_form.action;
   completed_form.username_element = encountered_form.username_element;
   completed_form.password_element = encountered_form.password_element;
   completed_form.submit_element = encountered_form.submit_element;
-  EXPECT_TRUE(db_.UpdateLogin(completed_form, NULL));
+  EXPECT_EQ(AddChangeForForm(completed_form), db_.AddLogin(completed_form));
+  EXPECT_TRUE(db_.RemoveLogin(incomplete_form));
 
   // Get matches for encountered_form again.
   EXPECT_TRUE(db_.GetLogins(encountered_form, &result));
   ASSERT_EQ(1U, result.size());
 
   // This time we should have all the info available.
   PasswordForm expected_form(completed_form);
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   expected_form.password_value.clear();
 #endif  // OS_MACOSX && !OS_IOS
@@ skipping 18 matching lines @@
   EXPECT_EQ(AddChangeForForm(incomplete_form), db_.AddLogin(incomplete_form));
 
   // Save a complete version of the previous form. Both forms could exist if
   // the user created the complete version before importing the incomplete
   // version from a different browser.
   PasswordForm complete_form = incomplete_form;
   complete_form.action = GURL("http://accounts.google.com/Login");
   complete_form.username_element = ASCIIToUTF16("username_element");
   complete_form.password_element = ASCIIToUTF16("password_element");
   complete_form.submit_element = ASCIIToUTF16("submit");
+
+  // An update fails because the primary key for |complete_form| is different.
+  EXPECT_EQ(PasswordStoreChangeList(), db_.UpdateLogin(complete_form));
   EXPECT_EQ(AddChangeForForm(complete_form), db_.AddLogin(complete_form));
 
   // Make sure both passwords exist.
   ScopedVector<autofill::PasswordForm> result;
   EXPECT_TRUE(db_.GetAutofillableLogins(&result.get()));
   ASSERT_EQ(2U, result.size());
   result.clear();
 
   // Simulate the user changing their password.
   complete_form.password_value = ASCIIToUTF16("new_password");
-  EXPECT_TRUE(db_.UpdateLogin(complete_form, NULL));
+  EXPECT_EQ(UpdateChangeForForm(complete_form), db_.UpdateLogin(complete_form));
 
-  // Only one updated form should exist now.
+  // Both still exist now.
   EXPECT_TRUE(db_.GetAutofillableLogins(&result.get()));
-  ASSERT_EQ(1U, result.size());
+  ASSERT_EQ(2U, result.size());
 
-  PasswordForm expected_form(complete_form);
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   // On Mac, passwords are not stored in login database, instead they're in
   // the keychain.
-  expected_form.password_value.clear();
+  complete_form.password_value.clear();
+  incomplete_form.password_value.clear();
 #endif  // OS_MACOSX && !OS_IOS
-  EXPECT_EQ(expected_form, *result[0]);
+  if (result[0]->username_element.empty())
+    std::swap(result[0], result[1]);
+  EXPECT_EQ(complete_form, *result[0]);
+  EXPECT_EQ(incomplete_form, *result[1]);
 }
 
 TEST_F(LoginDatabaseTest, DoubleAdd) {
   PasswordForm form;
   form.origin = GURL("http://accounts.google.com/LoginAuth");
   form.signon_realm = "http://accounts.google.com/";
   form.username_value = ASCIIToUTF16("my_username");
   form.password_value = ASCIIToUTF16("my_password");
   form.ssl_valid = false;
   form.preferred = true;
@@ skipping 16 matching lines @@
 // This tests that sql::Connection::set_restrict_to_user() was called,
 // and that function is a noop on non-POSIX platforms in any case.
 TEST_F(LoginDatabaseTest, FilePermissions) {
   int mode = base::FILE_PERMISSION_MASK;
   EXPECT_TRUE(base::GetPosixFilePermissions(file_, &mode));
   EXPECT_EQ((mode & base::FILE_PERMISSION_USER_MASK), mode);
 }
 #endif  // defined(OS_POSIX)
 
 }  // namespace password_manager