src/chrome/browser/sync/test/integration/two_client_extension_settings_and_app_settings_sync_test.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/strings/stringprintf.h"
   6 #include "chrome/browser/profiles/profile.h"
   7 #include "chrome/browser/sync/profile_sync_service_harness.h"
   8 #include "chrome/browser/sync/test/integration/apps_helper.h"
   9 #include "chrome/browser/sync/test/integration/extension_settings_helper.h"
  10 #include "chrome/browser/sync/test/integration/extensions_helper.h"
  11 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
  12 #include "chrome/browser/sync/test/integration/sync_test.h"
  13
  14 namespace {
  15
  16 using apps_helper::InstallAppForAllProfiles;
  17 using extension_settings_helper::AllExtensionSettingsSameAsVerifier;
  18 using extension_settings_helper::SetExtensionSettings;
  19 using extension_settings_helper::SetExtensionSettingsForAllProfiles;
  20 using extensions_helper::InstallExtensionForAllProfiles;
  21 using sync_datatype_helper::test;
  22
  23 // Generic mutations done after the initial setup of all tests. Note that
  24 // unfortuately we can't test existing configurations of the sync server since
  25 // the tests don't support that.
  26 void MutateSomeSettings(
  27     int seed, // used to modify the mutation values, not keys.
  28     const std::string& extension0,
  29     const std::string& extension1,
  30     const std::string& extension2) {
  31   {
  32     // Write to extension0 from profile 0 but not profile 1.
  33     DictionaryValue settings;
  34     settings.SetString("asdf", base::StringPrintf("asdfasdf-%d", seed));
  35     SetExtensionSettings(test()->verifier(),    extension0, settings);
  36     SetExtensionSettings(test()->GetProfile(0), extension0, settings);
  37   }
  38   {
  39     // Write the same data to extension1 from both profiles.
  40     DictionaryValue settings;
  41     settings.SetString("asdf", base::StringPrintf("asdfasdf-%d", seed));
  42     settings.SetString("qwer", base::StringPrintf("qwerqwer-%d", seed));
  43     SetExtensionSettingsForAllProfiles(extension1, settings);
  44   }
  45   {
  46     // Write different data to extension2 from each profile.
  47     DictionaryValue settings0;
  48     settings0.SetString("zxcv", base::StringPrintf("zxcvzxcv-%d", seed));
  49     SetExtensionSettings(test()->verifier(),    extension2, settings0);
  50     SetExtensionSettings(test()->GetProfile(0), extension2, settings0);
  51
  52     DictionaryValue settings1;
  53     settings1.SetString("1324", base::StringPrintf("12341234-%d", seed));
  54     settings1.SetString("5687", base::StringPrintf("56785678-%d", seed));
  55     SetExtensionSettings(test()->verifier(),    extension2, settings1);
  56     SetExtensionSettings(test()->GetProfile(1), extension2, settings1);
  57   }
  58 }
  59
  60 class TwoClientExtensionSettingsAndAppSettingsSyncTest : public SyncTest {
  61  public:
  62   TwoClientExtensionSettingsAndAppSettingsSyncTest() : SyncTest(TWO_CLIENT) {}
  63   virtual ~TwoClientExtensionSettingsAndAppSettingsSyncTest() {}
  64
  65  private:
  66   DISALLOW_COPY_AND_ASSIGN(TwoClientExtensionSettingsAndAppSettingsSyncTest);
  67 };
  68
  69 // For three independent extensions:
  70 //
  71 // Set up each extension with the same (but not necessarily empty) settings for
  72 // all profiles, start syncing, add some new settings, sync, mutate those
  73 // settings, sync.
  74 testing::AssertionResult StartWithSameSettingsTest(
  75     const std::string& extension0,
  76     const std::string& extension1,
  77     const std::string& extension2) {
  78   {
  79     // Leave extension0 empty.
  80   }
  81   {
  82     DictionaryValue settings;
  83     settings.SetString("foo", "bar");
  84     SetExtensionSettingsForAllProfiles(extension1, settings);
  85   }
  86   {
  87     DictionaryValue settings;
  88     settings.SetString("foo", "bar");
  89     settings.SetString("baz", "qux");
  90     SetExtensionSettingsForAllProfiles(extension2, settings);
  91   }
  92
  93   if (!test()->SetupSync())
  94     return testing::AssertionFailure();
  95   if (!test()->AwaitQuiescence())
  96     return testing::AssertionFailure();
  97   if (!AllExtensionSettingsSameAsVerifier())
  98     return testing::AssertionFailure();
  99
 100   MutateSomeSettings(0, extension0, extension1, extension2);
 101   if (!test()->AwaitQuiescence())
 102     return testing::AssertionFailure();
 103   if (!AllExtensionSettingsSameAsVerifier())
 104     return testing::AssertionFailure();
 105
 106   MutateSomeSettings(1, extension0, extension1, extension2);
 107   if (!test()->AwaitQuiescence())
 108     return testing::AssertionFailure();
 109   if (!AllExtensionSettingsSameAsVerifier())
 110     return testing::AssertionFailure();
 111
 112   return testing::AssertionSuccess();
 113 }
 114
 115 // For three independent extensions:
 116 //
 117 // Set up each extension with different settings for each profile, start
 118 // syncing, add some settings, sync, mutate those settings, sync, have a no-op
 119 // (non-)change to those settings, sync, mutate again, sync.
 120 testing::AssertionResult StartWithDifferentSettingsTest(
 121     const std::string& extension0,
 122     const std::string& extension1,
 123     const std::string& extension2) {
 124   {
 125     // Leave extension0 empty again for no particular reason other than it's
 126     // the only remaining unique combination given the other 2 tests have
 127     // (empty, nonempty) and (nonempty, nonempty) configurations. We can't test
 128     // (nonempty, nonempty) because the merging will provide unpredictable
 129     // results, so test (empty, empty).
 130   }
 131   {
 132     DictionaryValue settings;
 133     settings.SetString("foo", "bar");
 134     SetExtensionSettings(test()->verifier(), extension1, settings);
 135     SetExtensionSettings(test()->GetProfile(0), extension1, settings);
 136   }
 137   {
 138     DictionaryValue settings;
 139     settings.SetString("foo", "bar");
 140     settings.SetString("baz", "qux");
 141     SetExtensionSettings(test()->verifier(), extension2, settings);
 142     SetExtensionSettings(test()->GetProfile(1), extension2, settings);
 143   }
 144
 145   if (!test()->SetupSync())
 146     return testing::AssertionFailure();
 147   if (!test()->AwaitQuiescence())
 148     return testing::AssertionFailure();
 149   if (!AllExtensionSettingsSameAsVerifier())
 150     return testing::AssertionFailure();
 151
 152   MutateSomeSettings(2, extension0, extension1, extension2);
 153   if (!test()->AwaitQuiescence())
 154     return testing::AssertionFailure();
 155   if (!AllExtensionSettingsSameAsVerifier())
 156     return testing::AssertionFailure();
 157
 158   MutateSomeSettings(3, extension0, extension1, extension2);
 159   if (!test()->AwaitQuiescence())
 160     return testing::AssertionFailure();
 161   if (!AllExtensionSettingsSameAsVerifier())
 162     return testing::AssertionFailure();
 163
 164   // Test a round of no-ops once, for sanity. Ideally we'd want to assert that
 165   // this causes no sync activity, but that sounds tricky.
 166   MutateSomeSettings(3, extension0, extension1, extension2);
 167   if (!test()->AwaitQuiescence())
 168     return testing::AssertionFailure();
 169   if (!AllExtensionSettingsSameAsVerifier())
 170     return testing::AssertionFailure();
 171
 172   MutateSomeSettings(4, extension0, extension1, extension2);
 173   if (!test()->AwaitQuiescence())
 174     return testing::AssertionFailure();
 175   if (!AllExtensionSettingsSameAsVerifier())
 176     return testing::AssertionFailure();
 177
 178   return testing::AssertionSuccess();
 179 }
 180
 181 IN_PROC_BROWSER_TEST_F(TwoClientExtensionSettingsAndAppSettingsSyncTest,
 182                        ExtensionsStartWithSameSettings) {
 183   ASSERT_TRUE(SetupClients());
 184   ASSERT_PRED3(StartWithSameSettingsTest,
 185     InstallExtensionForAllProfiles(0),
 186     InstallExtensionForAllProfiles(1),
 187     InstallExtensionForAllProfiles(2)
 188   );
 189 }
 190
 191 IN_PROC_BROWSER_TEST_F(TwoClientExtensionSettingsAndAppSettingsSyncTest,
 192                        AppsStartWithSameSettings) {
 193   ASSERT_TRUE(SetupClients());
 194   ASSERT_PRED3(StartWithSameSettingsTest,
 195     InstallAppForAllProfiles(0),
 196     InstallAppForAllProfiles(1),
 197     InstallAppForAllProfiles(2)
 198   );
 199 }
 200
 201 IN_PROC_BROWSER_TEST_F(TwoClientExtensionSettingsAndAppSettingsSyncTest,
 202                        ExtensionsStartWithDifferentSettings) {
 203   ASSERT_TRUE(SetupClients());
 204   ASSERT_PRED3(StartWithDifferentSettingsTest,
 205     InstallExtensionForAllProfiles(0),
 206     InstallExtensionForAllProfiles(1),
 207     InstallExtensionForAllProfiles(2)
 208   );
 209 }
 210
 211 IN_PROC_BROWSER_TEST_F(TwoClientExtensionSettingsAndAppSettingsSyncTest,
 212                        AppsStartWithDifferentSettings) {
 213   ASSERT_TRUE(SetupClients());
 214   ASSERT_PRED3(StartWithDifferentSettingsTest,
 215     InstallAppForAllProfiles(0),
 216     InstallAppForAllProfiles(1),
 217     InstallAppForAllProfiles(2)
 218   );
 219 }
 220
 221 }  // namespace