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"
@@ skipping 64 matching lines @@
     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));
   }
 
   FilePath test_file() {
     return temp_dir_.path().AppendASCII("CloudPolicyCacheTest");
   }
 
+  const PolicyMapType& mandatory_policy(const CloudPolicyCache& cache) {
+    return cache.mandatory_policy_;
+  }
+
+  const PolicyMapType& recommended_policy(const CloudPolicyCache& cache) {
+    return cache.recommended_policy_;
+  }
+
   bool Equals(const PolicyMapType& a, const PolicyMapType& b) const {
     return CloudPolicyCache::Equals(a, b);
   }
 
   MessageLoop loop_;
 
  private:
   ScopedTempDir temp_dir_;
   BrowserThread ui_thread_;
   BrowserThread file_thread_;
@@ skipping 80 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());
   PolicyMapType empty;
-  EXPECT_TRUE(Equals(empty, *cache.GetMandatoryPolicy()));
-  EXPECT_TRUE(Equals(empty, *cache.GetRecommendedPolicy()));
+  EXPECT_TRUE(Equals(empty, mandatory_policy(cache)));
+  EXPECT_TRUE(Equals(empty, recommended_policy(cache)));
   EXPECT_EQ(base::Time(), cache.last_policy_refresh_time());
 }
 
 TEST_F(CloudPolicyCacheTest, LoadNoFile) {
   CloudPolicyCache cache(test_file());
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   PolicyMapType empty;
-  EXPECT_TRUE(Equals(empty, *cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(Equals(empty, 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();
   PolicyMapType empty;
-  EXPECT_TRUE(Equals(empty, *cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(Equals(empty, 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();
   PolicyMapType empty;
-  EXPECT_TRUE(Equals(empty, *cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(Equals(empty, 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();
   PolicyMapType expected;
   expected.insert(
       std::make_pair(kPolicyHomepageLocation,
                      Value::CreateStringValue("http://www.example.com")));
-  EXPECT_TRUE(Equals(expected, *cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(Equals(expected, mandatory_policy(cache)));
 }
 
 TEST_F(CloudPolicyCacheTest, SetPolicy) {
   CloudPolicyCache cache(test_file());
   scoped_ptr<em::CloudPolicyResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   EXPECT_TRUE(cache.SetPolicy(*policy));
   scoped_ptr<em::CloudPolicyResponse> policy2(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   EXPECT_FALSE(cache.SetPolicy(*policy2));
   PolicyMapType expected;
   expected.insert(
       std::make_pair(kPolicyHomepageLocation,
                      Value::CreateStringValue("http://www.example.com")));
   PolicyMapType empty;
-  EXPECT_TRUE(Equals(expected, *cache.GetMandatoryPolicy()));
-  EXPECT_TRUE(Equals(empty, *cache.GetRecommendedPolicy()));
+  EXPECT_TRUE(Equals(expected, mandatory_policy(cache)));
+  EXPECT_TRUE(Equals(empty, recommended_policy(cache)));
   policy.reset(CreateHomepagePolicy("http://www.example.com",
                                     base::Time::NowFromSystemTime(),
                                     em::PolicyOptions::RECOMMENDED));
   EXPECT_TRUE(cache.SetPolicy(*policy));
-  EXPECT_TRUE(Equals(expected, *cache.GetRecommendedPolicy()));
-  EXPECT_TRUE(Equals(empty, *cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(Equals(expected, recommended_policy(cache)));
+  EXPECT_TRUE(Equals(empty, mandatory_policy(cache)));
 }
 
 TEST_F(CloudPolicyCacheTest, ResetPolicy) {
   CloudPolicyCache cache(test_file());
 
   scoped_ptr<em::CloudPolicyResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   EXPECT_TRUE(cache.SetPolicy(*policy));
   PolicyMapType expected;
   expected.insert(
       std::make_pair(kPolicyHomepageLocation,
                      Value::CreateStringValue("http://www.example.com")));
-  EXPECT_TRUE(Equals(expected, *cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(Equals(expected, mandatory_policy(cache)));
 
   scoped_ptr<em::CloudPolicyResponse> empty_policy(
       CreateHomepagePolicy("", base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   EXPECT_TRUE(cache.SetPolicy(*empty_policy));
   PolicyMapType empty;
-  EXPECT_TRUE(Equals(empty, *cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(Equals(empty, 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();
   PolicyMapType expected;
   expected.insert(
       std::make_pair(kPolicyHomepageLocation,
                      Value::CreateStringValue("http://www.example.com")));
-  EXPECT_TRUE(Equals(expected, *cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(Equals(expected, 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(
       CreateHomepagePolicy("http://www.chromium.org",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
   EXPECT_TRUE(cache.SetPolicy(*updated_policy));
 
-  cache.LoadPolicyFromFile();
+  cache.LoadFromFile();
   PolicyMapType expected;
   expected.insert(
       std::make_pair(kPolicyHomepageLocation,
                      Value::CreateStringValue("http://www.chromium.org")));
-  EXPECT_TRUE(Equals(expected, *cache.GetMandatoryPolicy()));
+  EXPECT_TRUE(Equals(expected, mandatory_policy(cache)));
 }
 
 }  // namespace policy