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/files/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)); 473