chrome/browser/password_manager/password_store_x_unittest.cc

   1 // Copyright (c) 2012 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 "base/basictypes.h"
   6 #include "base/bind.h"
   7 #include "base/bind_helpers.h"
   8 #include "base/file_util.h"
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/run_loop.h"
  12 #include "base/stl_util.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/time/time.h"
  17 #include "chrome/browser/password_manager/password_store_x.h"
  18 #include "chrome/test/base/testing_browser_process.h"
  19 #include "components/password_manager/core/browser/password_form_data.h"
  20 #include "components/password_manager/core/browser/password_store_change.h"
  21 #include "components/password_manager/core/browser/password_store_consumer.h"
  22 #include "components/password_manager/core/common/password_manager_pref_names.h"
  23 #include "content/public/browser/browser_thread.h"
  24 #include "content/public/test/test_browser_thread_bundle.h"
  25 #include "testing/gmock/include/gmock/gmock.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27
  28 using autofill::PasswordForm;
  29 using content::BrowserThread;
  30 using password_manager::ContainsAllPasswordForms;
  31 using password_manager::PasswordStoreChange;
  32 using password_manager::PasswordStoreChangeList;
  33 using testing::_;
  34 using testing::DoAll;
  35 using testing::ElementsAreArray;
  36 using testing::Pointee;
  37 using testing::Property;
  38 using testing::WithArg;
  39
  40 typedef std::vector<PasswordForm*> VectorOfForms;
  41
  42 namespace {
  43
  44 class MockPasswordStoreConsumer
  45     : public password_manager::PasswordStoreConsumer {
  46  public:
  47   MOCK_METHOD1(OnGetPasswordStoreResults,
  48                void(const std::vector<PasswordForm*>&));
  49 };
  50
  51 class MockPasswordStoreObserver
  52     : public password_manager::PasswordStore::Observer {
  53  public:
  54   MOCK_METHOD1(OnLoginsChanged,
  55                void(const password_manager::PasswordStoreChangeList& changes));
  56 };
  57
  58 class FailingBackend : public PasswordStoreX::NativeBackend {
  59  public:
  60   virtual bool Init() OVERRIDE { return true; }
  61
  62   virtual PasswordStoreChangeList AddLogin(const PasswordForm& form) OVERRIDE {
  63     return PasswordStoreChangeList();
  64   }
  65   virtual bool UpdateLogin(const PasswordForm& form,
  66                            PasswordStoreChangeList* changes) OVERRIDE {
  67     return false;
  68   }
  69   virtual bool RemoveLogin(const PasswordForm& form) OVERRIDE { return false; }
  70
  71   virtual bool RemoveLoginsCreatedBetween(
  72       base::Time delete_begin,
  73       base::Time delete_end,
  74       password_manager::PasswordStoreChangeList* changes) OVERRIDE {
  75     return false;
  76   }
  77
  78   virtual bool RemoveLoginsSyncedBetween(
  79       base::Time delete_begin,
  80       base::Time delete_end,
  81       password_manager::PasswordStoreChangeList* changes) OVERRIDE {
  82     return false;
  83   }
  84
  85   virtual bool GetLogins(const PasswordForm& form,
  86                          PasswordFormList* forms) OVERRIDE {
  87     return false;
  88   }
  89
  90   virtual bool GetAutofillableLogins(PasswordFormList* forms) OVERRIDE {
  91     return false;
  92   }
  93   virtual bool GetBlacklistLogins(PasswordFormList* forms) OVERRIDE {
  94     return false;
  95   }
  96 };
  97
  98 class MockBackend : public PasswordStoreX::NativeBackend {
  99  public:
 100   virtual bool Init() OVERRIDE { return true; }
 101
 102   virtual PasswordStoreChangeList AddLogin(const PasswordForm& form) OVERRIDE {
 103     all_forms_.push_back(form);
 104     PasswordStoreChange change(PasswordStoreChange::ADD, form);
 105     return PasswordStoreChangeList(1, change);
 106   }
 107
 108   virtual bool UpdateLogin(const PasswordForm& form,
 109                            PasswordStoreChangeList* changes) OVERRIDE {
 110     for (size_t i = 0; i < all_forms_.size(); ++i)
 111       if (CompareForms(all_forms_[i], form, true)) {
 112         all_forms_[i] = form;
 113         changes->push_back(PasswordStoreChange(PasswordStoreChange::UPDATE,
 114                                                form));
 115       }
 116     return true;
 117   }
 118
 119   virtual bool RemoveLogin(const PasswordForm& form) OVERRIDE {
 120     for (size_t i = 0; i < all_forms_.size(); ++i)
 121       if (CompareForms(all_forms_[i], form, false))
 122         erase(i--);
 123     return true;
 124   }
 125
 126   virtual bool RemoveLoginsCreatedBetween(
 127       base::Time delete_begin,
 128       base::Time delete_end,
 129       password_manager::PasswordStoreChangeList* changes) OVERRIDE {
 130     for (size_t i = 0; i < all_forms_.size(); ++i) {
 131       if (delete_begin <= all_forms_[i].date_created &&
 132           (delete_end.is_null() || all_forms_[i].date_created < delete_end))
 133         erase(i--);
 134     }
 135     return true;
 136   }
 137
 138   virtual bool RemoveLoginsSyncedBetween(
 139       base::Time delete_begin,
 140       base::Time delete_end,
 141       password_manager::PasswordStoreChangeList* changes) OVERRIDE {
 142     DCHECK(changes);
 143     for (size_t i = 0; i < all_forms_.size(); ++i) {
 144       if (delete_begin <= all_forms_[i].date_synced &&
 145           (delete_end.is_null() || all_forms_[i].date_synced < delete_end)) {
 146         changes->push_back(password_manager::PasswordStoreChange(
 147             password_manager::PasswordStoreChange::REMOVE, all_forms_[i]));
 148         erase(i--);
 149       }
 150     }
 151     return true;
 152   }
 153
 154   virtual bool GetLogins(const PasswordForm& form,
 155                          PasswordFormList* forms) OVERRIDE {
 156     for (size_t i = 0; i < all_forms_.size(); ++i)
 157       if (all_forms_[i].signon_realm == form.signon_realm)
 158         forms->push_back(new PasswordForm(all_forms_[i]));
 159     return true;
 160   }
 161
 162   virtual bool GetAutofillableLogins(PasswordFormList* forms) OVERRIDE {
 163     for (size_t i = 0; i < all_forms_.size(); ++i)
 164       if (!all_forms_[i].blacklisted_by_user)
 165         forms->push_back(new PasswordForm(all_forms_[i]));
 166     return true;
 167   }
 168
 169   virtual bool GetBlacklistLogins(PasswordFormList* forms) OVERRIDE {
 170     for (size_t i = 0; i < all_forms_.size(); ++i)
 171       if (all_forms_[i].blacklisted_by_user)
 172         forms->push_back(new PasswordForm(all_forms_[i]));
 173     return true;
 174   }
 175
 176  private:
 177   void erase(size_t index) {
 178     if (index < all_forms_.size() - 1)
 179       all_forms_[index] = all_forms_[all_forms_.size() - 1];
 180     all_forms_.pop_back();
 181   }
 182
 183   bool CompareForms(const PasswordForm& a, const PasswordForm& b, bool update) {
 184     // An update check doesn't care about the submit element.
 185     if (!update && a.submit_element != b.submit_element)
 186       return false;
 187     return a.origin           == b.origin &&
 188            a.password_element == b.password_element &&
 189            a.signon_realm     == b.signon_realm &&
 190            a.username_element == b.username_element &&
 191            a.username_value   == b.username_value;
 192   }
 193
 194   std::vector<PasswordForm> all_forms_;
 195 };
 196
 197 class MockLoginDatabaseReturn {
 198  public:
 199   MOCK_METHOD1(OnLoginDatabaseQueryDone,
 200                void(const std::vector<PasswordForm*>&));
 201 };
 202
 203 void LoginDatabaseQueryCallback(password_manager::LoginDatabase* login_db,
 204                                 bool autofillable,
 205                                 MockLoginDatabaseReturn* mock_return) {
 206   std::vector<PasswordForm*> forms;
 207   if (autofillable)
 208     login_db->GetAutofillableLogins(&forms);
 209   else
 210     login_db->GetBlacklistLogins(&forms);
 211   mock_return->OnLoginDatabaseQueryDone(forms);
 212 }
 213
 214 // Generate |count| expected logins, either auto-fillable or blacklisted.
 215 void InitExpectedForms(bool autofillable, size_t count, VectorOfForms* forms) {
 216   const char* domain = autofillable ? "example" : "blacklisted";
 217   for (size_t i = 0; i < count; ++i) {
 218     std::string realm = base::StringPrintf("http://%zu.%s.com", i, domain);
 219     std::string origin = base::StringPrintf("http://%zu.%s.com/origin",
 220                                             i, domain);
 221     std::string action = base::StringPrintf("http://%zu.%s.com/action",
 222                                             i, domain);
 223     password_manager::PasswordFormData data = {
 224         PasswordForm::SCHEME_HTML,
 225         realm.c_str(),
 226         origin.c_str(),
 227         action.c_str(),
 228         L"submit_element",
 229         L"username_element",
 230         L"password_element",
 231         autofillable ? L"username_value" : NULL,
 232         autofillable ? L"password_value" : NULL,
 233         autofillable,
 234         false,
 235         static_cast<double>(i + 1)};
 236     forms->push_back(CreatePasswordFormFromData(data));
 237   }
 238 }
 239
 240 }  // anonymous namespace
 241
 242 enum BackendType {
 243   NO_BACKEND,
 244   FAILING_BACKEND,
 245   WORKING_BACKEND
 246 };
 247
 248 class PasswordStoreXTest : public testing::TestWithParam<BackendType> {
 249  protected:
 250   virtual void SetUp() {
 251     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 252
 253     login_db_.reset(new password_manager::LoginDatabase());
 254     ASSERT_TRUE(login_db_->Init(temp_dir_.path().Append("login_test")));
 255   }
 256
 257   virtual void TearDown() {
 258     base::RunLoop().RunUntilIdle();
 259   }
 260
 261   PasswordStoreX::NativeBackend* GetBackend() {
 262     switch (GetParam()) {
 263       case FAILING_BACKEND:
 264         return new FailingBackend();
 265       case WORKING_BACKEND:
 266         return new MockBackend();
 267       default:
 268         return NULL;
 269     }
 270   }
 271
 272   content::TestBrowserThreadBundle thread_bundle_;
 273
 274   scoped_ptr<password_manager::LoginDatabase> login_db_;
 275   base::ScopedTempDir temp_dir_;
 276 };
 277
 278 ACTION(STLDeleteElements0) {
 279   STLDeleteContainerPointers(arg0.begin(), arg0.end());
 280 }
 281
 282 TEST_P(PasswordStoreXTest, Notifications) {
 283   scoped_refptr<PasswordStoreX> store(
 284       new PasswordStoreX(base::MessageLoopProxy::current(),
 285                          base::MessageLoopProxy::current(),
 286                          login_db_.release(),
 287                          GetBackend()));
 288   store->Init(syncer::SyncableService::StartSyncFlare(), "");
 289
 290   password_manager::PasswordFormData form_data = {
 291       PasswordForm::SCHEME_HTML,       "http://bar.example.com",
 292       "http://bar.example.com/origin", "http://bar.example.com/action",
 293       L"submit_element",               L"username_element",
 294       L"password_element",             L"username_value",
 295       L"password_value",               true,
 296       false,                           1};
 297   scoped_ptr<PasswordForm> form(CreatePasswordFormFromData(form_data));
 298
 299   MockPasswordStoreObserver observer;
 300   store->AddObserver(&observer);
 301
 302   const PasswordStoreChange expected_add_changes[] = {
 303     PasswordStoreChange(PasswordStoreChange::ADD, *form),
 304   };
 305
 306   EXPECT_CALL(
 307       observer,
 308       OnLoginsChanged(ElementsAreArray(expected_add_changes)));
 309
 310   // Adding a login should trigger a notification.
 311   store->AddLogin(*form);
 312
 313   // The PasswordStore schedules tasks to run on the DB thread. Wait for them
 314   // to complete.
 315   base::RunLoop().RunUntilIdle();
 316
 317   // Change the password.
 318   form->password_value = base::ASCIIToUTF16("a different password");
 319
 320   const PasswordStoreChange expected_update_changes[] = {
 321     PasswordStoreChange(PasswordStoreChange::UPDATE, *form),
 322   };
 323
 324   EXPECT_CALL(
 325       observer,
 326       OnLoginsChanged(ElementsAreArray(expected_update_changes)));
 327
 328   // Updating the login with the new password should trigger a notification.
 329   store->UpdateLogin(*form);
 330
 331   // Wait for PasswordStore to send execute.
 332   base::RunLoop().RunUntilIdle();
 333
 334   const PasswordStoreChange expected_delete_changes[] = {
 335     PasswordStoreChange(PasswordStoreChange::REMOVE, *form),
 336   };
 337
 338   EXPECT_CALL(
 339       observer,
 340       OnLoginsChanged(ElementsAreArray(expected_delete_changes)));
 341
 342   // Deleting the login should trigger a notification.
 343   store->RemoveLogin(*form);
 344
 345   // Wait for PasswordStore to execute.
 346   base::RunLoop().RunUntilIdle();
 347
 348   store->RemoveObserver(&observer);
 349
 350   store->Shutdown();
 351 }
 352
 353 TEST_P(PasswordStoreXTest, NativeMigration) {
 354   VectorOfForms expected_autofillable;
 355   InitExpectedForms(true, 50, &expected_autofillable);
 356
 357   VectorOfForms expected_blacklisted;
 358   InitExpectedForms(false, 50, &expected_blacklisted);
 359
 360   // Get the initial size of the login DB file, before we populate it.
 361   // This will be used later to make sure it gets back to this size.
 362   const base::FilePath login_db_file = temp_dir_.path().Append("login_test");
 363   base::File::Info db_file_start_info;
 364   ASSERT_TRUE(base::GetFileInfo(login_db_file, &db_file_start_info));
 365
 366   password_manager::LoginDatabase* login_db = login_db_.get();
 367
 368   // Populate the login DB with logins that should be migrated.
 369   for (VectorOfForms::iterator it = expected_autofillable.begin();
 370        it != expected_autofillable.end(); ++it) {
 371     login_db->AddLogin(**it);
 372   }
 373   for (VectorOfForms::iterator it = expected_blacklisted.begin();
 374        it != expected_blacklisted.end(); ++it) {
 375     login_db->AddLogin(**it);
 376   }
 377
 378   // Get the new size of the login DB file. We expect it to be larger.
 379   base::File::Info db_file_full_info;
 380   ASSERT_TRUE(base::GetFileInfo(login_db_file, &db_file_full_info));
 381   EXPECT_GT(db_file_full_info.size, db_file_start_info.size);
 382
 383   // Initializing the PasswordStore shouldn't trigger a native migration (yet).
 384   scoped_refptr<PasswordStoreX> store(
 385       new PasswordStoreX(base::MessageLoopProxy::current(),
 386                          base::MessageLoopProxy::current(),
 387                          login_db_.release(),
 388                          GetBackend()));
 389   store->Init(syncer::SyncableService::StartSyncFlare(), "");
 390
 391   MockPasswordStoreConsumer consumer;
 392
 393   // The autofillable forms should have been migrated to the native backend.
 394   EXPECT_CALL(consumer,
 395       OnGetPasswordStoreResults(
 396           ContainsAllPasswordForms(expected_autofillable)))
 397       .WillOnce(WithArg<0>(STLDeleteElements0()));
 398
 399   store->GetAutofillableLogins(&consumer);
 400   base::RunLoop().RunUntilIdle();
 401
 402   // The blacklisted forms should have been migrated to the native backend.
 403   EXPECT_CALL(consumer,
 404       OnGetPasswordStoreResults(ContainsAllPasswordForms(expected_blacklisted)))
 405       .WillOnce(WithArg<0>(STLDeleteElements0()));
 406
 407   store->GetBlacklistLogins(&consumer);
 408   base::RunLoop().RunUntilIdle();
 409
 410   VectorOfForms empty;
 411   MockLoginDatabaseReturn ld_return;
 412
 413   if (GetParam() == WORKING_BACKEND) {
 414     // No autofillable logins should be left in the login DB.
 415     EXPECT_CALL(ld_return,
 416                 OnLoginDatabaseQueryDone(ContainsAllPasswordForms(empty)));
 417   } else {
 418     // The autofillable logins should still be in the login DB.
 419     EXPECT_CALL(ld_return,
 420                 OnLoginDatabaseQueryDone(
 421                     ContainsAllPasswordForms(expected_autofillable)))
 422         .WillOnce(WithArg<0>(STLDeleteElements0()));
 423   }
 424
 425   LoginDatabaseQueryCallback(login_db, true, &ld_return);
 426
 427   // Wait for the login DB methods to execute.
 428   base::RunLoop().RunUntilIdle();
 429
 430   if (GetParam() == WORKING_BACKEND) {
 431     // Likewise, no blacklisted logins should be left in the login DB.
 432     EXPECT_CALL(ld_return,
 433                 OnLoginDatabaseQueryDone(ContainsAllPasswordForms(empty)));
 434   } else {
 435     // The blacklisted logins should still be in the login DB.
 436     EXPECT_CALL(ld_return,
 437                 OnLoginDatabaseQueryDone(
 438                     ContainsAllPasswordForms(expected_blacklisted)))
 439         .WillOnce(WithArg<0>(STLDeleteElements0()));
 440   }
 441
 442   LoginDatabaseQueryCallback(login_db, false, &ld_return);
 443
 444   // Wait for the login DB methods to execute.
 445   base::RunLoop().RunUntilIdle();
 446
 447   if (GetParam() == WORKING_BACKEND) {
 448     // If the migration succeeded, then not only should there be no logins left
 449     // in the login DB, but also the file should have been deleted and then
 450     // recreated. We approximate checking for this by checking that the file
 451     // size is equal to the size before we populated it, even though it was
 452     // larger after populating it.
 453     base::File::Info db_file_end_info;
 454     ASSERT_TRUE(base::GetFileInfo(login_db_file, &db_file_end_info));
 455     EXPECT_EQ(db_file_start_info.size, db_file_end_info.size);
 456   }
 457
 458   STLDeleteElements(&expected_autofillable);
 459   STLDeleteElements(&expected_blacklisted);
 460
 461   store->Shutdown();
 462 }
 463
 464 INSTANTIATE_TEST_CASE_P(NoBackend,
 465                         PasswordStoreXTest,
 466                         testing::Values(NO_BACKEND));
 467 INSTANTIATE_TEST_CASE_P(FailingBackend,
 468                         PasswordStoreXTest,
 469                         testing::Values(FAILING_BACKEND));
 470 INSTANTIATE_TEST_CASE_P(WorkingBackend,
 471                         PasswordStoreXTest,
 472                         testing::Values(WORKING_BACKEND));