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

   1 // Copyright (c) 2011 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/string_number_conversions.h"
   6 #include "chrome/browser/sync/test/integration/dictionary_helper.h"
   7 #include "chrome/browser/sync/test/integration/profile_sync_service_harness.h"
   8 #include "chrome/browser/sync/test/integration/sync_test.h"
   9 #include "chrome/common/spellcheck_common.h"
  10
  11 using dictionary_helper::AwaitNumDictionaryEntries;
  12 using chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
  13
  14 class MultipleClientDictionarySyncTest : public SyncTest {
  15  public:
  16   MultipleClientDictionarySyncTest() : SyncTest(MULTIPLE_CLIENT) {}
  17   virtual ~MultipleClientDictionarySyncTest() {}
  18
  19   virtual bool TestUsesSelfNotifications() OVERRIDE { return false; }
  20
  21  private:
  22   DISALLOW_COPY_AND_ASSIGN(MultipleClientDictionarySyncTest);
  23 };
  24
  25 IN_PROC_BROWSER_TEST_F(MultipleClientDictionarySyncTest, AddToOne) {
  26   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
  27   dictionary_helper::LoadDictionaries();
  28   ASSERT_TRUE(dictionary_helper::AwaitDictionariesMatch());
  29
  30   ASSERT_TRUE(dictionary_helper::AddWord(0, "foo"));
  31   ASSERT_TRUE(dictionary_helper::AwaitDictionariesMatch());
  32 }
  33
  34 IN_PROC_BROWSER_TEST_F(MultipleClientDictionarySyncTest, AddSameToAll) {
  35   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
  36   dictionary_helper::LoadDictionaries();
  37   ASSERT_TRUE(dictionary_helper::AwaitDictionariesMatch());
  38
  39   for (int i = 0; i < num_clients(); ++i)
  40     dictionary_helper::AddWord(i, "foo");
  41   ASSERT_TRUE(dictionary_helper::AwaitDictionariesMatch());
  42   ASSERT_EQ(1UL, dictionary_helper::GetDictionarySize(0));
  43 }
  44
  45 IN_PROC_BROWSER_TEST_F(MultipleClientDictionarySyncTest, AddDifferentToAll) {
  46   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
  47   dictionary_helper::LoadDictionaries();
  48   ASSERT_TRUE(dictionary_helper::AwaitDictionariesMatch());
  49
  50   for (int i = 0; i < num_clients(); ++i)
  51     dictionary_helper::AddWord(i, "foo" + base::IntToString(i));
  52   ASSERT_TRUE(dictionary_helper::AwaitDictionariesMatch());
  53   ASSERT_EQ(num_clients(),
  54             static_cast<int>(dictionary_helper::GetDictionarySize(0)));
  55 }
  56
  57 // Tests the case where the Nth client pushes the server beyond its
  58 // MAX_SYNCABLE_DICTIONARY_WORDS limit.
  59 IN_PROC_BROWSER_TEST_F(MultipleClientDictionarySyncTest, Limit) {
  60   ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
  61   dictionary_helper::LoadDictionaries();
  62   ASSERT_TRUE(dictionary_helper::AwaitDictionariesMatch());
  63
  64   const int n = num_clients();
  65
  66   // Pick a number of initial words per client such that
  67   // (num-clients()-1) * initial_words
  68   //     < MAX_SYNCABLE_DICTIONARY_WORDS
  69   //     < num_clients() * initial_words
  70   size_t initial_words =
  71       (MAX_SYNCABLE_DICTIONARY_WORDS + n) / n;
  72
  73   // Add |initial_words| words to each of the clients before sync.
  74   for (int i = 0; i < n; ++i) {
  75     GetClient(i)->DisableSyncForAllDatatypes();
  76     for (size_t j = 0; j < initial_words; ++j) {
  77       ASSERT_TRUE(dictionary_helper::AddWord(
  78           i, "foo-" + base::IntToString(i) + "-" + base::Uint64ToString(j)));
  79     }
  80     ASSERT_EQ(initial_words, dictionary_helper::GetDictionarySize(i));
  81   }
  82
  83   // As long as we don't get involved in any race conditions where two clients
  84   // are committing at once, we should be able to guarantee that the server has
  85   // at most MAX_SYNCABLE_DICTIONARY_WORDS words.  Every client will be able to
  86   // sync these items.  Clients are allowed to have more words if they're
  87   // available locally, but they won't be able to commit any words once the
  88   // server is full.
  89   //
  90   // As we enable clients one-by-one, all but the (N-1)th client should be able
  91   // to commit all of their items.  The last one will have some local data left
  92   // over.
  93
  94   // Open the floodgates.   Allow N-1 clients to sync their items.
  95   for (int i = 0; i < n-1; ++i) {
  96     SCOPED_TRACE(i);
  97
  98     // Client #i has |initial_words| words before sync.
  99     ASSERT_EQ(initial_words, dictionary_helper::GetDictionarySize(i));
 100     ASSERT_TRUE(GetClient(i)->EnableSyncForAllDatatypes());
 101   }
 102
 103   // Wait for clients to catch up.  All should be in sync with the server
 104   // and have exactly (initial_words * (N-1)) words in their dictionaries.
 105   for (int i = 0; i < n-1; ++i) {
 106     SCOPED_TRACE(i);
 107     ASSERT_TRUE(AwaitNumDictionaryEntries(i, initial_words*(n-1)));
 108   }
 109
 110   // Add the client that has engough new words to cause an overflow.
 111   ASSERT_EQ(initial_words, dictionary_helper::GetDictionarySize(n-1));
 112   ASSERT_TRUE(GetClient(n-1)->EnableSyncForAllDatatypes());
 113
 114   // The Nth client will receive the initial_words * (n-1) entries that were on
 115   // the server.  It will commit some of the entries it had locally.  And it
 116   // will have a few uncommittable items left over.
 117   ASSERT_TRUE(AwaitNumDictionaryEntries(n-1, initial_words*n));
 118
 119   // Everyone else should be at the limit.
 120   for (int i = 0; i < n-1; ++i) {
 121     SCOPED_TRACE(i);
 122     ASSERT_TRUE(AwaitNumDictionaryEntries(i, MAX_SYNCABLE_DICTIONARY_WORDS));
 123   }
 124 }