chrome/browser/sync/glue/synced_device_tracker_unittest.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 <string>
   6
   7 #include "base/guid.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/memory/scoped_vector.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/run_loop.h"
  12 #include "chrome/browser/sync/glue/device_info.h"
  13 #include "chrome/browser/sync/glue/synced_device_tracker.h"
  14 #include "sync/internal_api/public/base/model_type.h"
  15 #include "sync/internal_api/public/test/test_user_share.h"
  16 #include "sync/protocol/sync.pb.h"
  17 #include "sync/syncable/directory.h"
  18 #include "sync/test/test_transaction_observer.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 namespace browser_sync {
  22
  23 namespace {
  24
  25 void ConvertDeviceInfoSpecifics(
  26     const DeviceInfo& device_info,
  27     sync_pb::DeviceInfoSpecifics* specifics) {
  28   specifics->set_cache_guid(device_info.guid());
  29   specifics->set_client_name(device_info.client_name());
  30   specifics->set_chrome_version(device_info.chrome_version());
  31   specifics->set_sync_user_agent(device_info.sync_user_agent());
  32   specifics->set_device_type(device_info.device_type());
  33 }
  34
  35 }  // namespace
  36
  37 class SyncedDeviceTrackerTest : public ::testing::Test {
  38  protected:
  39   SyncedDeviceTrackerTest() : transaction_count_baseline_(0) { }
  40   virtual ~SyncedDeviceTrackerTest() { }
  41
  42   virtual void SetUp() {
  43     test_user_share_.SetUp();
  44     syncer::TestUserShare::CreateRoot(syncer::DEVICE_INFO, user_share());
  45
  46     synced_device_tracker_.reset(
  47         new SyncedDeviceTracker(user_share(),
  48                                 user_share()->directory->cache_guid()));
  49
  50     // We don't actually touch the Profile, so we can get away with passing in a
  51     // NULL here.  Constructing a TestingProfile can take over a 100ms, so this
  52     // optimization can be the difference between 'tests run with a noticeable
  53     // delay' and 'tests run instantaneously'.
  54     synced_device_tracker_->Start(NULL, user_share());
  55   }
  56
  57   virtual void TearDown() {
  58     synced_device_tracker_.reset();
  59     test_user_share_.TearDown();
  60   }
  61
  62   syncer::UserShare* user_share() {
  63     return test_user_share_.user_share();
  64   }
  65
  66   // Expose the private method to our tests.
  67   void WriteLocalDeviceInfo(const DeviceInfo& info) {
  68     synced_device_tracker_->WriteLocalDeviceInfo(info);
  69   }
  70
  71   void WriteDeviceInfo(const DeviceInfo& device_info) {
  72     sync_pb::DeviceInfoSpecifics specifics;
  73     ConvertDeviceInfoSpecifics(device_info, &specifics);
  74     synced_device_tracker_->WriteDeviceInfo(specifics, device_info.guid());
  75   }
  76
  77   void ResetObservedChangesCounter() {
  78     transaction_count_baseline_ = GetTotalTransactionsCount();
  79   }
  80
  81   int GetObservedChangesCounter() {
  82     return GetTotalTransactionsCount() - transaction_count_baseline_;
  83   }
  84
  85   scoped_ptr<SyncedDeviceTracker> synced_device_tracker_;
  86
  87  private:
  88   // Count of how many closed WriteTransactions notified of meaningful changes.
  89   int GetTotalTransactionsCount() {
  90     base::RunLoop run_loop;
  91     run_loop.RunUntilIdle();
  92     return test_user_share_.transaction_observer()->transactions_observed();
  93   }
  94
  95   base::MessageLoop message_loop_;
  96   syncer::TestUserShare test_user_share_;
  97   int transaction_count_baseline_;
  98 };
  99
 100 namespace {
 101
 102 // New client scenario: set device info when no previous info existed.
 103 TEST_F(SyncedDeviceTrackerTest, CreateNewDeviceInfo) {
 104   ASSERT_FALSE(synced_device_tracker_->ReadLocalDeviceInfo());
 105
 106   ResetObservedChangesCounter();
 107
 108   // Include the non-ASCII character "’" (typographic apostrophe) in the client
 109   // name to ensure that SyncedDeviceTracker can properly handle non-ASCII
 110   // characters, which client names can include on some platforms (e.g., Mac
 111   // and iOS).
 112   DeviceInfo write_device_info(
 113       user_share()->directory->cache_guid(),
 114       "John’s Device", "Chromium 3000", "ChromeSyncAgent 3000",
 115       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
 116   WriteLocalDeviceInfo(write_device_info);
 117
 118   scoped_ptr<DeviceInfo> read_device_info(
 119       synced_device_tracker_->ReadLocalDeviceInfo());
 120   ASSERT_TRUE(read_device_info);
 121   EXPECT_TRUE(write_device_info.Equals(*read_device_info.get()));
 122
 123   EXPECT_EQ(1, GetObservedChangesCounter());
 124 }
 125
 126 // Restart scenario: update existing device info with identical data.
 127 TEST_F(SyncedDeviceTrackerTest, DontModifyExistingDeviceInfo) {
 128   // For writing.
 129   DeviceInfo device_info(
 130       user_share()->directory->cache_guid(),
 131       "John’s Device", "XYZ v1", "XYZ SyncAgent v1",
 132       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
 133   WriteLocalDeviceInfo(device_info);
 134
 135   // First read.
 136   scoped_ptr<DeviceInfo> old_device_info(
 137       synced_device_tracker_->ReadLocalDeviceInfo());
 138   ASSERT_TRUE(old_device_info);
 139
 140   ResetObservedChangesCounter();
 141
 142   // Overwrite the device info with the same data as before.
 143   WriteLocalDeviceInfo(device_info);
 144
 145   // Ensure that this didn't count as a change worth syncing.
 146   EXPECT_EQ(0, GetObservedChangesCounter());
 147
 148   // Second read.
 149   scoped_ptr<DeviceInfo> new_device_info(
 150       synced_device_tracker_->ReadLocalDeviceInfo());
 151   ASSERT_TRUE(new_device_info);
 152   EXPECT_TRUE(old_device_info->Equals(*new_device_info.get()));
 153 }
 154
 155 // Upgrade scenario: update existing device info with new version.
 156 TEST_F(SyncedDeviceTrackerTest, UpdateExistingDeviceInfo) {
 157   // Write v1 device info.
 158   DeviceInfo device_info_v1(
 159       user_share()->directory->cache_guid(),
 160       "John’s Device", "XYZ v1", "XYZ SyncAgent v1",
 161       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
 162   WriteLocalDeviceInfo(device_info_v1);
 163
 164   ResetObservedChangesCounter();
 165
 166   // Write upgraded device info.
 167   DeviceInfo device_info_v2(
 168       user_share()->directory->cache_guid(),
 169       "John’s Device", "XYZ v2", "XYZ SyncAgent v2",
 170       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
 171   WriteLocalDeviceInfo(device_info_v2);
 172
 173   // Verify result.
 174   scoped_ptr<DeviceInfo> result_device_info(
 175       synced_device_tracker_->ReadLocalDeviceInfo());
 176   ASSERT_TRUE(result_device_info);
 177
 178   EXPECT_TRUE(result_device_info->Equals(device_info_v2));
 179
 180   // The update write should have sent a nudge.
 181   EXPECT_EQ(1, GetObservedChangesCounter());
 182 }
 183
 184 // Test retrieving DeviceInfos for all the syncing devices.
 185 TEST_F(SyncedDeviceTrackerTest, GetAllDeviceInfo) {
 186   DeviceInfo device_info1(
 187       base::GenerateGUID(),
 188       "abc Device", "XYZ v1", "XYZ SyncAgent v1",
 189       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
 190
 191   std::string guid1 = base::GenerateGUID();
 192
 193   DeviceInfo device_info2(
 194       base::GenerateGUID(),
 195       "def Device", "XYZ v2", "XYZ SyncAgent v2",
 196       sync_pb::SyncEnums_DeviceType_TYPE_LINUX);
 197
 198   std::string guid2 = base::GenerateGUID();
 199
 200   WriteDeviceInfo(device_info1);
 201   WriteDeviceInfo(device_info2);
 202
 203   ScopedVector<DeviceInfo> device_info;
 204   synced_device_tracker_->GetAllSyncedDeviceInfo(&device_info);
 205
 206   EXPECT_EQ(device_info.size(), 2U);
 207   EXPECT_TRUE(device_info[0]->Equals(device_info1));
 208   EXPECT_TRUE(device_info[1]->Equals(device_info2));
 209 }
 210
 211 }  // namespace
 212
 213 }  // namespace browser_sync