Drop non-user policy in ConfigDirPolicyLoader on Chrome OS.

components/policy/core/common/configuration_policy_provider_test.cc

 // Copyright 2013 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 "components/policy/core/common/configuration_policy_provider_test.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/policy/core/common/configuration_policy_provider.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_namespace.h"
+#include "components/policy/core/common/policy_test_utils.h"
 #include "components/policy/core/common/policy_types.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::Mock;
 using ::testing::_;
 
-namespace policy {
+namespace {
 
 const char kTestChromeSchema[] =
     "{"
     "  \"type\": \"object\","
     "  \"properties\": {"
     "    \"StringPolicy\": { \"type\": \"string\" },"
     "    \"BooleanPolicy\": { \"type\": \"boolean\" },"
     "    \"IntegerPolicy\": { \"type\": \"integer\" },"
     "    \"StringListPolicy\": {"
     "      \"type\": \"array\","
@@ skipping 71 matching lines @@
     "                }"
     "              }"
     "            }"
     "          }"
     "        }"
     "      }"
     "    }"
     "  }"
     "}";
 
+}  // anonymous namespace
+
+namespace policy {
+
 namespace test_keys {
 
+// These are the defaults for PolicyProviderTestHarness but they are generally
+// available for use in other tests.  Subclasses of PolicyProviderTestHarness
+// may use different values.
 const char kKeyString[] = "StringPolicy";
 const char kKeyBoolean[] = "BooleanPolicy";
 const char kKeyInteger[] = "IntegerPolicy";
 const char kKeyStringList[] = "StringListPolicy";
 const char kKeyDictionary[] = "DictionaryPolicy";
 
 }  // namespace test_keys
 
 PolicyTestBase::PolicyTestBase() {}
 
@@ skipping 16 matching lines @@
     schema_registry_.RegisterComponent(ns, schema);
     return true;
   }
   ADD_FAILURE() << error;
   return false;
 }
 
 PolicyProviderTestHarness::PolicyProviderTestHarness(PolicyLevel level,
                                                      PolicyScope scope,
                                                      PolicySource source)
-    : level_(level), scope_(scope), source_(source) {}
+    : key_string_(test_keys::kKeyString),
+      key_boolean_(test_keys::kKeyBoolean),
+      key_integer_(test_keys::kKeyInteger),
+      key_stringlist_(test_keys::kKeyStringList),
+      key_dictionary_(test_keys::kKeyDictionary),
+      test_schema_(kTestChromeSchema),
+      level_(level),
+      scope_(scope),
+      source_(source) {
+}
 
 PolicyProviderTestHarness::~PolicyProviderTestHarness() {}
 
