chrome/browser/extensions/api/storage/policy_value_store_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 "chrome/browser/extensions/api/storage/policy_value_store.h"
   6
   7 #include "base/callback.h"
   8 #include "base/files/file_path.h"
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "components/policy/core/common/external_data_fetcher.h"
  14 #include "components/policy/core/common/policy_map.h"
  15 #include "content/public/test/test_browser_thread.h"
  16 #include "extensions/browser/api/storage/settings_observer.h"
  17 #include "extensions/browser/value_store/leveldb_value_store.h"
  18 #include "extensions/browser/value_store/value_store_unittest.h"
  19 #include "testing/gmock/include/gmock/gmock.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 using testing::_;
  23 using testing::Mock;
  24
  25 namespace extensions {
  26
  27 namespace {
  28
  29 const char kTestExtensionId[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
  30
  31 class MockSettingsObserver : public SettingsObserver {
  32  public:
  33   MOCK_METHOD3(OnSettingsChanged, void(
  34       const std::string& extension_id,
  35       settings_namespace::Namespace settings_namespace,
  36       const std::string& changes_json));
  37 };
  38
  39 // Extends PolicyValueStore by overriding the mutating methods, so that the
  40 // Get() base implementation can be tested with the ValueStoreTest parameterized
  41 // tests.
  42 class MutablePolicyValueStore : public PolicyValueStore {
  43  public:
  44   explicit MutablePolicyValueStore(const base::FilePath& path)
  45       : PolicyValueStore(kTestExtensionId,
  46                          make_scoped_refptr(new SettingsObserverList()),
  47                          scoped_ptr<ValueStore>(new LeveldbValueStore(path))) {}
  48   virtual ~MutablePolicyValueStore() {}
  49
  50   virtual WriteResult Set(
  51       WriteOptions options,
  52       const std::string& key,
  53       const base::Value& value) OVERRIDE {
  54     return delegate()->Set(options, key, value);
  55   }
  56
  57   virtual WriteResult Set(
  58       WriteOptions options, const base::DictionaryValue& values) OVERRIDE {
  59     return delegate()->Set(options, values);
  60   }
  61
  62   virtual WriteResult Remove(const std::string& key) OVERRIDE {
  63     return delegate()->Remove(key);
  64   }
  65
  66   virtual WriteResult Remove(const std::vector<std::string>& keys) OVERRIDE {
  67     return delegate()->Remove(keys);
  68   }
  69
  70   virtual WriteResult Clear() OVERRIDE {
  71     return delegate()->Clear();
  72   }
  73
  74  private:
  75   DISALLOW_COPY_AND_ASSIGN(MutablePolicyValueStore);
  76 };
  77
  78 ValueStore* Param(const base::FilePath& file_path) {
  79   return new MutablePolicyValueStore(file_path);
  80 }
  81
  82 }  // namespace
  83
  84 INSTANTIATE_TEST_CASE_P(
  85     PolicyValueStoreTest,
  86     ValueStoreTest,
  87     testing::Values(&Param));
  88
  89 class PolicyValueStoreTest : public testing::Test {
  90  public:
  91   PolicyValueStoreTest()
  92       : file_thread_(content::BrowserThread::FILE, &loop_) {}
  93   virtual ~PolicyValueStoreTest() {}
  94
  95   virtual void SetUp() OVERRIDE {
  96     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
  97     observers_ = new SettingsObserverList();
  98     observers_->AddObserver(&observer_);
  99     store_.reset(new PolicyValueStore(
 100         kTestExtensionId,
 101         observers_,
 102         scoped_ptr<ValueStore>(
 103             new LeveldbValueStore(scoped_temp_dir_.path()))));
 104   }
 105
 106   virtual void TearDown() OVERRIDE {
 107     observers_->RemoveObserver(&observer_);
 108     store_.reset();
 109   }
 110
 111  protected:
 112   base::ScopedTempDir scoped_temp_dir_;
 113   base::MessageLoop loop_;
 114   content::TestBrowserThread file_thread_;
 115   scoped_ptr<PolicyValueStore> store_;
 116   MockSettingsObserver observer_;
 117   scoped_refptr<SettingsObserverList> observers_;
 118 };
 119
 120 TEST_F(PolicyValueStoreTest, DontProvideRecommendedPolicies) {
 121   policy::PolicyMap policies;
 122   base::FundamentalValue expected(123);
 123   policies.Set("must", policy::POLICY_LEVEL_MANDATORY,
 124                policy::POLICY_SCOPE_USER, expected.DeepCopy(), NULL);
 125   policies.Set("may", policy::POLICY_LEVEL_RECOMMENDED,
 126                policy::POLICY_SCOPE_USER,
 127                new base::FundamentalValue(456), NULL);
 128   store_->SetCurrentPolicy(policies);
 129   ValueStore::ReadResult result = store_->Get();
 130   ASSERT_FALSE(result->HasError());
 131   EXPECT_EQ(1u, result->settings().size());
 132   base::Value* value = NULL;
 133   EXPECT_FALSE(result->settings().Get("may", &value));
 134   EXPECT_TRUE(result->settings().Get("must", &value));
 135   EXPECT_TRUE(base::Value::Equals(&expected, value));
 136 }
 137
 138 TEST_F(PolicyValueStoreTest, ReadOnly) {
 139   ValueStore::WriteOptions options = ValueStore::DEFAULTS;
 140
 141   base::StringValue string_value("value");
 142   EXPECT_TRUE(store_->Set(options, "key", string_value)->HasError());
 143
 144   base::DictionaryValue dict;
 145   dict.SetString("key", "value");
 146   EXPECT_TRUE(store_->Set(options, dict)->HasError());
 147
 148   EXPECT_TRUE(store_->Remove("key")->HasError());
 149   std::vector<std::string> keys;
 150   keys.push_back("key");
 151   EXPECT_TRUE(store_->Remove(keys)->HasError());
 152   EXPECT_TRUE(store_->Clear()->HasError());
 153 }
 154
 155 TEST_F(PolicyValueStoreTest, NotifyOnChanges) {
 156   // Notify when setting the initial policy.
 157   const base::StringValue value("111");
 158   {
 159     ValueStoreChangeList changes;
 160     changes.push_back(ValueStoreChange("aaa", NULL, value.DeepCopy()));
 161     EXPECT_CALL(observer_,
 162                 OnSettingsChanged(kTestExtensionId,
 163                                   settings_namespace::MANAGED,
 164                                   ValueStoreChange::ToJson(changes)));
 165   }
 166
 167   policy::PolicyMap policies;
 168   policies.Set("aaa", policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
 169                value.DeepCopy(), NULL);
 170   store_->SetCurrentPolicy(policies);
 171   loop_.RunUntilIdle();
 172   Mock::VerifyAndClearExpectations(&observer_);
 173
 174   // Notify when new policies are added.
 175   {
 176     ValueStoreChangeList changes;
 177     changes.push_back(ValueStoreChange("bbb", NULL, value.DeepCopy()));
 178     EXPECT_CALL(observer_,
 179                 OnSettingsChanged(kTestExtensionId,
 180                                   settings_namespace::MANAGED,
 181                                   ValueStoreChange::ToJson(changes)));
 182   }
 183
 184   policies.Set("bbb", policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
 185                value.DeepCopy(), NULL);
 186   store_->SetCurrentPolicy(policies);
 187   loop_.RunUntilIdle();
 188   Mock::VerifyAndClearExpectations(&observer_);
 189
 190   // Notify when policies change.
 191   const base::StringValue new_value("222");
 192   {
 193     ValueStoreChangeList changes;
 194     changes.push_back(
 195         ValueStoreChange("bbb", value.DeepCopy(), new_value.DeepCopy()));
 196     EXPECT_CALL(observer_,
 197                 OnSettingsChanged(kTestExtensionId,
 198                                   settings_namespace::MANAGED,
 199                                   ValueStoreChange::ToJson(changes)));
 200   }
 201
 202   policies.Set("bbb", policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
 203                new_value.DeepCopy(), NULL);
 204   store_->SetCurrentPolicy(policies);
 205   loop_.RunUntilIdle();
 206   Mock::VerifyAndClearExpectations(&observer_);
 207
 208   // Notify when policies are removed.
 209   {
 210     ValueStoreChangeList changes;
 211     changes.push_back(ValueStoreChange("bbb", new_value.DeepCopy(), NULL));
 212     EXPECT_CALL(observer_,
 213                 OnSettingsChanged(kTestExtensionId,
 214                                   settings_namespace::MANAGED,
 215                                   ValueStoreChange::ToJson(changes)));
 216   }
 217
 218   policies.Erase("bbb");
 219   store_->SetCurrentPolicy(policies);
 220   loop_.RunUntilIdle();
 221   Mock::VerifyAndClearExpectations(&observer_);
 222
 223   // Don't notify when there aren't any changes.
 224   EXPECT_CALL(observer_, OnSettingsChanged(_, _, _)).Times(0);
 225   store_->SetCurrentPolicy(policies);
 226   loop_.RunUntilIdle();
 227   Mock::VerifyAndClearExpectations(&observer_);
 228 }
 229
 230 }  // namespace extensions