New policy protobuf protocol.

chrome/browser/policy/device_management_policy_cache_unittest.cc

 // Copyright (c) 2010 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/device_management_policy_cache.h"
+#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/proto/device_management_constants.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+// This test used to test DeviceManagementPolicyCache. The new CloudPolicyCache
+// supports the old DMPC's interface for now (until it is phased out), so for
+// this transitional period, we keep these old test cases but apply them to the
+// new implementation (CPC).
+// This file can be removed when support for the old policy protocol is removed
+// from CPC. The new interface is tested in cloud_policy_cache_unittest.cc.

[Mattias Nissler (ping if slow), 2011/02/15 10:46:39]

Ah, the tests are here. Can we just move this code to the other file? Breaking
the convention of the implementation and test file names matching doesn't seem
like a good idea.

[Jakob Kummerow, 2011/02/15 14:22:00]

Well, it was only supposed to be a temporary solution for a few weeks, but...
Done.

+
 namespace policy {
 
 // Wraps base functionaly for the test cases.
 class DeviceManagementPolicyCacheTestBase : public testing::Test {
  protected:
   // Add a string policy setting to a policy response message.
   void AddStringPolicy(em::DevicePolicyResponse* policy,
                        const std::string& name,
                        const std::string& value) {
     em::DevicePolicySetting* setting = policy->add_setting();
@@ skipping 20 matching lines @@
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   void TearDown() {
     loop_.RunAllPending();
   }
 
   void WritePolicy(const em::DevicePolicyResponse& policy,
                    const base::Time& timestamp) {
     std::string data;
-    em::CachedDevicePolicyResponse cached_policy;
-    cached_policy.mutable_policy()->CopyFrom(policy);
-    cached_policy.set_timestamp(timestamp.ToInternalValue());
+    em::CachedCloudPolicyResponse cached_policy;
+    cached_policy.mutable_device_policy()->CopyFrom(policy);
+    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:
   MessageLoop loop_;
 
  private:
   ScopedTempDir temp_dir_;
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
 };
 
 TEST_F(DeviceManagementPolicyCacheTest, Empty) {
-  DeviceManagementPolicyCache cache(test_file());
+  CloudPolicyCache cache(test_file());
   DictionaryValue empty;
-  scoped_ptr<Value> policy(cache.GetPolicy());
+  scoped_ptr<Value> policy(cache.GetDevicePolicy());
   EXPECT_TRUE(empty.Equals(policy.get()));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, LoadNoFile) {
-  DeviceManagementPolicyCache cache(test_file());
+  CloudPolicyCache cache(test_file());
   cache.LoadPolicyFromFile();
   DictionaryValue empty;
-  scoped_ptr<Value> policy(cache.GetPolicy());
+  scoped_ptr<Value> policy(cache.GetDevicePolicy());
   EXPECT_TRUE(empty.Equals(policy.get()));
   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));
-  DeviceManagementPolicyCache cache(test_file());
+  CloudPolicyCache cache(test_file());
   cache.LoadPolicyFromFile();
   DictionaryValue empty;
-  scoped_ptr<Value> policy(cache.GetPolicy());
+  scoped_ptr<Value> policy(cache.GetDevicePolicy());
   EXPECT_TRUE(empty.Equals(policy.get()));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, LoadWithFile) {
   em::DevicePolicyResponse policy_response;
   WritePolicy(policy_response, base::Time::NowFromSystemTime());
-  DeviceManagementPolicyCache cache(test_file());
+  CloudPolicyCache cache(test_file());
   cache.LoadPolicyFromFile();
   DictionaryValue empty;
-  scoped_ptr<Value> policy(cache.GetPolicy());
+  scoped_ptr<Value> policy(cache.GetDevicePolicy());
   EXPECT_TRUE(empty.Equals(policy.get()));
   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());
-  DeviceManagementPolicyCache cache(test_file());
+  CloudPolicyCache cache(test_file());
   cache.LoadPolicyFromFile();
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.example.com"));
-  scoped_ptr<Value> policy_value(cache.GetPolicy());
+  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
   EXPECT_TRUE(expected.Equals(policy_value.get()));
 }
 
