Refactor password sync integration tests

chrome/browser/sync/test/integration/multiple_client_passwords_sync_test.cc

 // Copyright (c) 2011 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/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/sync/test/integration/passwords_helper.h"
+#include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
+#include "chrome/browser/sync/test/integration/sync_integration_test_util.h"
 #include "chrome/browser/sync/test/integration/sync_test.h"
 #include "components/password_manager/core/browser/password_form_data.h"
 
 using passwords_helper::AddLogin;
+using passwords_helper::AllProfilesContainSamePasswordFormsAsVerifier;
 using passwords_helper::AwaitAllProfilesContainSamePasswordForms;
+using passwords_helper::AwaitProfileContainsSamePasswordFormsAsVerifier;
 using passwords_helper::CreateTestPasswordForm;
 using passwords_helper::GetPasswordCount;
 using passwords_helper::GetPasswordStore;
+using passwords_helper::GetVerifierPasswordCount;
+using passwords_helper::GetVerifierPasswordStore;
+using passwords_helper::ProfileContainsSamePasswordFormsAsVerifier;
+using passwords_helper::SetDecryptionPassphrase;
+using passwords_helper::SetEncryptionPassphrase;
+using sync_integration_test_util::AwaitPassphraseAccepted;
+using sync_integration_test_util::AwaitPassphraseRequired;
 
 using autofill::PasswordForm;
 
+static const char* kValidPassphrase = "passphrase!";
+static const char* kAnotherValidPassphrase = "Mot de passe!";
+
 class MultipleClientPasswordsSyncTest : public SyncTest {
  public:
   MultipleClientPasswordsSyncTest() : SyncTest(MULTIPLE_CLIENT) {}
   virtual ~MultipleClientPasswordsSyncTest() {}
 
   virtual bool TestUsesSelfNotifications() OVERRIDE {
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MultipleClientPasswordsSyncTest);
 };
 
 IN_PROC_BROWSER_TEST_F(MultipleClientPasswordsSyncTest, Sanity) {
   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
 
   for (int i = 0; i < num_clients(); ++i) {
     PasswordForm form = CreateTestPasswordForm(i);
     AddLogin(GetPasswordStore(i), form);
   }
 
   ASSERT_TRUE(AwaitAllProfilesContainSamePasswordForms());
   ASSERT_EQ(num_clients(), GetPasswordCount(0));
 }
+
+IN_PROC_BROWSER_TEST_F(MultipleClientPasswordsSyncTest,
+                       SetPassphraseAndThenSetupSync) {
+  ASSERT_TRUE(SetupClients());
+
+  ASSERT_TRUE(GetClient(0)->SetupSync());
+  SetEncryptionPassphrase(0, kValidPassphrase, ProfileSyncService::EXPLICIT);
+  ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService(0)));
+
+  // When client 1 hits a passphrase required state, we can infer that
+  // client 0's passphrase has been committed. to the server.
+  GetClient(1)->SetupSync();
+  ASSERT_TRUE(AwaitPassphraseRequired(GetSyncService(1)));
+
+  // Setup client 2 *after* the passphrase has been committed.
+  ASSERT_FALSE(GetClient(2)->SetupSync());
+  ASSERT_TRUE(AwaitPassphraseRequired(GetSyncService(2)));
+
+  // Get clients 1 and 2 out of the passphrase required state.
+  ASSERT_TRUE(SetDecryptionPassphrase(1, kValidPassphrase));
+  ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService(1)));
+  ASSERT_TRUE(SetDecryptionPassphrase(2, kValidPassphrase));
+  ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService(2)));
+
+  // For some reason, the tests won't pass unless these flags are set.
+  GetSyncService(1)->SetSyncSetupCompleted();
+  GetSyncService(1)->SetSetupInProgress(false);
+  GetSyncService(2)->SetSyncSetupCompleted();
+  GetSyncService(2)->SetSetupInProgress(false);
+
+  // Move around some passwords to make sure it's all working.
+  PasswordForm form0 = CreateTestPasswordForm(0);
+  AddLogin(GetPasswordStore(0), form0);
+
+  ASSERT_TRUE(AwaitAllProfilesContainSamePasswordForms());
+}
+
+IN_PROC_BROWSER_TEST_F(MultipleClientPasswordsSyncTest,
+                       SetDifferentPassphraseAndThenSetupSync) {
+  ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
+
+  ASSERT_TRUE(GetClient(0)->SetupSync());
+  SetEncryptionPassphrase(0, kValidPassphrase, ProfileSyncService::EXPLICIT);
+  ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService((0))));
+
+  // When client 1 hits a passphrase required state, we can infer that
+  // client 0's passphrase has been committed. to the server.
+  GetClient(1)->SetupSync();
+  ASSERT_TRUE(AwaitPassphraseRequired(GetSyncService(1)));
+
+  // Give client 1 the correct passphrase.
+  SetDecryptionPassphrase(1, kValidPassphrase);
+  ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService((1))));
+
+  // For some reason, the tests won't pass unless these flags are set.
+  GetSyncService(1)->SetSetupInProgress(false);
+  GetSyncService(1)->SetSyncSetupCompleted();
+
+  // Give client 2 a different passphrase so it fails to sync.
+  ASSERT_FALSE(GetClient(2)->SetupSync());
+  ASSERT_TRUE(AwaitPassphraseRequired(GetSyncService((2))));
+  SetDecryptionPassphrase(2, kAnotherValidPassphrase);
+  ASSERT_TRUE(AwaitPassphraseRequired(GetSyncService((2))));
+
+  // Add a password on 0 while client 2 has different passphrases.
+  PasswordForm form0 = CreateTestPasswordForm(0);
+  AddLogin(GetVerifierPasswordStore(), form0);
+  AddLogin(GetPasswordStore(0), form0);
+
+  // It should sync to client 1.
+  ASSERT_TRUE(AwaitProfileContainsSamePasswordFormsAsVerifier(1));
+
+  // But it won't get synced to 2.
+  ASSERT_FALSE(ProfileContainsSamePasswordFormsAsVerifier(2));
+
+  // Update 2 with the correct passphrase, the password should now sync over.
+  ASSERT_TRUE(AwaitPassphraseRequired(GetSyncService(2)));
+  ASSERT_TRUE(SetDecryptionPassphrase(2, kValidPassphrase));
+  ASSERT_TRUE(AwaitPassphraseAccepted(GetSyncService(2)));
+
+  // For some reason, the tests won't pass unless these flags are set.
+  GetSyncService(2)->SetSetupInProgress(false);
+  GetSyncService(2)->SetSyncSetupCompleted();
+
+  ASSERT_TRUE(AwaitProfileContainsSamePasswordFormsAsVerifier(2));
+  ASSERT_TRUE(AllProfilesContainSamePasswordFormsAsVerifier());
+}