Device policy infrastructure

chrome/browser/policy/cloud_policy_cache_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/policy/cloud_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/values.h"
 #include "chrome/browser/browser_thread.h"
+#include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/proto/cloud_policy.pb.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 // TODO(jkummerow): remove this import when removing old DMPC test cases.
 #include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 // Decodes a CloudPolicySettings object into two maps with mandatory and
 // recommended settings, respectively. The implementation is generated code
 // in policy/cloud_policy_generated.cc.
 void DecodePolicy(const em::CloudPolicySettings& policy,
                   PolicyMap* mandatory, PolicyMap* recommended);
 
 // The implementations of these methods are in cloud_policy_generated.cc.
 Value* DecodeIntegerValue(google::protobuf::int64 value);
 ListValue* DecodeStringList(const em::StringList& string_list);
 
+class MockConfigurationPolicyProviderObserver
+    : public ConfigurationPolicyProvider::Observer {
+ public:
+  MockConfigurationPolicyProviderObserver() {}
+  virtual ~MockConfigurationPolicyProviderObserver() {}
+  MOCK_METHOD0(OnUpdatePolicy, void());
+  void OnProviderGoingAway() {}
+};
+
 // Tests the device management policy cache.
 class CloudPolicyCacheTest : public testing::Test {
  protected:
   CloudPolicyCacheTest()
       : loop_(MessageLoop::TYPE_UI),
         ui_thread_(BrowserThread::UI, &loop_),
         file_thread_(BrowserThread::FILE, &loop_) {}
 
   void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
@@ skipping 34 matching lines @@
 
   void WritePolicy(const em::CloudPolicyResponse& policy) {
     std::string data;
     em::CachedCloudPolicyResponse cached_policy;
     cached_policy.mutable_cloud_policy()->CopyFrom(policy);
     EXPECT_TRUE(cached_policy.SerializeToString(&data));
     int size = static_cast<int>(data.size());
     EXPECT_EQ(size, file_util::WriteFile(test_file(), data.c_str(), size));
   }
 
+  // Takes ownership of |policy_response|.
+  void SetPolicy(CloudPolicyCache* cache,
+                 em::CloudPolicyResponse* policy_response,
+                 bool expect_changed_policy) {
+    scoped_ptr<em::CloudPolicyResponse> policy(policy_response);
+    ConfigurationPolicyObserverRegistrar registrar;
+    registrar.Init(cache->GetManagedPolicyProvider(), &observer);
+    if (expect_changed_policy)
+      EXPECT_CALL(observer, OnUpdatePolicy()).Times(1);
+    else
+      EXPECT_CALL(observer, OnUpdatePolicy()).Times(0);
+    cache->SetPolicy(*policy);
+    testing::Mock::VerifyAndClearExpectations(&observer);
+  }
+
   FilePath test_file() {
     return temp_dir_.path().AppendASCII("CloudPolicyCacheTest");
   }
 
+  const PolicyMap& mandatory_policy(const CloudPolicyCache& cache) {
+    return cache.mandatory_policy_;
+  }
+
+  const PolicyMap& recommended_policy(const CloudPolicyCache& cache) {
+    return cache.recommended_policy_;
+  }
+
   MessageLoop loop_;
+  MockConfigurationPolicyProviderObserver observer;
 
  private:
   ScopedTempDir temp_dir_;
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
 };
 
 TEST_F(CloudPolicyCacheTest, DecodePolicy) {
   em::CloudPolicySettings settings;
   settings.mutable_homepagelocation()->set_homepagelocation("chromium.org");
@@ skipping 47 matching lines @@
   scoped_ptr<ListValue> decoded(DecodeStringList(string_list));
   ListValue expected;
   expected.Append(Value::CreateStringValue("ponies"));
   expected.Append(Value::CreateStringValue("more ponies"));
   EXPECT_TRUE(decoded->Equals(&expected));
 }
 
 TEST_F(CloudPolicyCacheTest, Empty) {
   CloudPolicyCache cache(test_file());
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
-  EXPECT_TRUE(empty.Equals(*cache.GetRecommendedPolicy()));
+  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(empty.Equals(recommended_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(CloudPolicyCacheTest, LoadNoFile) {
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(CloudPolicyCacheTest, RejectFuture) {
   scoped_ptr<em::CloudPolicyResponse> policy_response(
       CreateHomepagePolicy("", base::Time::NowFromSystemTime() +
                                base::TimeDelta::FromMinutes(5),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy_response);
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(CloudPolicyCacheTest, LoadWithFile) {
   scoped_ptr<em::CloudPolicyResponse> policy_response(
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy_response);
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
   EXPECT_NE(base::Time(), cache.last_policy_refresh_time());
   EXPECT_GE(base::Time::Now(), cache.last_policy_refresh_time());
 }
 
 TEST_F(CloudPolicyCacheTest, LoadWithData) {
   scoped_ptr<em::CloudPolicyResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy);
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
-  EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(CloudPolicyCacheTest, SetPolicy) {
   CloudPolicyCache cache(test_file());
-  scoped_ptr<em::CloudPolicyResponse> policy(
+  em::CloudPolicyResponse* policy =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
-                           em::PolicyOptions::MANDATORY));
-  EXPECT_TRUE(cache.SetPolicy(*policy));
-  scoped_ptr<em::CloudPolicyResponse> policy2(
+                           em::PolicyOptions::MANDATORY);
+  SetPolicy(&cache, policy, true);
+  em::CloudPolicyResponse* policy2 =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
-                           em::PolicyOptions::MANDATORY));
-  EXPECT_FALSE(cache.SetPolicy(*policy2));
+                           em::PolicyOptions::MANDATORY);
+  SetPolicy(&cache, policy2, false);
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
   PolicyMap empty;
-  EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
-  EXPECT_TRUE(empty.Equals(*cache.GetRecommendedPolicy()));
-  policy.reset(CreateHomepagePolicy("http://www.example.com",
+  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
+  EXPECT_TRUE(empty.Equals(recommended_policy(cache)));
+  policy = CreateHomepagePolicy("http://www.example.com",
                                     base::Time::NowFromSystemTime(),
-                                    em::PolicyOptions::RECOMMENDED));
-  EXPECT_TRUE(cache.SetPolicy(*policy));
-  EXPECT_TRUE(expected.Equals(*cache.GetRecommendedPolicy()));
-  EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
+                                    em::PolicyOptions::RECOMMENDED);
+  SetPolicy(&cache, policy, true);
+  EXPECT_TRUE(expected.Equals(recommended_policy(cache)));
+  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(CloudPolicyCacheTest, ResetPolicy) {
   CloudPolicyCache cache(test_file());
 
-  scoped_ptr<em::CloudPolicyResponse> policy(
+  em::CloudPolicyResponse* policy =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
-                           em::PolicyOptions::MANDATORY));
-  EXPECT_TRUE(cache.SetPolicy(*policy));
+                           em::PolicyOptions::MANDATORY);
+  SetPolicy(&cache, policy, true);
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
-  EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 
-  scoped_ptr<em::CloudPolicyResponse> empty_policy(
+  em::CloudPolicyResponse* empty_policy =
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
-                           em::PolicyOptions::MANDATORY));
-  EXPECT_TRUE(cache.SetPolicy(*empty_policy));
+                           em::PolicyOptions::MANDATORY);
+  SetPolicy(&cache, empty_policy, true);
   PolicyMap empty;
