src/chrome/browser/sync/test/integration/migration_test.cc

   1 // Copyright 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/compiler_specific.h"
   6 #include "base/memory/scoped_vector.h"
   7 #include "base/prefs/scoped_user_pref_update.h"
   8 #include "chrome/browser/profiles/profile.h"
   9 #include "chrome/browser/sync/backend_migrator.h"
  10 #include "chrome/browser/sync/profile_sync_service.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/profile_sync_service_harness.h"
  14 #include "chrome/browser/sync/test/integration/single_client_status_change_checker.h"
  15 #include "chrome/browser/sync/test/integration/sync_test.h"
  16 #include "chrome/common/pref_names.h"
  17 #include "chrome/test/base/ui_test_utils.h"
  18 #include "components/translate/core/browser/translate_prefs.h"
  19
  20 using bookmarks_helper::AddURL;
  21 using bookmarks_helper::IndexedURL;
  22 using bookmarks_helper::IndexedURLTitle;
  23
  24 using preferences_helper::BooleanPrefMatches;
  25 using preferences_helper::ChangeBooleanPref;
  26
  27 namespace {
  28
  29 // Utility functions to make a model type set out of a small number of
  30 // model types.
  31
  32 syncer::ModelTypeSet MakeSet(syncer::ModelType type) {
  33   return syncer::ModelTypeSet(type);
  34 }
  35
  36 syncer::ModelTypeSet MakeSet(syncer::ModelType type1,
  37                              syncer::ModelType type2) {
  38   return syncer::ModelTypeSet(type1, type2);
  39 }
  40
  41 // An ordered list of model types sets to migrate.  Used by
  42 // RunMigrationTest().
  43 typedef std::deque<syncer::ModelTypeSet> MigrationList;
  44
  45 // Utility functions to make a MigrationList out of a small number of
  46 // model types / model type sets.
  47
  48 MigrationList MakeList(syncer::ModelTypeSet model_types) {
  49   return MigrationList(1, model_types);
  50 }
  51
  52 MigrationList MakeList(syncer::ModelTypeSet model_types1,
  53                        syncer::ModelTypeSet model_types2) {
  54   MigrationList migration_list;
  55   migration_list.push_back(model_types1);
  56   migration_list.push_back(model_types2);
  57   return migration_list;
  58 }
  59
  60 MigrationList MakeList(syncer::ModelType type) {
  61   return MakeList(MakeSet(type));
  62 }
  63
  64 MigrationList MakeList(syncer::ModelType type1,
  65                        syncer::ModelType type2) {
  66   return MakeList(MakeSet(type1), MakeSet(type2));
  67 }
  68
  69 // Helper class that checks if the sync backend has successfully completed
  70 // migration for a set of data types.
  71 class MigrationChecker : public SingleClientStatusChangeChecker,
  72                          public browser_sync::MigrationObserver {
  73  public:
  74   explicit MigrationChecker(ProfileSyncServiceHarness* harness)
  75       : SingleClientStatusChangeChecker(harness->service()),
  76         harness_(harness) {
  77     DCHECK(harness_);
  78     browser_sync::BackendMigrator* migrator =
  79         harness_->service()->GetBackendMigratorForTest();
  80     // PSS must have a migrator after sync is setup and initial data type
  81     // configuration is complete.
  82     DCHECK(migrator);
  83     migrator->AddMigrationObserver(this);
  84   }
  85
  86   virtual ~MigrationChecker() {}
  87
  88   // Returns true when sync reports that there is no pending migration, and
  89   // migration is complete for all data types in |expected_types_|.
  90   virtual bool IsExitConditionSatisfied() OVERRIDE {
  91     DCHECK(!expected_types_.Empty());
  92     bool all_expected_types_migrated = migrated_types_.HasAll(expected_types_);
  93     DVLOG(1) << harness_->profile_debug_name() << ": Migrated types "
  94              << syncer::ModelTypeSetToString(migrated_types_)
  95              << (all_expected_types_migrated ? " contains " :
  96                                                " does not contain ")
  97              << syncer::ModelTypeSetToString(expected_types_);
  98     return all_expected_types_migrated &&
  99            !HasPendingBackendMigration();
 100   }
 101
 102   virtual std::string GetDebugMessage() const OVERRIDE {
 103     return "Waiting to migrate (" + ModelTypeSetToString(expected_types_) + ")";
 104   }
 105
 106   bool HasPendingBackendMigration() const {
 107     browser_sync::BackendMigrator* migrator =
 108         harness_->service()->GetBackendMigratorForTest();
 109     return migrator && migrator->state() != browser_sync::BackendMigrator::IDLE;
 110   }
 111
 112   void set_expected_types(syncer::ModelTypeSet expected_types) {
 113     expected_types_ = expected_types;
 114   }
 115
 116   syncer::ModelTypeSet migrated_types() const {
 117     return migrated_types_;
 118   }
 119
 120   virtual void OnMigrationStateChange() OVERRIDE {
 121     if (HasPendingBackendMigration()) {
 122       // A new bunch of data types are in the process of being migrated. Merge
 123       // them into |pending_types_|.
 124       pending_types_.PutAll(
 125           harness_->service()->GetBackendMigratorForTest()->
 126               GetPendingMigrationTypesForTest());
 127       DVLOG(1) << harness_->profile_debug_name()
 128                << ": new pending migration types "
 129                << syncer::ModelTypeSetToString(pending_types_);
 130     } else {
 131       // Migration just finished for a bunch of data types. Merge them into
 132       // |migrated_types_|.
 133       migrated_types_.PutAll(pending_types_);
 134       pending_types_.Clear();
 135       DVLOG(1) << harness_->profile_debug_name() << ": new migrated types "
 136                << syncer::ModelTypeSetToString(migrated_types_);
 137     }
 138
 139     // Manually trigger a check of the exit condition.
 140     if (!expected_types_.Empty())
 141       OnStateChanged();
 142   }
 143
 144  private:
 145   // The sync client for which migration is being verified.
 146   ProfileSyncServiceHarness* harness_;
 147
 148   // The set of data types that are expected to eventually undergo migration.
 149   syncer::ModelTypeSet expected_types_;
 150
 151   // The set of data types currently undergoing migration.
 152   syncer::ModelTypeSet pending_types_;
 153
 154   // The set of data types for which migration is complete. Accumulated by
 155   // successive calls to OnMigrationStateChanged.
 156   syncer::ModelTypeSet migrated_types_;
 157
 158   DISALLOW_COPY_AND_ASSIGN(MigrationChecker);
 159 };
 160
 161 class MigrationTest : public SyncTest  {
 162  public:
 163   explicit MigrationTest(TestType test_type) : SyncTest(test_type) {}
 164   virtual ~MigrationTest() {}
 165
 166   enum TriggerMethod { MODIFY_PREF, MODIFY_BOOKMARK, TRIGGER_NOTIFICATION };
 167
 168   // Set up sync for all profiles and initialize all MigrationCheckers. This
 169   // helps ensure that all migration events are captured, even if they were to
 170   // occur before a test calls AwaitMigration for a specific profile.
 171   virtual bool SetupSync() OVERRIDE {
 172     if (!SyncTest::SetupSync())
 173       return false;
 174
 175     for (int i = 0; i < num_clients(); ++i) {
 176       MigrationChecker* checker = new MigrationChecker(GetClient(i));
 177       migration_checkers_.push_back(checker);
 178     }
 179     return true;
 180   }
 181
 182   syncer::ModelTypeSet GetPreferredDataTypes() {
 183     // ProfileSyncService must already have been created before we can call
 184     // GetPreferredDataTypes().
 185     DCHECK(GetSyncService((0)));
 186     syncer::ModelTypeSet preferred_data_types =
 187         GetSyncService((0))->GetPreferredDataTypes();
 188     preferred_data_types.RemoveAll(syncer::ProxyTypes());
 189     // Make sure all clients have the same preferred data types.
 190     for (int i = 1; i < num_clients(); ++i) {
 191       const syncer::ModelTypeSet other_preferred_data_types =
 192           GetSyncService((i))->GetPreferredDataTypes();
 193       EXPECT_TRUE(preferred_data_types.Equals(other_preferred_data_types));
 194     }
 195     return preferred_data_types;
 196   }
 197
 198   // Returns a MigrationList with every enabled data type in its own
 199   // set.
 200   MigrationList GetPreferredDataTypesList() {
 201     MigrationList migration_list;
 202     const syncer::ModelTypeSet preferred_data_types =
 203         GetPreferredDataTypes();
 204     for (syncer::ModelTypeSet::Iterator it =
 205              preferred_data_types.First(); it.Good(); it.Inc()) {
 206       migration_list.push_back(MakeSet(it.Get()));
 207     }
 208     return migration_list;
 209   }
 210
 211   // Trigger a migration for the given types with the given method.
 212   void TriggerMigration(syncer::ModelTypeSet model_types,
 213                         TriggerMethod trigger_method) {
 214     switch (trigger_method) {
 215       case MODIFY_PREF:
 216         // Unlike MODIFY_BOOKMARK, MODIFY_PREF doesn't cause a
 217         // notification to happen (since model association on a
 218         // boolean pref clobbers the local value), so it doesn't work
 219         // for anything but single-client tests.
 220         ASSERT_EQ(1, num_clients());
 221         ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton));
 222         ChangeBooleanPref(0, prefs::kShowHomeButton);
 223         break;
 224       case MODIFY_BOOKMARK:
 225         ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0))));
 226         break;
 227       case TRIGGER_NOTIFICATION:
 228         TriggerNotification(model_types);
 229         break;
 230       default:
 231         ADD_FAILURE();
 232     }
 233   }
 234
 235   // Block until all clients have completed migration for the given
 236   // types.
 237   void AwaitMigration(syncer::ModelTypeSet migrate_types) {
 238     for (int i = 0; i < num_clients(); ++i) {
 239       MigrationChecker* checker = migration_checkers_[i];
 240       checker->set_expected_types(migrate_types);
 241       checker->Wait();
 242       ASSERT_FALSE(checker->TimedOut());
 243     }
 244   }
 245
 246   bool ShouldRunMigrationTest() const {
 247     if (!ServerSupportsNotificationControl() ||
 248         !ServerSupportsErrorTriggering()) {
 249       LOG(WARNING) << "Test skipped in this server environment.";
 250       return false;
 251     }
 252     return true;
 253   }
 254
 255   // Makes sure migration works with the given migration list and
 256   // trigger method.
 257   void RunMigrationTest(const MigrationList& migration_list,
 258                         TriggerMethod trigger_method) {
 259     ASSERT_TRUE(ShouldRunMigrationTest());
 260
 261     // If we have only one client, turn off notifications to avoid the
 262     // possibility of spurious sync cycles.
 263     bool do_test_without_notifications =
 264         (trigger_method != TRIGGER_NOTIFICATION && num_clients() == 1);
 265
 266     if (do_test_without_notifications) {
 267       DisableNotifications();
 268     }
 269
 270     // Make sure migration hasn't been triggered prematurely.
 271     for (int i = 0; i < num_clients(); ++i) {
 272       ASSERT_TRUE(migration_checkers_[i]->migrated_types().Empty());
 273     }
 274
 275     // Phase 1: Trigger the migrations on the server.
 276     for (MigrationList::const_iterator it = migration_list.begin();
 277          it != migration_list.end(); ++it) {
 278       TriggerMigrationDoneError(*it);
 279     }
 280
 281     // Phase 2: Trigger each migration individually and wait for it to
 282     // complete.  (Multiple migrations may be handled by each
 283     // migration cycle, but there's no guarantee of that, so we have
 284     // to trigger each migration individually.)
 285     for (MigrationList::const_iterator it = migration_list.begin();
 286          it != migration_list.end(); ++it) {
 287       TriggerMigration(*it, trigger_method);
 288       AwaitMigration(*it);
 289     }
 290
 291     // Phase 3: Wait for all clients to catch up.
 292     //
 293     // AwaitQuiescence() will not succeed when notifications are disabled.  We
 294     // can safely avoid calling it because we know that, in the single client
 295     // case, there is no one else to wait for.
 296     //
 297     // TODO(rlarocque, 97780): Remove the if condition when the test harness
 298     // supports calling AwaitQuiescence() when notifications are disabled.
 299     if (!do_test_without_notifications) {
 300       AwaitQuiescence();
 301     }
 302
 303     // TODO(rlarocque): It should be possible to re-enable notifications
 304     // here, but doing so makes some windows tests flaky.
 305   }
 306
 307  private:
 308   // Used to keep track of the migration progress for each sync client.
 309   ScopedVector<MigrationChecker> migration_checkers_;
 310
 311   DISALLOW_COPY_AND_ASSIGN(MigrationTest);
 312 };
 313
 314 class MigrationSingleClientTest : public MigrationTest {
 315  public:
 316   MigrationSingleClientTest() : MigrationTest(SINGLE_CLIENT) {}
 317   virtual ~MigrationSingleClientTest() {}
 318
 319   void RunSingleClientMigrationTest(const MigrationList& migration_list,
 320                                     TriggerMethod trigger_method) {
 321     if (!ShouldRunMigrationTest()) {
 322       return;
 323     }
 324     ASSERT_TRUE(SetupSync());
 325     RunMigrationTest(migration_list, trigger_method);
 326   }
 327
 328  private:
 329   DISALLOW_COPY_AND_ASSIGN(MigrationSingleClientTest);
 330 };
 331
 332 // The simplest possible migration tests -- a single data type.
 333
 334 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsOnlyModifyPref) {
 335   RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES), MODIFY_PREF);
 336 }
 337
 338 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsOnlyModifyBookmark) {
 339   RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES),
 340                                MODIFY_BOOKMARK);
 341 }
 342
 343 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
 344                        PrefsOnlyTriggerNotification) {
 345   RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES),
 346                                TRIGGER_NOTIFICATION);
 347 }
 348
 349 // Nigori is handled specially, so we test that separately.
 350
 351 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, NigoriOnly) {
 352   RunSingleClientMigrationTest(MakeList(syncer::PREFERENCES),
 353                                TRIGGER_NOTIFICATION);
 354 }
 355
 356 // A little more complicated -- two data types.
 357
 358 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
 359                        BookmarksPrefsIndividually) {
 360   RunSingleClientMigrationTest(
 361       MakeList(syncer::BOOKMARKS, syncer::PREFERENCES),
 362       MODIFY_PREF);
 363 }
 364
 365 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, BookmarksPrefsBoth) {
 366   RunSingleClientMigrationTest(
 367       MakeList(MakeSet(syncer::BOOKMARKS, syncer::PREFERENCES)),
 368       MODIFY_BOOKMARK);
 369 }
 370
 371 // Two data types with one being nigori.
 372
 373 // See crbug.com/124480.
 374 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
 375                        DISABLED_PrefsNigoriIndividiaully) {
 376   RunSingleClientMigrationTest(
 377       MakeList(syncer::PREFERENCES, syncer::NIGORI),
 378       TRIGGER_NOTIFICATION);
 379 }
 380
 381 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, PrefsNigoriBoth) {
 382   RunSingleClientMigrationTest(
 383       MakeList(MakeSet(syncer::PREFERENCES, syncer::NIGORI)),
 384       MODIFY_PREF);
 385 }
 386
 387 // The whole shebang -- all data types.
 388
 389 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, AllTypesIndividually) {
 390   ASSERT_TRUE(SetupClients());
 391   RunSingleClientMigrationTest(GetPreferredDataTypesList(), MODIFY_BOOKMARK);
 392 }
 393
 394 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
 395                        AllTypesIndividuallyTriggerNotification) {
 396   ASSERT_TRUE(SetupClients());
 397   RunSingleClientMigrationTest(GetPreferredDataTypesList(),
 398                                TRIGGER_NOTIFICATION);
 399 }
 400
 401 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest, AllTypesAtOnce) {
 402   ASSERT_TRUE(SetupClients());
 403   RunSingleClientMigrationTest(MakeList(GetPreferredDataTypes()),
 404                                MODIFY_PREF);
 405 }
 406
 407 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
 408                        AllTypesAtOnceTriggerNotification) {
 409   ASSERT_TRUE(SetupClients());
 410   RunSingleClientMigrationTest(MakeList(GetPreferredDataTypes()),
 411                                TRIGGER_NOTIFICATION);
 412 }
 413
 414 // All data types plus nigori.
 415
 416 // See crbug.com/124480.
 417 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
 418                        DISABLED_AllTypesWithNigoriIndividually) {
 419   ASSERT_TRUE(SetupClients());
 420   MigrationList migration_list = GetPreferredDataTypesList();
 421   migration_list.push_front(MakeSet(syncer::NIGORI));
 422   RunSingleClientMigrationTest(migration_list, MODIFY_BOOKMARK);
 423 }
 424
 425 IN_PROC_BROWSER_TEST_F(MigrationSingleClientTest,
 426                        AllTypesWithNigoriAtOnce) {
 427   ASSERT_TRUE(SetupClients());
 428   syncer::ModelTypeSet all_types = GetPreferredDataTypes();
 429   all_types.Put(syncer::NIGORI);
 430   RunSingleClientMigrationTest(MakeList(all_types), MODIFY_PREF);
 431 }
 432
 433 class MigrationTwoClientTest : public MigrationTest {
 434  public:
 435   MigrationTwoClientTest() : MigrationTest(TWO_CLIENT) {}
 436   virtual ~MigrationTwoClientTest() {}
 437
 438   // Helper function that verifies that preferences sync still works.
 439   void VerifyPrefSync() {
 440     ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton));
 441     ChangeBooleanPref(0, prefs::kShowHomeButton);
 442     ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
 443     ASSERT_TRUE(BooleanPrefMatches(prefs::kShowHomeButton));
 444   }
 445
 446   void RunTwoClientMigrationTest(const MigrationList& migration_list,
 447                                  TriggerMethod trigger_method) {
 448     if (!ShouldRunMigrationTest()) {
 449       return;
 450     }
 451     ASSERT_TRUE(SetupSync());
 452
 453     // Make sure pref sync works before running the migration test.
 454     VerifyPrefSync();
 455
 456     RunMigrationTest(migration_list, trigger_method);
 457
 458     // Make sure pref sync still works after running the migration
 459     // test.
 460     VerifyPrefSync();
 461   }
 462
 463  private:
 464   DISALLOW_COPY_AND_ASSIGN(MigrationTwoClientTest);
 465 };
 466
 467 // Easiest possible test of migration errors: triggers a server
 468 // migration on one datatype, then modifies some other datatype.
 469 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest, MigratePrefsThenModifyBookmark) {
 470   RunTwoClientMigrationTest(MakeList(syncer::PREFERENCES),
 471                             MODIFY_BOOKMARK);
 472 }
 473
 474 // Triggers a server migration on two datatypes, then makes a local
 475 // modification to one of them.
 476 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest,
 477                        MigratePrefsAndBookmarksThenModifyBookmark) {
 478   RunTwoClientMigrationTest(
 479       MakeList(syncer::PREFERENCES, syncer::BOOKMARKS),
 480       MODIFY_BOOKMARK);
 481 }
 482
 483 // Migrate every datatype in sequence; the catch being that the server
 484 // will only tell the client about the migrations one at a time.
 485 // TODO(rsimha): This test takes longer than 60 seconds, and will cause tree
 486 // redness due to sharding.
 487 // Re-enable this test after syncer::kInitialBackoffShortRetrySeconds is reduced
 488 // to zero.
 489 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest,
 490                        DISABLED_MigrationHellWithoutNigori) {
 491   ASSERT_TRUE(SetupClients());
 492   MigrationList migration_list = GetPreferredDataTypesList();
 493   // Let the first nudge be a datatype that's neither prefs nor
 494   // bookmarks.
 495   migration_list.push_front(MakeSet(syncer::THEMES));
 496   RunTwoClientMigrationTest(migration_list, MODIFY_BOOKMARK);
 497 }
 498
 499 // See crbug.com/124480.
 500 IN_PROC_BROWSER_TEST_F(MigrationTwoClientTest,
 501                        DISABLED_MigrationHellWithNigori) {
 502   ASSERT_TRUE(SetupClients());
 503   MigrationList migration_list = GetPreferredDataTypesList();
 504   // Let the first nudge be a datatype that's neither prefs nor
 505   // bookmarks.
 506   migration_list.push_front(MakeSet(syncer::THEMES));
 507   // Pop off one so that we don't migrate all data types; the syncer
 508   // freaks out if we do that (see http://crbug.com/94882).
 509   ASSERT_GE(migration_list.size(), 2u);
 510   ASSERT_FALSE(migration_list.back().Equals(MakeSet(syncer::NIGORI)));
 511   migration_list.back() = MakeSet(syncer::NIGORI);
 512   RunTwoClientMigrationTest(migration_list, MODIFY_BOOKMARK);
 513 }
 514
 515 class MigrationReconfigureTest : public MigrationTwoClientTest {
 516  public:
 517   MigrationReconfigureTest() {}
 518
 519   virtual void SetUpCommandLine(base::CommandLine* cl) OVERRIDE {
 520     AddTestSwitches(cl);
 521     // Do not add optional datatypes.
 522   }
 523
 524   virtual ~MigrationReconfigureTest() {}
 525
 526  private:
 527   DISALLOW_COPY_AND_ASSIGN(MigrationReconfigureTest);
 528 };
 529
 530 }  // namespace