Home | History | Annotate | Download | only in integration 
      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 // TODO(akalin): Rename this file to migration_test.cc.
      6 
      7 #include "base/compiler_specific.h"
      8 #include "chrome/browser/prefs/scoped_user_pref_update.h"
      9 #include "chrome/browser/profiles/profile.h"
     10 #include "chrome/browser/sync/profile_sync_service_harness.h"
     11 #include "chrome/browser/sync/test/integration/bookmarks_helper.h"
     12 #include "chrome/browser/sync/test/integration/preferences_helper.h"
     13 #include "chrome/browser/sync/test/integration/sync_test.h"
     14 #include "chrome/browser/translate/translate_prefs.h"
     15 #include "chrome/common/pref_names.h"
     16 #include "chrome/test/base/ui_test_utils.h"
     17 
     18 using bookmarks_helper::AddURL;
     19 using bookmarks_helper::IndexedURL;
     20 using bookmarks_helper::IndexedURLTitle;
     21 
     22 using preferences_helper::BooleanPrefMatches;
     23 using preferences_helper::ChangeBooleanPref;
     24 
     25 namespace {
     26 
     27 // Utility functions to make a model type set out of a small number of
     28 // model types.
     29 
     30 syncer::ModelTypeSet MakeSet(syncer::ModelType type) {
     31   return syncer::ModelTypeSet(type);
     32 }
     33 
     34 syncer::ModelTypeSet MakeSet(syncer::ModelType type1,
     35                              syncer::ModelType type2) {
     36   return syncer::ModelTypeSet(type1, type2);
     37 }
     38 
     39 // An ordered list of model types sets to migrate.  Used by
     40 // RunMigrationTest().
     41 typedef std::deque<syncer::ModelTypeSet> MigrationList;
     42 
     43 // Utility functions to make a MigrationList out of a small number of
     44 // model types / model type sets.
     45 
     46 MigrationList MakeList(syncer::ModelTypeSet model_types) {
     47   return MigrationList(1, model_types);
     48 }
     49 
     50 MigrationList MakeList(syncer::ModelTypeSet model_types1,
     51                        syncer::ModelTypeSet model_types2) {
     52   MigrationList migration_list;
     53   migration_list.push_back(model_types1);
     54   migration_list.push_back(model_types2);
     55   return migration_list;
     56 }
     57 
     58 MigrationList MakeList(syncer::ModelType type) {
     59   return MakeList(MakeSet(type));
     60 }
     61 
     62 MigrationList MakeList(syncer::ModelType type1,
     63                        syncer::ModelType type2) {
     64   return MakeList(MakeSet(type1), MakeSet(type2));
     65 }
     66 
     67 class MigrationTest : public SyncTest {
     68  public:
     69   explicit MigrationTest(TestType test_type) : SyncTest(test_type) {}
     70   virtual ~MigrationTest() {}
     71 
     72   // TODO(akalin): Add more MODIFY_(data type) trigger methods, as
     73   // well as a poll-based trigger method.
     74   enum TriggerMethod { MODIFY_PREF, MODIFY_BOOKMARK, TRIGGER_NOTIFICATION };
     75 
     76   syncer::ModelTypeSet GetPreferredDataTypes() {
     77     // ProfileSyncService must already have been created before we can call
     78     // GetPreferredDataTypes().
     79     DCHECK(GetClient(0)->IsSyncAlreadySetup());
     80     syncer::ModelTypeSet preferred_data_types =
     81         GetClient(0)->service()->GetPreferredDataTypes();
     82     preferred_data_types.RemoveAll(syncer::ProxyTypes());
     83     // Make sure all clients have the same preferred data types.
     84     for (int i = 1; i < num_clients(); ++i) {
     85       const syncer::ModelTypeSet other_preferred_data_types =
     86           GetClient(i)->service()->GetPreferredDataTypes();
     87       EXPECT_TRUE(preferred_data_types.Equals(other_preferred_data_types));
     88     }
     89     return preferred_data_types;
     90   }
     91 
     92   // Returns a MigrationList with every enabled data type in its own
     93   // set.
     94   MigrationList GetPreferredDataTypesList() {
     95     MigrationList migration_list;
     96     const syncer::ModelTypeSet preferred_data_types =
     97         GetPreferredDataTypes();
     98     for (syncer::ModelTypeSet::Iterator it =
     99              preferred_data_types.First(); it.Good(); it.Inc()) {
    100       migration_list.push_back(MakeSet(it.Get()));
    101     }
    102     return migration_list;
    103   }
    104 
    105   // Trigger a migration for the given types with the given method.
    106   void TriggerMigration(syncer::ModelTypeSet model_types,
    107                         TriggerMethod trigger_method) {
    108     switch (trigger_method) {
    109       case MODIFY_PREF:
    110         // Unlike MODIFY_BOOKMARK, MODIFY_PREF doesn't cause a
    111         // notification to happen (since model association on a
    112         // boolean pref clobbers the local value), so it doesn't work
    113         // for anything but single-client tests.
    114         ASSERT_EQ(1, num_clients());
    115         ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton));
    116         ChangeBooleanPref(0, prefs::kShowHomeButton);
    117         break;
    118       case MODIFY_BOOKMARK:
    119         ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0))));
    120         break;
    121       case TRIGGER_NOTIFICATION:
    122         TriggerNotification(model_types);
    123         break;
    124       default:
    125         ADD_FAILURE();
    126     }
    127   }
    128 
    129   // Block until all clients have completed migration for the given
    130   // types.
    131   void AwaitMigration(syncer::ModelTypeSet migrate_types) {
    132     for (int i = 0; i < num_clients(); ++i) {
    133       ASSERT_TRUE(GetClient(i)->AwaitMigration(migrate_types));
    134     }
    135   }
    136 
    137   bool ShouldRunMigrationTest() const {
    138     if (!ServerSupportsNotificationControl() ||
    139         !ServerSupportsErrorTriggering()) {
    140       LOG(WARNING) << "Test skipped in this server environment.";
    141       return false;
    142     }
    143     return true;
    144   }
    145 
    146   // Makes sure migration works with the given migration list and
    147   // trigger method.
    148   void RunMigrationTest(const MigrationList& migration_list,
    149                        TriggerMethod trigger_method) {
    150     ASSERT_TRUE(ShouldRunMigrationTest());
    151 
    152     // If we have only one client, turn off notifications to avoid the
    153     // possibility of spurious sync cycles.
    154     bool do_test_without_notifications =
    155         (trigger_method != TRIGGER_NOTIFICATION && num_clients() == 1);
    156 
    157     if (do_test_without_notifications) {
    158       DisableNotifications();
    159     }
    160 
    161     // Phase 1: Trigger the migrations on the server.
    162     for (MigrationList::const_iterator it = migration_list.begin();
    163          it != migration_list.end(); ++it) {
    164       TriggerMigrationDoneError(*it);
    165     }
    166 
    167     // Phase 2: Trigger each migration individually and wait for it to
    168     // complete.  (Multiple migrations may be handled by each
    169     // migration cycle, but there's no guarantee of that, so we have
    170     // to trigger each migration individually.)
    171     for (MigrationList::const_iterator it = migration_list.begin();
    172          it != migration_list.end(); ++it) {
    173       TriggerMigration(*it, trigger_method);
    174       AwaitMigration(*it);
    175     }
    176 
    177     // Phase 3: Wait for all clients to catch up.
    178     //
    179     // AwaitQuiescence() will not succeed when notifications are disabled.  We
    180     // can safely avoid calling it because we know that, in the single client
    181     // case, there is no one else to wait for.
    182     //
    183     // TODO(rlarocque, 97780): Remove the if condition when the test harness
    184     // supports calling AwaitQuiescence() when notifications are disabled.
    185     if (!do_test_without_notifications) {
    186       AwaitQuiescence();
    187     }
    188 
    189     // TODO(rlarocque): It should be possible to re-enable notifications
    190     // here, but doing so makes some windows tests flaky.
    191   }
    192 
    193  private:
    194   DISALLOW_COPY_AND_ASSIGN(MigrationTest);
    195 };
    196 
    197 class MigrationSingleClientTest : public MigrationTest {
    198  public:
    199   MigrationSingleClientTest() : MigrationTest(SINGLE_CLIENT) {}
    200   virtual ~MigrationSingleClientTest() {}
    201 
    202   void RunSingleClientMigrationTest(const MigrationList& migration_list,
    203                                     TriggerMethod trigger_method) {
    204     if (!ShouldRunMigrationTest()) {
    205       return;
    206     }
    207     ASSERT_TRUE(SetupSync());
    208     RunMigrationTest(migration_list, trigger_method);
    209   }
    210 
    211  private:
    212   DISALLOW_COPY_AND_ASSIGN(MigrationSingleClientTest);
    213 };
    214 
    215 // The simplest possible migration tests -- a single data type.
    216 
    217 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsOnlyModifyPref) {
    218   RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES), MODIFY_PREF);
    219 }
    220 
    221 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsOnlyModifyBookmark) {
    222   RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES),
    223                                MODIFY_BOOKMARK);
    224 }
    225 
    226 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
    227                        PrefsOnlyTriggerNotification) {
    228   RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES),
    229                                TRIGGER_NOTIFICATION);
    230 }
    231 
    232 // Nigori is handled specially, so we test that separately.
    233 
    234 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, NigoriOnly) {
    235   RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES),
    236                                TRIGGER_NOTIFICATION);
    237 }
    238 
    239 // A little more complicated -- two data types.
    240 
    241 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
    242                        BookmarksPrefsIndividually) {
    243   RunSingleClientMigrationTest(
    244       MakeList(syncer::BOOKMARKS, syncer::PREFERENCES),
    245       MODIFY_PREF);
    246 }
    247 
    248 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, BookmarksPrefsBoth) {
    249   RunSingleClientMigrationTest(
    250       MakeList(MakeSet(syncer::BOOKMARKS, syncer::PREFERENCES)),
    251       MODIFY_BOOKMARK);
    252 }
    253 
    254 // Two data types with one being nigori.
    255 
    256 // See crbug.com/124480.
    257 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
    258                        DISABLED_PrefsNigoriIndividiaully) {
    259   RunSingleClientMigrationTest(
    260       MakeList(syncer::PREFERENCES, syncer::NIGORI),
    261       TRIGGER_NOTIFICATION);
    262 }
    263 
    264 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsNigoriBoth) {
    265   RunSingleClientMigrationTest(
    266       MakeList(MakeSet(syncer::PREFERENCES, syncer::NIGORI)),
    267       MODIFY_PREF);
    268 }
    269 
    270 // The whole shebang -- all data types.
    271 
    272 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, AllTypesIndividually) {
    273   ASSERT_TRUE(SetupClients());
    274   RunSingleClientMigrationTest(GetPreferredDataTypesList(), MODIFY_BOOKMARK);
    275 }
    276 
    277 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
    278                        AllTypesIndividuallyTriggerNotification) {
    279   ASSERT_TRUE(SetupClients());
    280   RunSingleClientMigrationTest(GetPreferredDataTypesList(),
    281                                TRIGGER_NOTIFICATION);
    282 }
    283 
    284 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, AllTypesAtOnce) {
    285   ASSERT_TRUE(SetupClients());
    286   RunSingleClientMigrationTest(MakeList(GetPreferredDataTypes()),
    287                                MODIFY_PREF);
    288 }
    289 
    290 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
    291                        AllTypesAtOnceTriggerNotification) {
    292   ASSERT_TRUE(SetupClients());
    293   RunSingleClientMigrationTest(MakeList(GetPreferredDataTypes()),
    294                                TRIGGER_NOTIFICATION);
    295 }
    296 
    297 // All data types plus nigori.
    298 
    299 // See crbug.com/124480.
    300 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
    301                        DISABLED_AllTypesWithNigoriIndividually) {
    302   ASSERT_TRUE(SetupClients());
    303   MigrationList migration_list = GetPreferredDataTypesList();
    304   migration_list.push_front(MakeSet(syncer::NIGORI));
    305   RunSingleClientMigrationTest(migration_list, MODIFY_BOOKMARK);
    306 }
    307 
    308 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
    309                        AllTypesWithNigoriAtOnce) {
    310   ASSERT_TRUE(SetupClients());
    311   syncer::ModelTypeSet all_types = GetPreferredDataTypes();
    312   all_types.Put(syncer::NIGORI);
    313   RunSingleClientMigrationTest(MakeList(all_types), MODIFY_PREF);
    314 }
    315 
    316 class MigrationTwoClientTest : public MigrationTest {
    317  public:
    318   MigrationTwoClientTest() : MigrationTest(TWO_CLIENT) {}
    319   virtual ~MigrationTwoClientTest() {}
    320 
    321   // Helper function that verifies that preferences sync still works.
    322   void VerifyPrefSync() {
    323     ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton));
    324     ChangeBooleanPref(0, prefs::kShowHomeButton);
    325     ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
    326     ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton));
    327   }
    328 
    329   void RunTwoClientMigrationTest(const MigrationList& migration_list,
    330                                     TriggerMethod trigger_method) {
    331     if (!ShouldRunMigrationTest()) {
    332       return;
    333     }
    334     ASSERT_TRUE(SetupSync());
    335 
    336     // Make sure pref sync works before running the migration test.
    337     VerifyPrefSync();
    338 
    339     RunMigrationTest(migration_list, trigger_method);
    340 
    341     // Make sure pref sync still works after running the migration
    342     // test.
    343     VerifyPrefSync();
    344   }
    345 
    346  private:
    347   DISALLOW_COPY_AND_ASSIGN(MigrationTwoClientTest);
    348 };
    349 
    350 // Easiest possible test of migration errors: triggers a server
    351 // migration on one datatype, then modifies some other datatype.
    352 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest, MigratePrefsThenModifyBookmark) {
    353   RunTwoClientMigrationTest(MakeList(syncer::PREFERENCES),
    354                             MODIFY_BOOKMARK);
    355 }
    356 
    357 // Triggers a server migration on two datatypes, then makes a local
    358 // modification to one of them.
    359 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest,
    360                        MigratePrefsAndBookmarksThenModifyBookmark) {
    361   RunTwoClientMigrationTest(
    362       MakeList(syncer::PREFERENCES, syncer::BOOKMARKS),
    363       MODIFY_BOOKMARK);
    364 }
    365 
    366 // Migrate every datatype in sequence; the catch being that the server
    367 // will only tell the client about the migrations one at a time.
    368 // TODO(rsimha): This test takes longer than 60 seconds, and will cause tree
    369 // redness due to sharding.
    370 // Re-enable this test after syncer::kInitialBackoffShortRetrySeconds is reduced
    371 // to zero.
    372 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest,
    373                        DISABLED_MigrationHellWithoutNigori) {
    374   ASSERT_TRUE(SetupClients());
    375   MigrationList migration_list = GetPreferredDataTypesList();
    376   // Let the first nudge be a datatype that's neither prefs nor
    377   // bookmarks.
    378   migration_list.push_front(MakeSet(syncer::THEMES));
    379   RunTwoClientMigrationTest(migration_list, MODIFY_BOOKMARK);
    380 }
    381 
    382 // See crbug.com/124480.
    383 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest,
    384                        DISABLED_MigrationHellWithNigori) {
    385   ASSERT_TRUE(SetupClients());
    386   MigrationList migration_list = GetPreferredDataTypesList();
    387   // Let the first nudge be a datatype that's neither prefs nor
    388   // bookmarks.
    389   migration_list.push_front(MakeSet(syncer::THEMES));
    390   // Pop off one so that we don't migrate all data types; the syncer
    391   // freaks out if we do that (see http://crbug.com/94882).
    392   ASSERT_GE(migration_list.size(), 2u);
    393   ASSERT_FALSE(migration_list.back().Equals(MakeSet(syncer::NIGORI)));
    394   migration_list.back() = MakeSet(syncer::NIGORI);
    395   RunTwoClientMigrationTest(migration_list, MODIFY_BOOKMARK);
    396 }
    397 
    398 class MigrationReconfigureTest : public MigrationTwoClientTest {
    399  public:
    400   MigrationReconfigureTest() {}
    401 
    402   virtual void SetUpCommandLine(CommandLine* cl) OVERRIDE {
    403     AddTestSwitches(cl);
    404     // Do not add optional datatypes.
    405   }
    406 
    407   virtual ~MigrationReconfigureTest() {}
    408 
    409  private:
    410   DISALLOW_COPY_AND_ASSIGN(MigrationReconfigureTest);
    411 };
    412 
    413 }  // namespace
    414