| // Copyright (c) 2012 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 <vector> |
| |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| #include "base/bind.h" |
| #include "base/location.h" |
| #include "base/prefs/pref_service.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "base/test/test_timeouts.h" |
| #include "base/time/time.h" |
| #include "chrome/browser/chrome_notification_types.h" |
| #include "chrome/browser/invalidation/invalidation_service_factory.h" |
| #include "chrome/browser/password_manager/mock_password_store.h" |
| #include "chrome/browser/password_manager/password_store.h" |
| #include "chrome/browser/password_manager/password_store_factory.h" |
| #include "chrome/browser/signin/signin_manager.h" |
| #include "chrome/browser/signin/signin_manager_factory.h" |
| #include "chrome/browser/signin/token_service_factory.h" |
| #include "chrome/browser/sync/abstract_profile_sync_service_test.h" |
| #include "chrome/browser/sync/glue/password_change_processor.h" |
| #include "chrome/browser/sync/glue/password_data_type_controller.h" |
| #include "chrome/browser/sync/glue/password_model_associator.h" |
| #include "chrome/browser/sync/profile_sync_components_factory.h" |
| #include "chrome/browser/sync/profile_sync_components_factory_mock.h" |
| #include "chrome/browser/sync/profile_sync_service.h" |
| #include "chrome/browser/sync/profile_sync_service_factory.h" |
| #include "chrome/browser/sync/profile_sync_test_util.h" |
| #include "chrome/browser/sync/test_profile_sync_service.h" |
| #include "chrome/common/pref_names.h" |
| #include "content/public/browser/notification_source.h" |
| #include "content/public/common/password_form.h" |
| #include "content/public/test/mock_notification_observer.h" |
| #include "content/public/test/test_browser_thread.h" |
| #include "google_apis/gaia/gaia_constants.h" |
| #include "sync/internal_api/public/read_node.h" |
| #include "sync/internal_api/public/read_transaction.h" |
| #include "sync/internal_api/public/write_node.h" |
| #include "sync/internal_api/public/write_transaction.h" |
| #include "sync/protocol/password_specifics.pb.h" |
| #include "sync/test/engine/test_id_factory.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| |
| using base::Time; |
| using browser_sync::PasswordChangeProcessor; |
| using browser_sync::PasswordDataTypeController; |
| using browser_sync::PasswordModelAssociator; |
| using content::BrowserThread; |
| using content::PasswordForm; |
| using syncer::syncable::WriteTransaction; |
| using testing::_; |
| using testing::AtLeast; |
| using testing::DoAll; |
| using testing::InvokeWithoutArgs; |
| using testing::Return; |
| using testing::SetArgumentPointee; |
| |
| ACTION_P3(MakePasswordSyncComponents, service, ps, dtc) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB)); |
| PasswordModelAssociator* model_associator = |
| new PasswordModelAssociator(service, ps, NULL); |
| PasswordChangeProcessor* change_processor = |
| new PasswordChangeProcessor(model_associator, ps, dtc); |
| return ProfileSyncComponentsFactory::SyncComponents(model_associator, |
| change_processor); |
| } |
| |
| ACTION_P(AcquireSyncTransaction, password_test_service) { |
| // Check to make sure we can aquire a transaction (will crash if a transaction |
| // is already held by this thread, deadlock if held by another thread). |
| syncer::WriteTransaction trans( |
| FROM_HERE, password_test_service->GetUserShare()); |
| DVLOG(1) << "Sync transaction acquired."; |
| } |
| |
| class NullPasswordStore : public MockPasswordStore { |
| public: |
| NullPasswordStore() {} |
| |
| static scoped_refptr<RefcountedBrowserContextKeyedService> Build( |
| content::BrowserContext* profile) { |
| return scoped_refptr<RefcountedBrowserContextKeyedService>(); |
| } |
| |
| protected: |
| virtual ~NullPasswordStore() {} |
| }; |
| |
| class PasswordTestProfileSyncService : public TestProfileSyncService { |
| public: |
| PasswordTestProfileSyncService( |
| ProfileSyncComponentsFactory* factory, |
| Profile* profile, |
| SigninManagerBase* signin) |
| : TestProfileSyncService(factory, |
| profile, |
| signin, |
| ProfileSyncService::AUTO_START, |
| false) {} |
| |
| virtual ~PasswordTestProfileSyncService() {} |
| |
| virtual void OnPassphraseAccepted() OVERRIDE { |
| if (!callback_.is_null()) |
| callback_.Run(); |
| |
| TestProfileSyncService::OnPassphraseAccepted(); |
| } |
| |
| static BrowserContextKeyedService* Build(content::BrowserContext* context) { |
| Profile* profile = static_cast<Profile*>(context); |
| SigninManagerBase* signin = |
| SigninManagerFactory::GetForProfile(profile); |
| ProfileSyncComponentsFactoryMock* factory = |
| new ProfileSyncComponentsFactoryMock(); |
| return new PasswordTestProfileSyncService(factory, profile, signin); |
| } |
| |
| void set_passphrase_accept_callback(const base::Closure& callback) { |
| callback_ = callback; |
| } |
| |
| private: |
| base::Closure callback_; |
| }; |
| |
| class ProfileSyncServicePasswordTest : public AbstractProfileSyncServiceTest { |
| public: |
| syncer::UserShare* GetUserShare() { |
| return sync_service_->GetUserShare(); |
| } |
| |
| void AddPasswordSyncNode(const PasswordForm& entry) { |
| syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare()); |
| syncer::ReadNode password_root(&trans); |
| ASSERT_EQ(syncer::BaseNode::INIT_OK, |
| password_root.InitByTagLookup(browser_sync::kPasswordTag)); |
| |
| syncer::WriteNode node(&trans); |
| std::string tag = PasswordModelAssociator::MakeTag(entry); |
| syncer::WriteNode::InitUniqueByCreationResult result = |
| node.InitUniqueByCreation(syncer::PASSWORDS, password_root, tag); |
| ASSERT_EQ(syncer::WriteNode::INIT_SUCCESS, result); |
| PasswordModelAssociator::WriteToSyncNode(entry, &node); |
| } |
| |
| protected: |
| ProfileSyncServicePasswordTest() {} |
| |
| virtual void SetUp() { |
| AbstractProfileSyncServiceTest::SetUp(); |
| TestingProfile::Builder builder; |
| builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(), |
| FakeOAuth2TokenService::BuildTokenService); |
| profile_ = builder.Build().Pass(); |
| invalidation::InvalidationServiceFactory::GetInstance()-> |
| SetBuildOnlyFakeInvalidatorsForTest(true); |
| password_store_ = static_cast<MockPasswordStore*>( |
| PasswordStoreFactory::GetInstance()->SetTestingFactoryAndUse( |
| profile_.get(), MockPasswordStore::Build).get()); |
| } |
| |
| virtual void TearDown() { |
| if (password_store_.get()) |
| password_store_->ShutdownOnUIThread(); |
| ProfileSyncServiceFactory::GetInstance()->SetTestingFactory( |
| profile_.get(), NULL); |
| profile_.reset(); |
| AbstractProfileSyncServiceTest::TearDown(); |
| } |
| |
| static void SignalEvent(base::WaitableEvent* done) { |
| done->Signal(); |
| } |
| |
| void FlushLastDBTask() { |
| base::WaitableEvent done(false, false); |
| BrowserThread::PostTask( |
| BrowserThread::DB, FROM_HERE, |
| base::Bind(&ProfileSyncServicePasswordTest::SignalEvent, &done)); |
| done.TimedWait(TestTimeouts::action_timeout()); |
| } |
| |
| void StartSyncService(const base::Closure& root_callback, |
| const base::Closure& node_callback) { |
| if (!sync_service_) { |
| SigninManagerBase* signin = |
| SigninManagerFactory::GetForProfile(profile_.get()); |
| signin->SetAuthenticatedUsername("test_user@gmail.com"); |
| token_service_ = static_cast<TokenService*>( |
| TokenServiceFactory::GetInstance()->SetTestingFactoryAndUse( |
| profile_.get(), BuildTokenService)); |
| |
| PasswordTestProfileSyncService* sync = |
| static_cast<PasswordTestProfileSyncService*>( |
| ProfileSyncServiceFactory::GetInstance()-> |
| SetTestingFactoryAndUse(profile_.get(), |
| &PasswordTestProfileSyncService::Build)); |
| sync->set_backend_init_callback(root_callback); |
| sync->set_passphrase_accept_callback(node_callback); |
| sync_service_ = sync; |
| |
| syncer::ModelTypeSet preferred_types = |
| sync_service_->GetPreferredDataTypes(); |
| preferred_types.Put(syncer::PASSWORDS); |
| sync_service_->ChangePreferredDataTypes(preferred_types); |
| PasswordDataTypeController* data_type_controller = |
| new PasswordDataTypeController(sync_service_->factory(), |
| profile_.get(), |
| sync_service_); |
| ProfileSyncComponentsFactoryMock* components = |
| sync_service_->components_factory_mock(); |
| if (password_store_.get()) { |
| EXPECT_CALL(*components, CreatePasswordSyncComponents(_, _, _)) |
| .Times(AtLeast(1)). // Can be more if we hit NEEDS_CRYPTO. |
| WillRepeatedly(MakePasswordSyncComponents( |
| sync_service_, password_store_.get(), data_type_controller)); |
| } else { |
| // When the password store is unavailable, password sync components must |
| // not be created. |
| EXPECT_CALL(*components, CreatePasswordSyncComponents(_, _, _)) |
| .Times(0); |
| } |
| EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _, _)). |
| WillOnce(ReturnNewDataTypeManager()); |
| |
| // We need tokens to get the tests going |
| token_service_->IssueAuthTokenForTest( |
| GaiaConstants::kGaiaOAuth2LoginRefreshToken, "oauth2_login_token"); |
| token_service_->IssueAuthTokenForTest( |
| GaiaConstants::kSyncService, "token"); |
| |
| sync_service_->RegisterDataTypeController(data_type_controller); |
| sync_service_->Initialize(); |
| base::MessageLoop::current()->Run(); |
| FlushLastDBTask(); |
| |
| sync_service_->SetEncryptionPassphrase("foo", |
| ProfileSyncService::IMPLICIT); |
| base::MessageLoop::current()->Run(); |
| } |
| } |
| |
| // Helper to sort the results of GetPasswordEntriesFromSyncDB. The sorting |
| // doesn't need to be particularly intelligent, it just needs to be consistent |
| // enough that we can base our tests expectations on the ordering it provides. |
| static bool PasswordFormComparator(const PasswordForm& pf1, |
| const PasswordForm& pf2) { |
| if (pf1.submit_element < pf2.submit_element) |
| return true; |
| if (pf1.username_element < pf2.username_element) |
| return true; |
| if (pf1.username_value < pf2.username_value) |
| return true; |
| if (pf1.password_element < pf2.password_element) |
| return true; |
| if (pf1.password_value < pf2.password_value) |
| return true; |
| |
| return false; |
| } |
| |
| void GetPasswordEntriesFromSyncDB(std::vector<PasswordForm>* entries) { |
| syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare()); |
| syncer::ReadNode password_root(&trans); |
| ASSERT_EQ(syncer::BaseNode::INIT_OK, |
| password_root.InitByTagLookup(browser_sync::kPasswordTag)); |
| |
| int64 child_id = password_root.GetFirstChildId(); |
| while (child_id != syncer::kInvalidId) { |
| syncer::ReadNode child_node(&trans); |
| ASSERT_EQ(syncer::BaseNode::INIT_OK, |
| child_node.InitByIdLookup(child_id)); |
| |
| const sync_pb::PasswordSpecificsData& password = |
| child_node.GetPasswordSpecifics(); |
| |
| PasswordForm form; |
| PasswordModelAssociator::CopyPassword(password, &form); |
| |
| entries->push_back(form); |
| |
| child_id = child_node.GetSuccessorId(); |
| } |
| |
| std::sort(entries->begin(), entries->end(), PasswordFormComparator); |
| } |
| |
| bool ComparePasswords(const PasswordForm& lhs, const PasswordForm& rhs) { |
| return lhs.scheme == rhs.scheme && |
| lhs.signon_realm == rhs.signon_realm && |
| lhs.origin == rhs.origin && |
| lhs.action == rhs.action && |
| lhs.username_element == rhs.username_element && |
| lhs.username_value == rhs.username_value && |
| lhs.password_element == rhs.password_element && |
| lhs.password_value == rhs.password_value && |
| lhs.ssl_valid == rhs.ssl_valid && |
| lhs.preferred == rhs.preferred && |
| lhs.date_created == rhs.date_created && |
| lhs.blacklisted_by_user == rhs.blacklisted_by_user; |
| } |
| |
| void SetIdleChangeProcessorExpectations() { |
| EXPECT_CALL(*password_store_.get(), AddLoginImpl(_)).Times(0); |
| EXPECT_CALL(*password_store_.get(), UpdateLoginImpl(_)).Times(0); |
| EXPECT_CALL(*password_store_.get(), RemoveLoginImpl(_)).Times(0); |
| } |
| |
| content::MockNotificationObserver observer_; |
| scoped_ptr<TestingProfile> profile_; |
| scoped_refptr<MockPasswordStore> password_store_; |
| content::NotificationRegistrar registrar_; |
| }; |
| |
| void AddPasswordEntriesCallback(ProfileSyncServicePasswordTest* test, |
| const std::vector<PasswordForm>& entries) { |
| for (size_t i = 0; i < entries.size(); ++i) |
| test->AddPasswordSyncNode(entries[i]); |
| } |
| |
| // Flaky on mac_rel. See http://crbug.com/228943 |
| #if defined(OS_MACOSX) |
| #define MAYBE_EmptyNativeEmptySync DISABLED_EmptyNativeEmptySync |
| #define MAYBE_EnsureNoTransactions DISABLED_EnsureNoTransactions |
| #define MAYBE_FailModelAssociation DISABLED_FailModelAssociation |
| #define MAYBE_FailPasswordStoreLoad DISABLED_FailPasswordStoreLoad |
| #define MAYBE_HasNativeEntriesEmptySync DISABLED_HasNativeEntriesEmptySync |
| #define MAYBE_HasNativeEntriesEmptySyncSameUsername \ |
| DISABLED_HasNativeEntriesEmptySyncSameUsername |
| #define MAYBE_HasNativeHasSyncMergeEntry DISABLED_HasNativeHasSyncMergeEntry |
| #define MAYBE_HasNativeHasSyncNoMerge DISABLED_HasNativeHasSyncNoMerge |
| #else |
| #define MAYBE_EmptyNativeEmptySync EmptyNativeEmptySync |
| #define MAYBE_EnsureNoTransactions EnsureNoTransactions |
| #define MAYBE_FailModelAssociation FailModelAssociation |
| #define MAYBE_FailPasswordStoreLoad FailPasswordStoreLoad |
| #define MAYBE_HasNativeEntriesEmptySync HasNativeEntriesEmptySync |
| #define MAYBE_HasNativeEntriesEmptySyncSameUsername \ |
| HasNativeEntriesEmptySyncSameUsername |
| #define MAYBE_HasNativeHasSyncMergeEntry HasNativeHasSyncMergeEntry |
| #define MAYBE_HasNativeHasSyncNoMerge HasNativeHasSyncNoMerge |
| #endif |
| |
| TEST_F(ProfileSyncServicePasswordTest, MAYBE_FailModelAssociation) { |
| StartSyncService(base::Closure(), base::Closure()); |
| EXPECT_TRUE(sync_service_->HasUnrecoverableError()); |
| } |
| |
| TEST_F(ProfileSyncServicePasswordTest, MAYBE_FailPasswordStoreLoad) { |
| password_store_ = static_cast<NullPasswordStore*>( |
| PasswordStoreFactory::GetInstance()->SetTestingFactoryAndUse( |
| profile_.get(), NullPasswordStore::Build).get()); |
| StartSyncService(base::Closure(), base::Closure()); |
| EXPECT_FALSE(sync_service_->HasUnrecoverableError()); |
| syncer::ModelTypeSet failed_types = |
| sync_service_->failed_data_types_handler().GetFailedTypes(); |
| EXPECT_TRUE(failed_types.Equals(syncer::ModelTypeSet(syncer::PASSWORDS))); |
| } |
| |
| TEST_F(ProfileSyncServicePasswordTest, MAYBE_EmptyNativeEmptySync) { |
| EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_)) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_)) |
| .WillOnce(Return(true)); |
| SetIdleChangeProcessorExpectations(); |
| CreateRootHelper create_root(this, syncer::PASSWORDS); |
| StartSyncService(create_root.callback(), base::Closure()); |
| std::vector<PasswordForm> sync_entries; |
| GetPasswordEntriesFromSyncDB(&sync_entries); |
| EXPECT_EQ(0U, sync_entries.size()); |
| } |
| |
| TEST_F(ProfileSyncServicePasswordTest, MAYBE_HasNativeEntriesEmptySync) { |
| std::vector<PasswordForm*> forms; |
| std::vector<PasswordForm> expected_forms; |
| PasswordForm* new_form = new PasswordForm; |
| new_form->scheme = PasswordForm::SCHEME_HTML; |
| new_form->signon_realm = "pie"; |
| new_form->origin = GURL("http://pie.com"); |
| new_form->action = GURL("http://pie.com/submit"); |
| new_form->username_element = UTF8ToUTF16("name"); |
| new_form->username_value = UTF8ToUTF16("tom"); |
| new_form->password_element = UTF8ToUTF16("cork"); |
| new_form->password_value = UTF8ToUTF16("password1"); |
| new_form->ssl_valid = true; |
| new_form->preferred = false; |
| new_form->date_created = base::Time::FromInternalValue(1234); |
| new_form->blacklisted_by_user = false; |
| forms.push_back(new_form); |
| expected_forms.push_back(*new_form); |
| EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_)) |
| .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true))); |
| EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_)) |
| .WillOnce(Return(true)); |
| SetIdleChangeProcessorExpectations(); |
| CreateRootHelper create_root(this, syncer::PASSWORDS); |
| StartSyncService(create_root.callback(), base::Closure()); |
| std::vector<PasswordForm> sync_forms; |
| GetPasswordEntriesFromSyncDB(&sync_forms); |
| ASSERT_EQ(1U, sync_forms.size()); |
| EXPECT_TRUE(ComparePasswords(expected_forms[0], sync_forms[0])); |
| } |
| |
| TEST_F(ProfileSyncServicePasswordTest, |
| MAYBE_HasNativeEntriesEmptySyncSameUsername) { |
| std::vector<PasswordForm*> forms; |
| std::vector<PasswordForm> expected_forms; |
| |
| { |
| PasswordForm* new_form = new PasswordForm; |
| new_form->scheme = PasswordForm::SCHEME_HTML; |
| new_form->signon_realm = "pie"; |
| new_form->origin = GURL("http://pie.com"); |
| new_form->action = GURL("http://pie.com/submit"); |
| new_form->username_element = UTF8ToUTF16("name"); |
| new_form->username_value = UTF8ToUTF16("tom"); |
| new_form->password_element = UTF8ToUTF16("cork"); |
| new_form->password_value = UTF8ToUTF16("password1"); |
| new_form->ssl_valid = true; |
| new_form->preferred = false; |
| new_form->date_created = base::Time::FromInternalValue(1234); |
| new_form->blacklisted_by_user = false; |
| forms.push_back(new_form); |
| expected_forms.push_back(*new_form); |
| } |
| { |
| PasswordForm* new_form = new PasswordForm; |
| new_form->scheme = PasswordForm::SCHEME_HTML; |
| new_form->signon_realm = "pie"; |
| new_form->origin = GURL("http://pie.com"); |
| new_form->action = GURL("http://pie.com/submit"); |
| new_form->username_element = UTF8ToUTF16("name"); |
| new_form->username_value = UTF8ToUTF16("pete"); |
| new_form->password_element = UTF8ToUTF16("cork"); |
| new_form->password_value = UTF8ToUTF16("password2"); |
| new_form->ssl_valid = true; |
| new_form->preferred = false; |
| new_form->date_created = base::Time::FromInternalValue(1234); |
| new_form->blacklisted_by_user = false; |
| forms.push_back(new_form); |
| expected_forms.push_back(*new_form); |
| } |
| |
| EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_)) |
| .WillOnce(DoAll(SetArgumentPointee<0>(forms), Return(true))); |
| EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_)) |
| .WillOnce(Return(true)); |
| SetIdleChangeProcessorExpectations(); |
| CreateRootHelper create_root(this, syncer::PASSWORDS); |
| StartSyncService(create_root.callback(), base::Closure()); |
| std::vector<PasswordForm> sync_forms; |
| GetPasswordEntriesFromSyncDB(&sync_forms); |
| ASSERT_EQ(2U, sync_forms.size()); |
| EXPECT_TRUE(ComparePasswords(expected_forms[0], sync_forms[1])); |
| EXPECT_TRUE(ComparePasswords(expected_forms[1], sync_forms[0])); |
| } |
| |
| TEST_F(ProfileSyncServicePasswordTest, MAYBE_HasNativeHasSyncNoMerge) { |
| std::vector<PasswordForm*> native_forms; |
| std::vector<PasswordForm> sync_forms; |
| std::vector<PasswordForm> expected_forms; |
| { |
| PasswordForm* new_form = new PasswordForm; |
| new_form->scheme = PasswordForm::SCHEME_HTML; |
| new_form->signon_realm = "pie"; |
| new_form->origin = GURL("http://pie.com"); |
| new_form->action = GURL("http://pie.com/submit"); |
| new_form->username_element = UTF8ToUTF16("name"); |
| new_form->username_value = UTF8ToUTF16("tom"); |
| new_form->password_element = UTF8ToUTF16("cork"); |
| new_form->password_value = UTF8ToUTF16("password1"); |
| new_form->ssl_valid = true; |
| new_form->preferred = false; |
| new_form->date_created = base::Time::FromInternalValue(1234); |
| new_form->blacklisted_by_user = false; |
| |
| native_forms.push_back(new_form); |
| expected_forms.push_back(*new_form); |
| } |
| |
| { |
| PasswordForm new_form; |
| new_form.scheme = PasswordForm::SCHEME_HTML; |
| new_form.signon_realm = "pie2"; |
| new_form.origin = GURL("http://pie2.com"); |
| new_form.action = GURL("http://pie2.com/submit"); |
| new_form.username_element = UTF8ToUTF16("name2"); |
| new_form.username_value = UTF8ToUTF16("tom2"); |
| new_form.password_element = UTF8ToUTF16("cork2"); |
| new_form.password_value = UTF8ToUTF16("password12"); |
| new_form.ssl_valid = false; |
| new_form.preferred = true; |
| new_form.date_created = base::Time::FromInternalValue(12345); |
| new_form.blacklisted_by_user = false; |
| sync_forms.push_back(new_form); |
| expected_forms.push_back(new_form); |
| } |
| |
| EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_)) |
| .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true))); |
| EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_)) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*password_store_.get(), AddLoginImpl(_)).Times(1); |
| |
| CreateRootHelper create_root(this, syncer::PASSWORDS); |
| StartSyncService(create_root.callback(), |
| base::Bind(&AddPasswordEntriesCallback, this, sync_forms)); |
| |
| std::vector<PasswordForm> new_sync_forms; |
| GetPasswordEntriesFromSyncDB(&new_sync_forms); |
| |
| EXPECT_EQ(2U, new_sync_forms.size()); |
| EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0])); |
| EXPECT_TRUE(ComparePasswords(expected_forms[1], new_sync_forms[1])); |
| } |
| |
| // Same as HasNativeHasEmptyNoMerge, but we attempt to aquire a sync transaction |
| // every time the password store is accessed. |
| TEST_F(ProfileSyncServicePasswordTest, MAYBE_EnsureNoTransactions) { |
| std::vector<PasswordForm*> native_forms; |
| std::vector<PasswordForm> sync_forms; |
| std::vector<PasswordForm> expected_forms; |
| { |
| PasswordForm* new_form = new PasswordForm; |
| new_form->scheme = PasswordForm::SCHEME_HTML; |
| new_form->signon_realm = "pie"; |
| new_form->origin = GURL("http://pie.com"); |
| new_form->action = GURL("http://pie.com/submit"); |
| new_form->username_element = UTF8ToUTF16("name"); |
| new_form->username_value = UTF8ToUTF16("tom"); |
| new_form->password_element = UTF8ToUTF16("cork"); |
| new_form->password_value = UTF8ToUTF16("password1"); |
| new_form->ssl_valid = true; |
| new_form->preferred = false; |
| new_form->date_created = base::Time::FromInternalValue(1234); |
| new_form->blacklisted_by_user = false; |
| |
| native_forms.push_back(new_form); |
| expected_forms.push_back(*new_form); |
| } |
| |
| { |
| PasswordForm new_form; |
| new_form.scheme = PasswordForm::SCHEME_HTML; |
| new_form.signon_realm = "pie2"; |
| new_form.origin = GURL("http://pie2.com"); |
| new_form.action = GURL("http://pie2.com/submit"); |
| new_form.username_element = UTF8ToUTF16("name2"); |
| new_form.username_value = UTF8ToUTF16("tom2"); |
| new_form.password_element = UTF8ToUTF16("cork2"); |
| new_form.password_value = UTF8ToUTF16("password12"); |
| new_form.ssl_valid = false; |
| new_form.preferred = true; |
| new_form.date_created = base::Time::FromInternalValue(12345); |
| new_form.blacklisted_by_user = false; |
| sync_forms.push_back(new_form); |
| expected_forms.push_back(new_form); |
| } |
| |
| EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_)) |
| .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), |
| AcquireSyncTransaction(this), |
| Return(true))); |
| EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_)) |
| .WillOnce(DoAll(AcquireSyncTransaction(this), Return(true))); |
| EXPECT_CALL(*password_store_.get(), AddLoginImpl(_)) |
| .WillOnce(AcquireSyncTransaction(this)); |
| |
| CreateRootHelper create_root(this, syncer::PASSWORDS); |
| StartSyncService(create_root.callback(), |
| base::Bind(&AddPasswordEntriesCallback, this, sync_forms)); |
| |
| std::vector<PasswordForm> new_sync_forms; |
| GetPasswordEntriesFromSyncDB(&new_sync_forms); |
| |
| EXPECT_EQ(2U, new_sync_forms.size()); |
| EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0])); |
| EXPECT_TRUE(ComparePasswords(expected_forms[1], new_sync_forms[1])); |
| } |
| |
| TEST_F(ProfileSyncServicePasswordTest, MAYBE_HasNativeHasSyncMergeEntry) { |
| std::vector<PasswordForm*> native_forms; |
| std::vector<PasswordForm> sync_forms; |
| std::vector<PasswordForm> expected_forms; |
| { |
| PasswordForm* new_form = new PasswordForm; |
| new_form->scheme = PasswordForm::SCHEME_HTML; |
| new_form->signon_realm = "pie"; |
| new_form->origin = GURL("http://pie.com"); |
| new_form->action = GURL("http://pie.com/submit"); |
| new_form->username_element = UTF8ToUTF16("name"); |
| new_form->username_value = UTF8ToUTF16("tom"); |
| new_form->password_element = UTF8ToUTF16("cork"); |
| new_form->password_value = UTF8ToUTF16("password1"); |
| new_form->ssl_valid = true; |
| new_form->preferred = false; |
| new_form->date_created = base::Time::FromInternalValue(1234); |
| new_form->blacklisted_by_user = false; |
| |
| native_forms.push_back(new_form); |
| } |
| |
| { |
| PasswordForm new_form; |
| new_form.scheme = PasswordForm::SCHEME_HTML; |
| new_form.signon_realm = "pie"; |
| new_form.origin = GURL("http://pie.com"); |
| new_form.action = GURL("http://pie.com/submit"); |
| new_form.username_element = UTF8ToUTF16("name"); |
| new_form.username_value = UTF8ToUTF16("tom"); |
| new_form.password_element = UTF8ToUTF16("cork"); |
| new_form.password_value = UTF8ToUTF16("password12"); |
| new_form.ssl_valid = false; |
| new_form.preferred = true; |
| new_form.date_created = base::Time::FromInternalValue(12345); |
| new_form.blacklisted_by_user = false; |
| sync_forms.push_back(new_form); |
| } |
| |
| { |
| PasswordForm new_form; |
| new_form.scheme = PasswordForm::SCHEME_HTML; |
| new_form.signon_realm = "pie"; |
| new_form.origin = GURL("http://pie.com"); |
| new_form.action = GURL("http://pie.com/submit"); |
| new_form.username_element = UTF8ToUTF16("name"); |
| new_form.username_value = UTF8ToUTF16("tom"); |
| new_form.password_element = UTF8ToUTF16("cork"); |
| new_form.password_value = UTF8ToUTF16("password12"); |
| new_form.ssl_valid = false; |
| new_form.preferred = true; |
| new_form.date_created = base::Time::FromInternalValue(12345); |
| new_form.blacklisted_by_user = false; |
| expected_forms.push_back(new_form); |
| } |
| |
| EXPECT_CALL(*password_store_.get(), FillAutofillableLogins(_)) |
| .WillOnce(DoAll(SetArgumentPointee<0>(native_forms), Return(true))); |
| EXPECT_CALL(*password_store_.get(), FillBlacklistLogins(_)) |
| .WillOnce(Return(true)); |
| EXPECT_CALL(*password_store_.get(), UpdateLoginImpl(_)).Times(1); |
| |
| CreateRootHelper create_root(this, syncer::PASSWORDS); |
| StartSyncService(create_root.callback(), |
| base::Bind(&AddPasswordEntriesCallback, this, sync_forms)); |
| |
| std::vector<PasswordForm> new_sync_forms; |
| GetPasswordEntriesFromSyncDB(&new_sync_forms); |
| |
| EXPECT_EQ(1U, new_sync_forms.size()); |
| EXPECT_TRUE(ComparePasswords(expected_forms[0], new_sync_forms[0])); |
| } |