-TEST_F(DeviceManagementPolicyCacheTest, SetPolicy) {
-  DeviceManagementPolicyCache cache(test_file());
+TEST_F(DeviceManagementPolicyCacheTest, SetDevicePolicy) {
+  CloudPolicyCache cache(test_file());
   em::DevicePolicyResponse policy;
   AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
-  EXPECT_TRUE(cache.SetPolicy(policy));
+  EXPECT_TRUE(cache.SetDevicePolicy(policy));
   em::DevicePolicyResponse policy2;
   AddStringPolicy(&policy2, "HomepageLocation", "http://www.example.com");
-  EXPECT_FALSE(cache.SetPolicy(policy2));
+  EXPECT_FALSE(cache.SetDevicePolicy(policy2));
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.example.com"));
-  scoped_ptr<Value> policy_value(cache.GetPolicy());
+  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
   EXPECT_TRUE(expected.Equals(policy_value.get()));
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, ResetPolicy) {
-  DeviceManagementPolicyCache cache(test_file());
+  CloudPolicyCache cache(test_file());
 
   em::DevicePolicyResponse policy;
   AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
-  EXPECT_TRUE(cache.SetPolicy(policy));
+  EXPECT_TRUE(cache.SetDevicePolicy(policy));
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.example.com"));
-  scoped_ptr<Value> policy_value(cache.GetPolicy());
+  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
   EXPECT_TRUE(expected.Equals(policy_value.get()));
 
-  EXPECT_TRUE(cache.SetPolicy(em::DevicePolicyResponse()));
-  policy_value.reset(cache.GetPolicy());
+  EXPECT_TRUE(cache.SetDevicePolicy(em::DevicePolicyResponse()));
+  policy_value.reset(cache.GetDevicePolicy());
   DictionaryValue empty;
   EXPECT_TRUE(empty.Equals(policy_value.get()));
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, PersistPolicy) {
   {
-    DeviceManagementPolicyCache cache(test_file());
+    CloudPolicyCache cache(test_file());
     em::DevicePolicyResponse policy;
     AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
-    cache.SetPolicy(policy);
+    cache.SetDevicePolicy(policy);
   }
 
   loop_.RunAllPending();
 
   EXPECT_TRUE(file_util::PathExists(test_file()));
-  DeviceManagementPolicyCache cache(test_file());
+  CloudPolicyCache cache(test_file());
   cache.LoadPolicyFromFile();
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.example.com"));
-  scoped_ptr<Value> policy_value(cache.GetPolicy());
+  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
   EXPECT_TRUE(expected.Equals(policy_value.get()));
 }
 
 TEST_F(DeviceManagementPolicyCacheTest, FreshPolicyOverride) {
   em::DevicePolicyResponse policy;
   AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
   WritePolicy(policy, base::Time::NowFromSystemTime());
 
-  DeviceManagementPolicyCache cache(test_file());
+  CloudPolicyCache cache(test_file());
   em::DevicePolicyResponse updated_policy;
   AddStringPolicy(&updated_policy, "HomepageLocation",
                   "http://www.chromium.org");
-  EXPECT_TRUE(cache.SetPolicy(updated_policy));
+  EXPECT_TRUE(cache.SetDevicePolicy(updated_policy));
 
   cache.LoadPolicyFromFile();
   DictionaryValue expected;
   expected.Set("HomepageLocation",
                Value::CreateStringValue("http://www.chromium.org"));
-  scoped_ptr<Value> policy_value(cache.GetPolicy());
+  scoped_ptr<Value> policy_value(cache.GetDevicePolicy());
   EXPECT_TRUE(expected.Equals(policy_value.get()));
 }
 
 // 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(
-        DeviceManagementPolicyCache::DecodeValue(value_));
+        CloudPolicyCache::DecodeValue(value_));
     if (expected_value_ptr) {
       ASSERT_TRUE(decoded_value.get());
       EXPECT_TRUE(decoded_value->Equals(expected_value.get()));
     } else {
       ASSERT_FALSE(decoded_value.get());
     }
   }
 
+  DictionaryValue* DecodeDevicePolicy(const em::DevicePolicyResponse policy) {
+    return CloudPolicyCache::DecodeDevicePolicy(policy);
+  }
+
   em::GenericValue value_;
 };
 
 TEST_F(DeviceManagementPolicyCacheDecodeTest, Bool) {
   value_.set_value_type(em::GenericValue::VALUE_TYPE_BOOL);
   value_.set_bool_value(true);
   DecodeAndCheck(Value::CreateBooleanValue(true));
 }
 
 TEST_F(DeviceManagementPolicyCacheDecodeTest, Int64) {
@@ skipping 72 matching lines @@
   value_.add_double_array(0.17L);
   ListValue* list = new ListValue;
   list->Append(Value::CreateDoubleValue(0.42L));
   list->Append(Value::CreateDoubleValue(0.17L));
   DecodeAndCheck(list);
 }
 
 TEST_F(DeviceManagementPolicyCacheDecodeTest, DecodePolicy) {
   em::DevicePolicyResponse policy;
   AddStringPolicy(&policy, "HomepageLocation", "http://www.example.com");
-  scoped_ptr<Value> decoded(DeviceManagementPolicyCache::DecodePolicy(policy));
+  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