-PolicyLevel PolicyProviderTestHarness::policy_level() const {
-  return level_;
-}
-
-PolicyScope PolicyProviderTestHarness::policy_scope() const {
-  return scope_;
-}
-
-PolicySource PolicyProviderTestHarness::policy_source() const {
-  return source_;
-}
-
 void PolicyProviderTestHarness::Install3rdPartyPolicy(
     const base::DictionaryValue* policies) {
   FAIL();
 }
 
 ConfigurationPolicyProviderTest::ConfigurationPolicyProviderTest() {}
 
 ConfigurationPolicyProviderTest::~ConfigurationPolicyProviderTest() {}
 
 void ConfigurationPolicyProviderTest::SetUp() {
-  PolicyTestBase::SetUp();
-
-  test_harness_.reset((*GetParam())());
-  test_harness_->SetUp();
+  harness_.reset((*GetParam())());
+  harness_->SetUp();
 
   const PolicyNamespace chrome_ns(POLICY_DOMAIN_CHROME, "");
+  ASSERT_TRUE(RegisterSchema(chrome_ns, harness_->test_schema()));
+
   Schema chrome_schema = *schema_registry_.schema_map()->GetSchema(chrome_ns);
   Schema extension_schema =
-      chrome_schema.GetKnownProperty(test_keys::kKeyDictionary);
+      chrome_schema.GetKnownProperty(harness_->key_dictionary());
   ASSERT_TRUE(extension_schema.valid());
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
       extension_schema);
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
       extension_schema);
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                       "cccccccccccccccccccccccccccccccc"),
       extension_schema);
 
   provider_.reset(
-      test_harness_->CreateProvider(&schema_registry_, loop_.task_runner()));
+      harness_->CreateProvider(&schema_registry_, loop_.task_runner()));
   provider_->Init(&schema_registry_);
   // Some providers do a reload on init. Make sure any notifications generated
   // are fired now.
   loop_.RunUntilIdle();
 
   const PolicyBundle kEmptyBundle;
   EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
 }
 
 void ConfigurationPolicyProviderTest::TearDown() {
   // Give providers the chance to clean up after themselves on the file thread.
-  provider_->Shutdown();
-  provider_.reset();
+  if (provider_) {
+    provider_->Shutdown();
+    provider_.reset();
+  }
 
   PolicyTestBase::TearDown();
 }
 
 void ConfigurationPolicyProviderTest::CheckValue(
     const char* policy_name,
     const base::Value& expected_value,
     base::Closure install_value) {
   // Install the value, reload policy and check the provider for the value.
   install_value.Run();
   provider_->RefreshPolicies();
   loop_.RunUntilIdle();
   PolicyBundle expected_bundle;
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
-      .Set(policy_name, test_harness_->policy_level(),
-           test_harness_->policy_scope(), test_harness_->policy_source(),
-           expected_value.CreateDeepCopy(), nullptr);
-  EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
+      .Set(policy_name, harness_->policy_level(), harness_->policy_scope(),
+           harness_->policy_source(), expected_value.CreateDeepCopy(), nullptr);
+  bool match = provider_->policies().Equals(expected_bundle);
+  if (!match) {
+    LOG(ERROR) << "EXPECTED: " << expected_bundle;
+    LOG(ERROR) << "ACTUAL: " << provider_->policies();
+  }
+  EXPECT_TRUE(match);
   // TODO(joaodasilva): set the policy in the POLICY_DOMAIN_EXTENSIONS too,
   // and extend the |expected_bundle|, once all providers are ready.
 }
 
 TEST_P(ConfigurationPolicyProviderTest, Empty) {
   provider_->RefreshPolicies();
   loop_.RunUntilIdle();
   const PolicyBundle kEmptyBundle;
   EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, StringValue) {
   const char kTestString[] = "string_value";
   base::StringValue expected_value(kTestString);
-  CheckValue(test_keys::kKeyString,
+  CheckValue(harness_->key_string(),
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallStringPolicy,
-                        base::Unretained(test_harness_.get()),
-                        test_keys::kKeyString,
+                        base::Unretained(harness_.get()),
+                        harness_->key_string(),
                         kTestString));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, BooleanValue) {
   base::FundamentalValue expected_value(true);
-  CheckValue(test_keys::kKeyBoolean,
+  CheckValue(harness_->key_boolean(),
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallBooleanPolicy,
-                        base::Unretained(test_harness_.get()),
-                        test_keys::kKeyBoolean,
+                        base::Unretained(harness_.get()),
+                        harness_->key_boolean(),
                         true));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, IntegerValue) {
   base::FundamentalValue expected_value(42);
-  CheckValue(test_keys::kKeyInteger,
+  CheckValue(harness_->key_integer(),
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallIntegerPolicy,
-                        base::Unretained(test_harness_.get()),
-                        test_keys::kKeyInteger,
+                        base::Unretained(harness_.get()),
+                        harness_->key_integer(),
                         42));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, StringListValue) {
   base::ListValue expected_value;
   expected_value.Set(0U, new base::StringValue("first"));
   expected_value.Set(1U, new base::StringValue("second"));
-  CheckValue(test_keys::kKeyStringList,
+  CheckValue(harness_->key_stringlist(),
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallStringListPolicy,
-                        base::Unretained(test_harness_.get()),
-                        test_keys::kKeyStringList,
+                        base::Unretained(harness_.get()),
+                        harness_->key_stringlist(),
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, DictionaryValue) {
   base::DictionaryValue expected_value;
   expected_value.SetBoolean("bool", true);
   expected_value.SetDouble("double", 123.456);
   expected_value.SetInteger("int", 123);
   expected_value.SetString("string", "omg");
 
   base::ListValue* list = new base::ListValue();
   list->Set(0U, new base::StringValue("first"));
   list->Set(1U, new base::StringValue("second"));
   expected_value.Set("array", list);
 
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("sub", "value");
   list = new base::ListValue();
   std::unique_ptr<base::DictionaryValue> sub(new base::DictionaryValue());
   sub->SetInteger("aaa", 111);
   sub->SetInteger("bbb", 222);
   list->Append(std::move(sub));
   sub.reset(new base::DictionaryValue());
   sub->SetString("ccc", "333");
   sub->SetString("ddd", "444");
   list->Append(std::move(sub));
   dict->Set("sublist", list);
   expected_value.Set("dictionary", dict);
 
-  CheckValue(test_keys::kKeyDictionary,
+  CheckValue(harness_->key_dictionary(),
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallDictionaryPolicy,
-                        base::Unretained(test_harness_.get()),
-                        test_keys::kKeyDictionary,
+                        base::Unretained(harness_.get()),
+                        harness_->key_dictionary(),
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, RefreshPolicies) {
   PolicyBundle bundle;
   EXPECT_TRUE(provider_->policies().Equals(bundle));
 
   // OnUpdatePolicy is called even when there are no changes.
   MockConfigurationPolicyObserver observer;
   provider_->AddObserver(&observer);
   EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
   provider_->RefreshPolicies();
   loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   EXPECT_TRUE(provider_->policies().Equals(bundle));
 
   // OnUpdatePolicy is called when there are changes.
-  test_harness_->InstallStringPolicy(test_keys::kKeyString, "value");
+  harness_->InstallStringPolicy(harness_->key_string(), "value");
   EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
   provider_->RefreshPolicies();
   loop_.RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer);
 
   bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
-      .Set(test_keys::kKeyString, test_harness_->policy_level(),
-           test_harness_->policy_scope(), test_harness_->policy_source(),
+      .Set(harness_->key_string(), harness_->policy_level(),
+           harness_->policy_scope(), harness_->policy_source(),
            base::WrapUnique(new base::StringValue("value")), nullptr);
   EXPECT_TRUE(provider_->policies().Equals(bundle));
   provider_->RemoveObserver(&observer);
 }
 
 Configuration3rdPartyPolicyProviderTest::
     Configuration3rdPartyPolicyProviderTest() {}
 
 Configuration3rdPartyPolicyProviderTest::
     ~Configuration3rdPartyPolicyProviderTest() {}
 
 TEST_P(Configuration3rdPartyPolicyProviderTest, Load3rdParty) {
   base::DictionaryValue policy_dict;
   policy_dict.SetBoolean("bool", true);
   policy_dict.SetDouble("double", 123.456);
   policy_dict.SetInteger("int", 789);
   policy_dict.SetString("string", "string value");
 
   base::ListValue* list = new base::ListValue();
   for (int i = 0; i < 2; ++i) {
     std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetInteger("subdictindex", i);
     dict->Set("subdict", policy_dict.DeepCopy());
     list->Append(std::move(dict));
   }
   policy_dict.Set("list", list);
   policy_dict.Set("dict", policy_dict.DeepCopy());
 
   // Install these policies as a Chrome policy.
-  test_harness_->InstallDictionaryPolicy(test_keys::kKeyDictionary,
-                                         &policy_dict);
+  harness_->InstallDictionaryPolicy(harness_->key_dictionary(), &policy_dict);
   // Install them as 3rd party policies too.
   base::DictionaryValue policy_3rdparty;
   policy_3rdparty.Set("extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                       policy_dict.DeepCopy());
   policy_3rdparty.Set("extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
                       policy_dict.DeepCopy());
   // Install invalid 3rd party policies that shouldn't be loaded. These also
   // help detecting memory leaks in the code paths that detect invalid input.
   policy_3rdparty.Set("invalid-domain.component", policy_dict.DeepCopy());
   policy_3rdparty.Set("extensions.cccccccccccccccccccccccccccccccc",
                       new base::StringValue("invalid-value"));
-  test_harness_->Install3rdPartyPolicy(&policy_3rdparty);
+  harness_->Install3rdPartyPolicy(&policy_3rdparty);
 
   provider_->RefreshPolicies();
   loop_.RunUntilIdle();
 
   PolicyMap expected_policy;
-  expected_policy.Set(test_keys::kKeyDictionary, test_harness_->policy_level(),
-                      test_harness_->policy_scope(),
-                      test_harness_->policy_source(),
+  expected_policy.Set(harness_->key_dictionary(), harness_->policy_level(),
+                      harness_->policy_scope(), harness_->policy_source(),
                       policy_dict.CreateDeepCopy(), nullptr);
   PolicyBundle expected_bundle;
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .CopyFrom(expected_policy);
   expected_policy.Clear();
   expected_policy.LoadFrom(&policy_dict,
-                           test_harness_->policy_level(),
-                           test_harness_->policy_scope(),
-                           test_harness_->policy_source());
+                           harness_->policy_level(),
+                           harness_->policy_scope(),
+                           harness_->policy_source());
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
       .CopyFrom(expected_policy);
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
       .CopyFrom(expected_policy);
   EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
 }
 
 }  // namespace policy