Update policy backend and testserver for the newest policy protocol

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"
@@ skipping 40 matching lines @@
         file_thread_(BrowserThread::FILE, &loop_) {}
 
   void SetUp() {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
   void TearDown() {
     loop_.RunAllPending();
   }
 
-  // Creates a (signed) CloudPolicyResponse setting the given |homepage| and
+  // Creates a (signed) PolicyFetchResponse setting the given |homepage| and
   // featuring the given |timestamp| (as issued by the server).
   // Mildly hacky special feature: pass an empty string as |homepage| to get
   // a completely empty policy.
-  em::CloudPolicyResponse* CreateHomepagePolicy(
+  em::PolicyFetchResponse* CreateHomepagePolicy(
       const std::string& homepage,
       const base::Time& timestamp,
       const em::PolicyOptions::PolicyMode policy_mode) {
-    em::SignedCloudPolicyResponse signed_response;
+    em::PolicyData signed_response;
     if (homepage != "") {
-      em::CloudPolicySettings* settings = signed_response.mutable_settings();
+      em::CloudPolicySettings settings;
       em::HomepageLocationProto* homepagelocation_proto =
-          settings->mutable_homepagelocation();
+          settings.mutable_homepagelocation();
       homepagelocation_proto->set_homepagelocation(homepage);
       homepagelocation_proto->mutable_policy_options()->set_mode(policy_mode);
+      EXPECT_TRUE(
+          settings.SerializeToString(signed_response.mutable_policy_value()));
     }
-    signed_response.set_timestamp(timestamp.ToTimeT());
+    signed_response.set_timestamp(
+        (timestamp - base::Time::UnixEpoch()).InMilliseconds());
     std::string serialized_signed_response;
     EXPECT_TRUE(signed_response.SerializeToString(&serialized_signed_response));
 
-    em::CloudPolicyResponse* response = new em::CloudPolicyResponse;
-    response->set_signed_response(serialized_signed_response);
+    em::PolicyFetchResponse* response = new em::PolicyFetchResponse;
+    response->set_policy_data(serialized_signed_response);
     // TODO(jkummerow): Set proper certificate_chain and signature (when
     // implementing support for signature verification).
-    response->set_signature("TODO");
+    response->set_policy_data_signature("TODO");
     response->add_certificate_chain("TODO");
     return response;
   }
 
-  void WritePolicy(const em::CloudPolicyResponse& policy) {
+  void WritePolicy(const em::PolicyFetchResponse& 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,
+                 em::PolicyFetchResponse* policy_response,
                  bool expect_changed_policy) {
-    scoped_ptr<em::CloudPolicyResponse> policy(policy_response);
+    scoped_ptr<em::PolicyFetchResponse> 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);
   }
 
@@ skipping 85 matching lines @@
 
 TEST_F(CloudPolicyCacheTest, LoadNoFile) {
   CloudPolicyCache cache(test_file());
   cache.LoadFromFile();
   PolicyMap empty;
   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(
+  scoped_ptr<em::PolicyFetchResponse> policy_response(
       CreateHomepagePolicy("", base::Time::NowFromSystemTime() +
                                base::TimeDelta::FromMinutes(5),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy_response);
   CloudPolicyCache cache(test_file());
   cache.LoadFromFile();
   PolicyMap empty;
   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(
+  scoped_ptr<em::PolicyFetchResponse> policy_response(
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy_response);
   CloudPolicyCache cache(test_file());
   cache.LoadFromFile();
   PolicyMap empty;
   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(
+  scoped_ptr<em::PolicyFetchResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy);
   CloudPolicyCache cache(test_file());
   cache.LoadFromFile();
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(CloudPolicyCacheTest, SetPolicy) {
   CloudPolicyCache cache(test_file());
-  em::CloudPolicyResponse* policy =
+  em::PolicyFetchResponse* policy =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy, true);
-  em::CloudPolicyResponse* policy2 =
+  em::PolicyFetchResponse* policy2 =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy2, false);
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
   PolicyMap empty;
   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);
+                                base::Time::NowFromSystemTime(),
+                                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());
 
-  em::CloudPolicyResponse* policy =
+  em::PolicyFetchResponse* policy =
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, policy, true);
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 
-  em::CloudPolicyResponse* empty_policy =
+  em::PolicyFetchResponse* empty_policy =
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, empty_policy, true);
   PolicyMap empty;
   EXPECT_TRUE(empty.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(CloudPolicyCacheTest, PersistPolicy) {
   {
     CloudPolicyCache cache(test_file());
-    scoped_ptr<em::CloudPolicyResponse> policy(
+    scoped_ptr<em::PolicyFetchResponse> 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.LoadFromFile();
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.example.com"));
   EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
 }
 
 TEST_F(CloudPolicyCacheTest, FreshPolicyOverride) {
-  scoped_ptr<em::CloudPolicyResponse> policy(
+  scoped_ptr<em::PolicyFetchResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   WritePolicy(*policy);
 
   CloudPolicyCache cache(test_file());
-  em::CloudPolicyResponse* updated_policy =
+  em::PolicyFetchResponse* updated_policy =
       CreateHomepagePolicy("http://www.chromium.org",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY);
   SetPolicy(&cache, updated_policy, true);
 
   cache.LoadFromFile();
   PolicyMap expected;
   expected.Set(kPolicyHomepageLocation,
                Value::CreateStringValue("http://www.chromium.org"));
   EXPECT_TRUE(expected.Equals(mandatory_policy(cache)));
@@ skipping 304 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