Home | History | Annotate | Download | only in sync 
      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 "chrome/browser/sync/sync_prefs.h"
      6 
      7 #include "base/command_line.h"
      8 #include "base/message_loop/message_loop.h"
      9 #include "base/time/time.h"
     10 #include "chrome/common/chrome_switches.h"
     11 #include "chrome/common/pref_names.h"
     12 #include "chrome/test/base/testing_pref_service_syncable.h"
     13 #include "sync/internal_api/public/base/model_type.h"
     14 #include "testing/gmock/include/gmock/gmock.h"
     15 #include "testing/gtest/include/gtest/gtest.h"
     16 
     17 namespace browser_sync {
     18 
     19 namespace {
     20 
     21 using ::testing::InSequence;
     22 using ::testing::StrictMock;
     23 
     24 class SyncPrefsTest : public testing::Test {
     25  protected:
     26   virtual void SetUp() OVERRIDE {
     27     SyncPrefs::RegisterProfilePrefs(pref_service_.registry());
     28   }
     29 
     30   TestingPrefServiceSyncable pref_service_;
     31 
     32  private:
     33   base::MessageLoop loop_;
     34 };
     35 
     36 TEST_F(SyncPrefsTest, Basic) {
     37   SyncPrefs sync_prefs(&pref_service_);
     38 
     39   EXPECT_FALSE(sync_prefs.HasSyncSetupCompleted());
     40   sync_prefs.SetSyncSetupCompleted();
     41   EXPECT_TRUE(sync_prefs.HasSyncSetupCompleted());
     42 
     43   EXPECT_FALSE(sync_prefs.IsStartSuppressed());
     44   sync_prefs.SetStartSuppressed(true);
     45   EXPECT_TRUE(sync_prefs.IsStartSuppressed());
     46   sync_prefs.SetStartSuppressed(false);
     47   EXPECT_FALSE(sync_prefs.IsStartSuppressed());
     48 
     49   EXPECT_EQ(base::Time(), sync_prefs.GetLastSyncedTime());
     50   const base::Time& now = base::Time::Now();
     51   sync_prefs.SetLastSyncedTime(now);
     52   EXPECT_EQ(now, sync_prefs.GetLastSyncedTime());
     53 
     54   EXPECT_TRUE(sync_prefs.HasKeepEverythingSynced());
     55   sync_prefs.SetKeepEverythingSynced(false);
     56   EXPECT_FALSE(sync_prefs.HasKeepEverythingSynced());
     57   sync_prefs.SetKeepEverythingSynced(true);
     58   EXPECT_TRUE(sync_prefs.HasKeepEverythingSynced());
     59 
     60   EXPECT_TRUE(sync_prefs.GetEncryptionBootstrapToken().empty());
     61   sync_prefs.SetEncryptionBootstrapToken("token");
     62   EXPECT_EQ("token", sync_prefs.GetEncryptionBootstrapToken());
     63 }
     64 
     65 TEST_F(SyncPrefsTest, DefaultTypes) {
     66   SyncPrefs sync_prefs(&pref_service_);
     67   sync_prefs.SetKeepEverythingSynced(false);
     68 
     69   // Only bookmarks are enabled by default.
     70   syncer::ModelTypeSet preferred_types = sync_prefs.GetPreferredDataTypes(
     71       syncer::UserTypes());
     72   EXPECT_TRUE(preferred_types.Equals(syncer::ModelTypeSet(syncer::BOOKMARKS)));
     73 
     74   // Simulate an upgrade to delete directives + proxy tabs support. None of the
     75   // new types or their pref group types should be registering, ensuring they
     76   // don't have pref values.
     77   syncer::ModelTypeSet registered_types = syncer::UserTypes();
     78   registered_types.Remove(syncer::PROXY_TABS);
     79   registered_types.Remove(syncer::TYPED_URLS);
     80   registered_types.Remove(syncer::SESSIONS);
     81   registered_types.Remove(syncer::HISTORY_DELETE_DIRECTIVES);
     82 
     83   // Enable all other types.
     84   sync_prefs.SetPreferredDataTypes(registered_types,
     85                                    registered_types);
     86 
     87   // Manually enable typed urls (to simulate the old world).
     88   pref_service_.SetBoolean(prefs::kSyncTypedUrls, true);
     89 
     90   // Proxy tabs should not be enabled (since sessions wasn't), but history
     91   // delete directives should (since typed urls was).
     92   preferred_types =
     93       sync_prefs.GetPreferredDataTypes(syncer::UserTypes());
     94   EXPECT_FALSE(preferred_types.Has(syncer::PROXY_TABS));
     95   EXPECT_TRUE(preferred_types.Has(syncer::HISTORY_DELETE_DIRECTIVES));
     96 
     97   // Now manually enable sessions, which should result in proxy tabs also being
     98   // enabled. Also, manually disable typed urls, which should mean that history
     99   // delete directives are not enabled.
    100   pref_service_.SetBoolean(prefs::kSyncTypedUrls, false);
    101   pref_service_.SetBoolean(prefs::kSyncSessions, true);
    102   preferred_types =
    103       sync_prefs.GetPreferredDataTypes(syncer::UserTypes());
    104   EXPECT_TRUE(preferred_types.Has(syncer::PROXY_TABS));
    105   EXPECT_FALSE(preferred_types.Has(syncer::HISTORY_DELETE_DIRECTIVES));
    106 }
    107 
    108 TEST_F(SyncPrefsTest, PreferredTypesKeepEverythingSynced) {
    109   SyncPrefs sync_prefs(&pref_service_);
    110 
    111   EXPECT_TRUE(sync_prefs.HasKeepEverythingSynced());
    112 
    113   const syncer::ModelTypeSet user_types = syncer::UserTypes();
    114   EXPECT_TRUE(user_types.Equals(
    115       sync_prefs.GetPreferredDataTypes(user_types)));
    116   const syncer::ModelTypeSet user_visible_types = syncer::UserSelectableTypes();
    117   for (syncer::ModelTypeSet::Iterator it = user_visible_types.First();
    118        it.Good(); it.Inc()) {
    119     syncer::ModelTypeSet preferred_types;
    120     preferred_types.Put(it.Get());
    121     sync_prefs.SetPreferredDataTypes(user_types, preferred_types);
    122     EXPECT_TRUE(user_types.Equals(
    123         sync_prefs.GetPreferredDataTypes(user_types)));
    124   }
    125 }
    126 
    127 TEST_F(SyncPrefsTest, PreferredTypesNotKeepEverythingSynced) {
    128   SyncPrefs sync_prefs(&pref_service_);
    129 
    130   sync_prefs.SetKeepEverythingSynced(false);
    131 
    132   const syncer::ModelTypeSet user_types = syncer::UserTypes();
    133   EXPECT_FALSE(user_types.Equals(
    134       sync_prefs.GetPreferredDataTypes(user_types)));
    135   const syncer::ModelTypeSet user_visible_types = syncer::UserSelectableTypes();
    136   for (syncer::ModelTypeSet::Iterator it = user_visible_types.First();
    137        it.Good(); it.Inc()) {
    138     syncer::ModelTypeSet preferred_types;
    139     preferred_types.Put(it.Get());
    140     syncer::ModelTypeSet expected_preferred_types(preferred_types);
    141     if (it.Get() == syncer::AUTOFILL) {
    142       expected_preferred_types.Put(syncer::AUTOFILL_PROFILE);
    143     }
    144     if (it.Get() == syncer::PREFERENCES) {
    145       expected_preferred_types.Put(syncer::DICTIONARY);
    146       expected_preferred_types.Put(syncer::PRIORITY_PREFERENCES);
    147       expected_preferred_types.Put(syncer::SEARCH_ENGINES);
    148     }
    149     if (it.Get() == syncer::APPS) {
    150       expected_preferred_types.Put(syncer::APP_NOTIFICATIONS);
    151       expected_preferred_types.Put(syncer::APP_SETTINGS);
    152     }
    153     if (it.Get() == syncer::EXTENSIONS) {
    154       expected_preferred_types.Put(syncer::EXTENSION_SETTINGS);
    155     }
    156     if (it.Get() == syncer::TYPED_URLS) {
    157       expected_preferred_types.Put(syncer::HISTORY_DELETE_DIRECTIVES);
    158       expected_preferred_types.Put(syncer::SESSIONS);
    159       expected_preferred_types.Put(syncer::FAVICON_IMAGES);
    160       expected_preferred_types.Put(syncer::FAVICON_TRACKING);
    161     }
    162     if (it.Get() == syncer::PROXY_TABS) {
    163       expected_preferred_types.Put(syncer::SESSIONS);
    164       expected_preferred_types.Put(syncer::FAVICON_IMAGES);
    165       expected_preferred_types.Put(syncer::FAVICON_TRACKING);
    166     }
    167     sync_prefs.SetPreferredDataTypes(user_types, preferred_types);
    168     EXPECT_TRUE(expected_preferred_types.Equals(
    169         sync_prefs.GetPreferredDataTypes(user_types)));
    170   }
    171 }
    172 
    173 class MockSyncPrefObserver : public SyncPrefObserver {
    174  public:
    175   MOCK_METHOD1(OnSyncManagedPrefChange, void(bool));
    176 };
    177 
    178 TEST_F(SyncPrefsTest, ObservedPrefs) {
    179   SyncPrefs sync_prefs(&pref_service_);
    180 
    181   StrictMock<MockSyncPrefObserver> mock_sync_pref_observer;
    182   InSequence dummy;
    183   EXPECT_CALL(mock_sync_pref_observer, OnSyncManagedPrefChange(true));
    184   EXPECT_CALL(mock_sync_pref_observer, OnSyncManagedPrefChange(false));
    185 
    186   EXPECT_FALSE(sync_prefs.IsManaged());
    187 
    188   sync_prefs.AddSyncPrefObserver(&mock_sync_pref_observer);
    189 
    190   sync_prefs.SetManagedForTest(true);
    191   EXPECT_TRUE(sync_prefs.IsManaged());
    192   sync_prefs.SetManagedForTest(false);
    193   EXPECT_FALSE(sync_prefs.IsManaged());
    194 
    195   sync_prefs.RemoveSyncPrefObserver(&mock_sync_pref_observer);
    196 }
    197 
    198 TEST_F(SyncPrefsTest, AcknowledgeSyncedTypes) {
    199   SyncPrefs sync_prefs(&pref_service_);
    200 
    201   syncer::ModelTypeSet expected_acknowledge_synced_types =
    202       sync_prefs.GetAcknowledgeSyncedTypesForTest();
    203   for (int i = syncer::EXTENSION_SETTINGS; i < syncer::MODEL_TYPE_COUNT; ++i) {
    204     const syncer::ModelType type = syncer::ModelTypeFromInt(i);
    205     syncer::ModelTypeSet acknowledge_synced_types(type);
    206     expected_acknowledge_synced_types.Put(type);
    207     sync_prefs.AcknowledgeSyncedTypes(acknowledge_synced_types);
    208     EXPECT_TRUE(expected_acknowledge_synced_types.Equals(
    209         sync_prefs.GetAcknowledgeSyncedTypesForTest()));
    210   }
    211 }
    212 
    213 TEST_F(SyncPrefsTest, ClearPreferences) {
    214   SyncPrefs sync_prefs(&pref_service_);
    215 
    216   EXPECT_FALSE(sync_prefs.HasSyncSetupCompleted());
    217   EXPECT_EQ(base::Time(), sync_prefs.GetLastSyncedTime());
    218   EXPECT_TRUE(sync_prefs.GetEncryptionBootstrapToken().empty());
    219 
    220   sync_prefs.SetSyncSetupCompleted();
    221   sync_prefs.SetLastSyncedTime(base::Time::Now());
    222   sync_prefs.SetEncryptionBootstrapToken("token");
    223 
    224   EXPECT_TRUE(sync_prefs.HasSyncSetupCompleted());
    225   EXPECT_NE(base::Time(), sync_prefs.GetLastSyncedTime());
    226   EXPECT_EQ("token", sync_prefs.GetEncryptionBootstrapToken());
    227 
    228   sync_prefs.ClearPreferences();
    229 
    230   EXPECT_FALSE(sync_prefs.HasSyncSetupCompleted());
    231   EXPECT_EQ(base::Time(), sync_prefs.GetLastSyncedTime());
    232   EXPECT_TRUE(sync_prefs.GetEncryptionBootstrapToken().empty());
    233 }
    234 
    235 TEST_F(SyncPrefsTest, NullPrefService) {
    236   SyncPrefs sync_prefs(NULL);
    237 
    238   EXPECT_FALSE(sync_prefs.HasSyncSetupCompleted());
    239   EXPECT_FALSE(sync_prefs.IsStartSuppressed());
    240   EXPECT_EQ(base::Time(), sync_prefs.GetLastSyncedTime());
    241   EXPECT_FALSE(sync_prefs.HasKeepEverythingSynced());
    242   const syncer::ModelTypeSet user_types = syncer::UserTypes();
    243   EXPECT_TRUE(sync_prefs.GetPreferredDataTypes(user_types).Empty());
    244   EXPECT_FALSE(sync_prefs.IsManaged());
    245   EXPECT_TRUE(sync_prefs.GetEncryptionBootstrapToken().empty());
    246 }
    247 
    248 }  // namespace
    249 
    250 }  // namespace browser_sync
    251