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;

[Mattias Nissler (ping if slow), 2011/02/21 14:39:13]

Hm, it seems a curious choice to hide the observer tests in this helper method.
Why not have separate test that tests observer functionality and drop the
observer here?

[Jakob Kummerow, 2011/02/22 10:02:33]

This doesn't just test whether notifying the observers work. Rather, it tests
whether the cache correctly determined whether the new policy is different from
the existing policy or not. We used to have the return value of SetPolicy() for
that, but that method's semantics have changed, so we need the observer
notification as a sentry mechanism.

As discussed, I'll leave it like this.

+    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