-  EXPECT_TRUE(empty.Equals(*cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(CloudPolicyCacheTest, PersistPolicy) {
   {
     CloudPolicyCache cache(test_file());
     scoped_ptr<em::CloudPolicyResponse> policy(
         CreateHomepagePolicy("http://www.example.com",
                              base::Time::NowFromSystemTime(),
                              em::PolicyOptions::MANDATORY));
     cache.SetPolicy(*policy);
   }
 
   loop_.RunAllPending();
 
   EXPECT_TRUE(file_util::PathExists(test_file()));
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
-  EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(CloudPolicyCacheTest, FreshPolicyOverride) {
   scoped_ptr<em::CloudPolicyResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy);
 
   CloudPolicyCache cache(test_file());
-  scoped_ptr<em::CloudPolicyResponse> updated_policy(
+  em::CloudPolicyResponse* updated_policy =
       CreateHomepagePolicy("http://www.chromium.org",
                            base::Time::NowFromSystemTime(),
-                           em::PolicyOptions::MANDATORY));
-  EXPECT_TRUE(cache.SetPolicy(*updated_policy));
+                           em::PolicyOptions::MANDATORY);
+  SetPolicy(&cache, updated_policy, true);
 
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.chromium.org"));
-  EXPECT_TRUE(expected.Equals(*cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 }
 
 }  // namespace policy
 
 // ==================================================================
 // Everything below this line can go when we phase out support for
 // the old (trusted testing/pilot program) policy format.
 
 // This is a (slightly updated) copy of the old
 // device_management_policy_cache_unittest.cc. The new CloudPolicyCache
@@ skipping 46 matching lines @@
     cached_policy.set_timestamp(timestamp.ToTimeT());
     EXPECT_TRUE(cached_policy.SerializeToString(&data));
     int size = static_cast<int>(data.size());
     EXPECT_EQ(size, file_util::WriteFile(test_file(), data.c_str(), size));
   }
 
   FilePath test_file() {
     return temp_dir_.path().AppendASCII("DeviceManagementPolicyCacheTest");
   }
 
- protected:
+  const DictionaryValue* device_policy(const CloudPolicyCache& cache) {
+    return cache.device_policy_.get();
+  }
+
   MessageLoop loop_;
 
  private:
   ScopedTempDir temp_dir_;
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
 };
 
 TEST_F(DeviceManagementPolicyCacheTest, Empty) {
   CloudPolicyCache cache(test_file());
   DictionaryValue empty;
-  scoped_ptr<Value> policy(cache.GetDevicePolicy());
-  EXPECT_TRUE(empty.Equals(policy.get()));
+  EXPECT_TRUE(empty.Equals(device_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, LoadNoFile) {
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   DictionaryValue empty;
-  scoped_ptr<Value> policy(cache.GetDevicePolicy());
-  EXPECT_TRUE(empty.Equals(policy.get()));
+  EXPECT_TRUE(empty.Equals(device_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, RejectFuture) {
   em::DevicePolicyResponse policy_response;
   WritePolicy(policy_response, base::Time::NowFromSystemTime() +
                                base::TimeDelta::FromMinutes(5));
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   DictionaryValue empty;
-  scoped_ptr<Value> policy(cache.GetDevicePolicy());
-  EXPECT_TRUE(empty.Equals(policy.get()));
+  EXPECT_TRUE(empty.Equals(device_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, LoadWithFile) {
   em::DevicePolicyResponse policy_response;
   WritePolicy(policy_response, base::Time::NowFromSystemTime());
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   DictionaryValue empty;
-  scoped_ptr<Value> policy(cache.GetDevicePolicy());
-  EXPECT_TRUE(empty.Equals(policy.get()));
+  EXPECT_TRUE(empty.Equals(device_policy(cache)));
   EXPECT_NE(base::Time(), cache.last_policy_refresh_time());
   EXPECT_GE(base::Time::Now(), cache.last_policy_refresh_time());
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, LoadWithData) {
   em::DevicePolicyResponse policy;
   AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
   WritePolicy(policy, base::Time::NowFromSystemTime());
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.example.com"));
-  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
-  EXPECT_TRUE(expected.Equals(policy_value.get()));
+  EXPECT_TRUE(expected.Equals(device_policy(cache)));
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, SetDevicePolicy) {
   CloudPolicyCache cache(test_file());
   em::DevicePolicyResponse policy;
   AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
-  EXPECT_TRUE(cache.SetDevicePolicy(policy));
+  cache.SetDevicePolicy(policy);
   em::DevicePolicyResponse policy2;
   AddStringPolicy(&policy2, "HomepageLocation", "http://www.example.com");
-  EXPECT_FALSE(cache.SetDevicePolicy(policy2));
+  cache.SetDevicePolicy(policy2);  // Does not notify observers.
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.example.com"));
-  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
-  EXPECT_TRUE(expected.Equals(policy_value.get()));
+  EXPECT_TRUE(expected.Equals(device_policy(cache)));
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, ResetPolicy) {
   CloudPolicyCache cache(test_file());
 
   em::DevicePolicyResponse policy;
   AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
-  EXPECT_TRUE(cache.SetDevicePolicy(policy));
+  cache.SetDevicePolicy(policy);
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.example.com"));
-  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
-  EXPECT_TRUE(expected.Equals(policy_value.get()));
+  EXPECT_TRUE(expected.Equals(device_policy(cache)));
 
-  EXPECT_TRUE(cache.SetDevicePolicy(em::DevicePolicyResponse()));
-  policy_value.reset(cache.GetDevicePolicy());
+  cache.SetDevicePolicy(em::DevicePolicyResponse());
   DictionaryValue empty;
-  EXPECT_TRUE(empty.Equals(policy_value.get()));
+  EXPECT_TRUE(empty.Equals(device_policy(cache)));
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, PersistPolicy) {
   {
     CloudPolicyCache cache(test_file());
     em::DevicePolicyResponse policy;
     AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
     cache.SetDevicePolicy(policy);
   }
 
   loop_.RunAllPending();
 
   EXPECT_TRUE(file_util::PathExists(test_file()));
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.example.com"));
-  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
-  EXPECT_TRUE(expected.Equals(policy_value.get()));
+  EXPECT_TRUE(expected.Equals(device_policy(cache)));
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, FreshPolicyOverride) {
   em::DevicePolicyResponse policy;
   AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
   WritePolicy(policy, base::Time::NowFromSystemTime());
 
   CloudPolicyCache cache(test_file());
   em::DevicePolicyResponse updated_policy;
   AddStringPolicy(&updated_policy, "HomepageLocation",
                   "http://www.chromium.org");
-  EXPECT_TRUE(cache.SetDevicePolicy(updated_policy));
+  cache.SetDevicePolicy(updated_policy);
 
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.chromium.org"));
-  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
-  EXPECT_TRUE(expected.Equals(policy_value.get()));
+  EXPECT_TRUE(expected.Equals(device_policy(cache)));
 }
 
 // Tests proper decoding of policy values.
 class DeviceManagementPolicyCacheDecodeTest
     : public DeviceManagementPolicyCacheTestBase {
  protected:
   void DecodeAndCheck(Value* expected_value_ptr) {
     scoped_ptr<Value> expected_value(expected_value_ptr);
     scoped_ptr<Value> decoded_value(
         CloudPolicyCache::DecodeValue(value_));
@@ skipping 102 matching lines @@
   em::DevicePolicyResponse policy;
   AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
   scoped_ptr<Value> decoded(DecodeDevicePolicy(policy));
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(decoded.get()));
 }
 
 }  // namespace policy