src/chrome/browser/extensions/extension_pref_value_map_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 "base/basictypes.h"
   6 #include "base/memory/ref_counted.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/prefs/pref_store_observer_mock.h"
   9 #include "base/values.h"
  10 #include "chrome/browser/extensions/extension_pref_value_map.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace {
  15 const char kExt1[] = "ext1";
  16 const char kExt2[] = "ext2";
  17 const char kExt3[] = "ext3";
  18
  19 const char kPref1[] = "path1.subpath";
  20 const char kPref2[] = "path2";
  21 const char kPref3[] = "path3";
  22 const char kPref4[] = "path4";
  23 }  // namespace
  24
  25 static Value* CreateVal(const char* str) {
  26   return new base::StringValue(str);
  27 }
  28
  29 static base::Time CreateTime(int64 t) {
  30   return base::Time::FromInternalValue(t);
  31 }
  32
  33 template <typename BASECLASS>
  34 class ExtensionPrefValueMapTestBase : public BASECLASS {
  35  public:
  36   static const extensions::ExtensionPrefsScope kRegular =
  37       extensions::kExtensionPrefsScopeRegular;
  38   static const extensions::ExtensionPrefsScope kRegularOnly =
  39       extensions::kExtensionPrefsScopeRegularOnly;
  40   static const extensions::ExtensionPrefsScope kIncognitoPersistent =
  41       extensions::kExtensionPrefsScopeIncognitoPersistent;
  42   static const extensions::ExtensionPrefsScope kIncognitoSessionOnly =
  43       extensions::kExtensionPrefsScopeIncognitoSessionOnly;
  44
  45   // Returns an empty string if the key is not set.
  46   std::string GetValue(const char * key, bool incognito) const {
  47     const Value *value = epvm_.GetEffectivePrefValue(key, incognito, NULL);
  48     std::string string_value;
  49     if (value)
  50       value->GetAsString(&string_value);
  51     return string_value;
  52   }
  53
  54  protected:
  55   ExtensionPrefValueMap epvm_;
  56 };
  57
  58 class ExtensionPrefValueMapTest
  59     : public ExtensionPrefValueMapTestBase<testing::Test> {
  60 };
  61
  62 // A gmock-ified implementation of PrefStore::Observer.
  63 class ExtensionPrefValueMapObserverMock
  64     : public ExtensionPrefValueMap::Observer {
  65  public:
  66   ExtensionPrefValueMapObserverMock() {}
  67   virtual ~ExtensionPrefValueMapObserverMock() {}
  68
  69   MOCK_METHOD1(OnPrefValueChanged, void(const std::string&));
  70   MOCK_METHOD0(OnInitializationCompleted, void());
  71   MOCK_METHOD0(OnExtensionPrefValueMapDestruction, void());
  72
  73  private:
  74   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefValueMapObserverMock);
  75 };
  76
  77 TEST_F(ExtensionPrefValueMapTest, SetAndGetPrefValue) {
  78   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
  79   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
  80   EXPECT_EQ("val1", GetValue(kPref1, false));
  81 };
  82
  83 TEST_F(ExtensionPrefValueMapTest, GetNotSetPrefValue) {
  84   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
  85   EXPECT_EQ("", GetValue(kPref1, false));
  86 };
  87
  88 // Make sure the last-installed extension wins for each preference.
  89 TEST_F(ExtensionPrefValueMapTest, Override) {
  90   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
  91   epvm_.RegisterExtension(kExt2, CreateTime(20), true);
  92   epvm_.RegisterExtension(kExt3, CreateTime(30), true);
  93
  94   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
  95   epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val2"));
  96   epvm_.SetExtensionPref(kExt3, kPref1, kRegular, CreateVal("val3"));
  97
  98   epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val4"));
  99   epvm_.SetExtensionPref(kExt2, kPref2, kRegular, CreateVal("val5"));
 100
 101   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val6"));
 102   epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val7"));
 103   epvm_.SetExtensionPref(kExt1, kPref3, kRegular, CreateVal("val8"));
 104
 105   EXPECT_EQ("val3", GetValue(kPref1, false));
 106   EXPECT_EQ("val5", GetValue(kPref2, false));
 107   EXPECT_EQ("val8", GetValue(kPref3, false));
 108 }
 109
 110 TEST_F(ExtensionPrefValueMapTest, OverrideChecks) {
 111   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 112   epvm_.RegisterExtension(kExt2, CreateTime(20), true);
 113   epvm_.RegisterExtension(kExt3, CreateTime(30), true);
 114
 115   EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt1, kPref1, NULL));
 116   EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt2, kPref1, NULL));
 117   EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt3, kPref1, NULL));
 118   EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt1, kPref1, false));
 119   EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt2, kPref1, false));
 120   EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt3, kPref1, false));
 121
 122   epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val1"));
 123
 124   EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt1, kPref1, NULL));
 125   EXPECT_TRUE(epvm_.DoesExtensionControlPref(kExt2, kPref1, NULL));
 126   EXPECT_FALSE(epvm_.DoesExtensionControlPref(kExt3, kPref1, NULL));
 127   EXPECT_FALSE(epvm_.CanExtensionControlPref(kExt1, kPref1, false));
 128   EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt2, kPref1, false));
 129   EXPECT_TRUE(epvm_.CanExtensionControlPref(kExt3, kPref1, false));
 130 }
 131
 132 TEST_F(ExtensionPrefValueMapTest, SetAndGetPrefValueIncognito) {
 133   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 134   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
 135   EXPECT_EQ("val1", GetValue(kPref1, true));
 136 }
 137
 138 TEST_F(ExtensionPrefValueMapTest, UninstallOnlyExtension) {
 139   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 140   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
 141   epvm_.UnregisterExtension(kExt1);
 142
 143   EXPECT_EQ("", GetValue(kPref1, false));
 144 }
 145
 146 // Tests uninstalling an extension that wasn't winning for any preferences.
 147 TEST_F(ExtensionPrefValueMapTest, UninstallIrrelevantExtension) {
 148   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 149   epvm_.RegisterExtension(kExt2, CreateTime(10), true);
 150
 151   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
 152   epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val2"));
 153
 154   epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val3"));
 155   epvm_.SetExtensionPref(kExt2, kPref2, kRegular, CreateVal("val4"));
 156
 157   epvm_.UnregisterExtension(kExt1);
 158
 159   EXPECT_EQ("val2", GetValue(kPref1, false));
 160   EXPECT_EQ("val4", GetValue(kPref2, false));
 161 }
 162
 163 // Tests uninstalling an extension that was winning for all preferences.
 164 TEST_F(ExtensionPrefValueMapTest, UninstallExtensionFromTop) {
 165   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 166   epvm_.RegisterExtension(kExt2, CreateTime(20), true);
 167   epvm_.RegisterExtension(kExt3, CreateTime(30), true);
 168
 169   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
 170   epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val2"));
 171   epvm_.SetExtensionPref(kExt3, kPref1, kRegular, CreateVal("val3"));
 172
 173   epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val4"));
 174   epvm_.SetExtensionPref(kExt3, kPref2, kRegular, CreateVal("val5"));
 175
 176   epvm_.UnregisterExtension(kExt3);
 177
 178   EXPECT_EQ("val2", GetValue(kPref1, false));
 179   EXPECT_EQ("val4", GetValue(kPref2, false));
 180 }
 181
 182 // Tests uninstalling an extension that was winning for only some preferences.
 183 TEST_F(ExtensionPrefValueMapTest, UninstallExtensionFromMiddle) {
 184   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 185   epvm_.RegisterExtension(kExt2, CreateTime(20), true);
 186   epvm_.RegisterExtension(kExt3, CreateTime(30), true);
 187
 188   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
 189   epvm_.SetExtensionPref(kExt2, kPref1, kRegular, CreateVal("val2"));
 190   epvm_.SetExtensionPref(kExt3, kPref1, kRegular, CreateVal("val3"));
 191
 192   epvm_.SetExtensionPref(kExt1, kPref2, kRegular, CreateVal("val4"));
 193   epvm_.SetExtensionPref(kExt2, kPref2, kRegular, CreateVal("val5"));
 194
 195   epvm_.SetExtensionPref(kExt1, kPref3, kRegular, CreateVal("val6"));
 196
 197   epvm_.SetExtensionPref(kExt2, kPref4, kRegular, CreateVal("val7"));
 198
 199   epvm_.UnregisterExtension(kExt2);
 200
 201   EXPECT_EQ("val3", GetValue(kPref1, false));
 202   EXPECT_EQ("val4", GetValue(kPref2, false));
 203   EXPECT_EQ("val6", GetValue(kPref3, false));
 204   EXPECT_EQ("", GetValue(kPref4, false));
 205 }
 206
 207 // Tests triggering of notifications to registered observers.
 208 TEST_F(ExtensionPrefValueMapTest, NotifyWhenNeeded) {
 209   using testing::Mock;
 210   using testing::StrEq;
 211
 212   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 213
 214   ExtensionPrefValueMapObserverMock observer;
 215   epvm_.AddObserver(&observer);
 216
 217   EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1)));
 218   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
 219   Mock::VerifyAndClearExpectations(&observer);
 220
 221   // Write the same value again.
 222   EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))).Times(0);
 223   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
 224   Mock::VerifyAndClearExpectations(&observer);
 225
 226   // Override incognito value.
 227   EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1)));
 228   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val2"));
 229   Mock::VerifyAndClearExpectations(&observer);
 230
 231   // Override non-incognito value.
 232   EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1)));
 233   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val3"));
 234   Mock::VerifyAndClearExpectations(&observer);
 235
 236   // Disable.
 237   EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1)));
 238   epvm_.SetExtensionState(kExt1, false);
 239   Mock::VerifyAndClearExpectations(&observer);
 240
 241   // Enable.
 242   EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1)));
 243   epvm_.SetExtensionState(kExt1, true);
 244   Mock::VerifyAndClearExpectations(&observer);
 245
 246   // Uninstall
 247   EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1)));
 248   epvm_.UnregisterExtension(kExt1);
 249   Mock::VerifyAndClearExpectations(&observer);
 250
 251   epvm_.RemoveObserver(&observer);
 252
 253   // Write new value --> no notification after removing observer.
 254   EXPECT_CALL(observer, OnPrefValueChanged(std::string(kPref1))).Times(0);
 255   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 256   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val4"));
 257   Mock::VerifyAndClearExpectations(&observer);
 258 }
 259
 260 // Tests disabling an extension.
 261 TEST_F(ExtensionPrefValueMapTest, DisableExt) {
 262   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 263
 264   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
 265   epvm_.SetExtensionState(kExt1, false);
 266   EXPECT_EQ("", GetValue(kPref1, false));
 267 }
 268
 269 // Tests disabling and reenabling an extension.
 270 TEST_F(ExtensionPrefValueMapTest, ReenableExt) {
 271   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 272
 273   epvm_.SetExtensionPref(kExt1, kPref1, kRegular, CreateVal("val1"));
 274   epvm_.SetExtensionState(kExt1, false);
 275   epvm_.SetExtensionState(kExt1, true);
 276   EXPECT_EQ("val1", GetValue(kPref1, false));
 277 }
 278
 279 struct OverrideIncognitoTestCase {
 280   OverrideIncognitoTestCase(int val_ext1_regular,
 281                             int val_ext1_regular_only,
 282                             int val_ext1_incognito_pers,
 283                             int val_ext1_incognito_sess,
 284                             int val_ext2_regular,
 285                             int val_ext2_regular_only,
 286                             int val_ext2_incognito_pers,
 287                             int val_ext2_incognito_sess,
 288                             int effective_value_regular,
 289                             int effective_value_incognito)
 290       : val_ext1_regular_(val_ext1_regular),
 291         val_ext1_regular_only_(val_ext1_regular_only),
 292         val_ext1_incognito_pers_(val_ext1_incognito_pers),
 293         val_ext1_incognito_sess_(val_ext1_incognito_sess),
 294         val_ext2_regular_(val_ext2_regular),
 295         val_ext2_regular_only_(val_ext2_regular_only),
 296         val_ext2_incognito_pers_(val_ext2_incognito_pers),
 297         val_ext2_incognito_sess_(val_ext2_incognito_sess),
 298         effective_value_regular_(effective_value_regular),
 299         effective_value_incognito_(effective_value_incognito) {}
 300
 301   // pers. = persistent
 302   // sess. = session only
 303   int val_ext1_regular_;           // pref value of extension 1
 304   int val_ext1_regular_only_;      // pref value of extension 1 regular-only.
 305   int val_ext1_incognito_pers_;    // pref value of extension 1 incognito pers.
 306   int val_ext1_incognito_sess_;    // pref value of extension 1 incognito sess.
 307   int val_ext2_regular_;           // pref value of extension 2
 308   int val_ext2_regular_only_;      // pref value of extension 2 regular-only.
 309   int val_ext2_incognito_pers_;    // pref value of extension 2 incognito pers.
 310   int val_ext2_incognito_sess_;    // pref value of extension 2 incognito sess.
 311   int effective_value_regular_;    // desired winner regular
 312   int effective_value_incognito_;  // desired winner incognito
 313 };
 314
 315 class ExtensionPrefValueMapTestIncognitoTests
 316     : public ExtensionPrefValueMapTestBase<
 317           testing::TestWithParam<OverrideIncognitoTestCase> > {
 318 };
 319
 320 TEST_P(ExtensionPrefValueMapTestIncognitoTests, OverrideIncognito) {
 321   OverrideIncognitoTestCase test = GetParam();
 322   const char* strings[] = {
 323       "undefined",
 324       "val1",
 325       "val2",
 326       "val3",
 327       "val4",
 328       "val5",
 329       "val6",
 330       "val7",
 331       "val8",
 332   };
 333
 334   epvm_.RegisterExtension(kExt1, CreateTime(10), true);
 335   epvm_.RegisterExtension(kExt2, CreateTime(20), true);
 336   if (test.val_ext1_regular_) {
 337     epvm_.SetExtensionPref(kExt1, kPref1, kRegular,
 338                            CreateVal(strings[test.val_ext1_regular_]));
 339   }
 340   if (test.val_ext1_regular_only_) {
 341     epvm_.SetExtensionPref(kExt1, kPref1, kRegularOnly,
 342                            CreateVal(strings[test.val_ext1_regular_only_]));
 343   }
 344   if (test.val_ext1_incognito_pers_) {
 345     epvm_.SetExtensionPref(kExt1, kPref1, kIncognitoPersistent,
 346                            CreateVal(strings[test.val_ext1_incognito_pers_]));
 347   }
 348   if (test.val_ext1_incognito_sess_) {
 349     epvm_.SetExtensionPref(kExt1, kPref1, kIncognitoSessionOnly,
 350                            CreateVal(strings[test.val_ext1_incognito_sess_]));
 351   }
 352   if (test.val_ext2_regular_) {
 353     epvm_.SetExtensionPref(kExt2, kPref1, kRegular,
 354                            CreateVal(strings[test.val_ext2_regular_]));
 355   }
 356   if (test.val_ext2_regular_only_) {
 357     epvm_.SetExtensionPref(kExt2, kPref1, kRegularOnly,
 358                            CreateVal(strings[test.val_ext2_regular_only_]));
 359   }
 360   if (test.val_ext2_incognito_pers_) {
 361     epvm_.SetExtensionPref(kExt2, kPref1, kIncognitoPersistent,
 362                            CreateVal(strings[test.val_ext2_incognito_pers_]));
 363   }
 364   if (test.val_ext2_incognito_sess_) {
 365     epvm_.SetExtensionPref(kExt2, kPref1, kIncognitoSessionOnly,
 366                            CreateVal(strings[test.val_ext2_incognito_sess_]));
 367   }
 368   std::string actual;
 369   EXPECT_EQ(strings[test.effective_value_regular_], GetValue(kPref1, false));
 370   EXPECT_EQ(strings[test.effective_value_incognito_], GetValue(kPref1, true));
 371   epvm_.UnregisterExtension(kExt1);
 372   epvm_.UnregisterExtension(kExt2);
 373 }
 374
 375 INSTANTIATE_TEST_CASE_P(
 376     ExtensionPrefValueMapTestIncognitoTestsInstance,
 377     ExtensionPrefValueMapTestIncognitoTests,
 378     testing::Values(
 379         // e.g. (1, 0, 0, 0,  0, 0, 7, 0,  1, 7), means:
 380         // ext1 regular is set to "val1", ext2 incognito persistent is set to
 381         // "val7"
 382         // --> the winning regular value is "val1", the winning incognito
 383         //     value is "val7".
 384         OverrideIncognitoTestCase(1, 0, 0, 0,  0, 0, 0, 0,  1, 1),
 385         OverrideIncognitoTestCase(1, 2, 0, 0,  0, 0, 0, 0,  2, 1),
 386         OverrideIncognitoTestCase(1, 0, 3, 0,  0, 0, 0, 0,  1, 3),
 387         OverrideIncognitoTestCase(1, 0, 0, 4,  0, 0, 0, 0,  1, 4),
 388         OverrideIncognitoTestCase(1, 0, 3, 4,  0, 0, 0, 0,  1, 4),
 389         OverrideIncognitoTestCase(1, 2, 3, 0,  0, 0, 0, 0,  2, 3),
 390         OverrideIncognitoTestCase(1, 0, 0, 0,  5, 0, 0, 0,  5, 5),
 391         OverrideIncognitoTestCase(1, 2, 3, 0,  5, 0, 0, 0,  5, 5),
 392         OverrideIncognitoTestCase(1, 0, 0, 0,  0, 6, 0, 0,  6, 1),
 393         OverrideIncognitoTestCase(1, 0, 3, 0,  5, 6, 0, 0,  6, 5),
 394         OverrideIncognitoTestCase(1, 0, 0, 4,  5, 6, 0, 0,  6, 5),
 395         OverrideIncognitoTestCase(1, 0, 0, 0,  0, 0, 7, 0,  1, 7),
 396         OverrideIncognitoTestCase(1, 2, 0, 0,  5, 0, 7, 0,  5, 7),
 397         OverrideIncognitoTestCase(1, 2, 0, 0,  5, 0, 0, 8,  5, 8),
 398         OverrideIncognitoTestCase(1, 2, 0, 0,  5, 0, 7, 8,  5, 8),
 399         OverrideIncognitoTestCase(1, 2, 3, 0,  0, 6, 7, 0,  6, 7)));