1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef COMPONENTS_POLICY_CORE_COMMON_CONFIGURATION_POLICY_PROVIDER_TEST_H_ 6 #define COMPONENTS_POLICY_CORE_COMMON_CONFIGURATION_POLICY_PROVIDER_TEST_H_ 7 8 #include <string> 9 10 #include "base/basictypes.h" 11 #include "base/callback_forward.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "base/message_loop/message_loop.h" 15 #include "components/policy/core/common/policy_types.h" 16 #include "components/policy/core/common/schema.h" 17 #include "components/policy/core/common/schema_registry.h" 18 #include "testing/gtest/include/gtest/gtest.h" 19 20 namespace base { 21 class DictionaryValue; 22 class ListValue; 23 class SequencedTaskRunner; 24 class Value; 25 } 26 27 namespace policy { 28 29 class ConfigurationPolicyProvider; 30 31 namespace test_keys { 32 33 extern const char kKeyString[]; 34 extern const char kKeyBoolean[]; 35 extern const char kKeyInteger[]; 36 extern const char kKeyStringList[]; 37 extern const char kKeyDictionary[]; 38 39 } // namespace test_keys 40 41 class PolicyTestBase : public testing::Test { 42 public: 43 PolicyTestBase(); 44 virtual ~PolicyTestBase(); 45 46 // testing::Test: 47 virtual void SetUp() OVERRIDE; 48 virtual void TearDown() OVERRIDE; 49 50 protected: 51 bool RegisterSchema(const PolicyNamespace& ns, 52 const std::string& schema); 53 54 SchemaRegistry schema_registry_; 55 56 // Create an actual IO loop (needed by FilePathWatcher). 57 base::MessageLoopForIO loop_; 58 59 private: 60 DISALLOW_COPY_AND_ASSIGN(PolicyTestBase); 61 }; 62 63 // An interface for creating a test policy provider and creating a policy 64 // provider instance for testing. Used as the parameter to the abstract 65 // ConfigurationPolicyProviderTest below. 66 class PolicyProviderTestHarness { 67 public: 68 // |level| and |scope| are the level and scope of the policies returned by 69 // the providers from CreateProvider(). 70 PolicyProviderTestHarness(PolicyLevel level, PolicyScope scope); 71 virtual ~PolicyProviderTestHarness(); 72 73 // Actions to run at gtest SetUp() time. 74 virtual void SetUp() = 0; 75 76 // Create a new policy provider. 77 virtual ConfigurationPolicyProvider* CreateProvider( 78 SchemaRegistry* registry, 79 scoped_refptr<base::SequencedTaskRunner> task_runner) = 0; 80 81 // Returns the policy level and scope set by the policy provider. 82 PolicyLevel policy_level() const; 83 PolicyScope policy_scope() const; 84 85 // Helpers to configure the environment the policy provider reads from. 86 virtual void InstallEmptyPolicy() = 0; 87 virtual void InstallStringPolicy(const std::string& policy_name, 88 const std::string& policy_value) = 0; 89 virtual void InstallIntegerPolicy(const std::string& policy_name, 90 int policy_value) = 0; 91 virtual void InstallBooleanPolicy(const std::string& policy_name, 92 bool policy_value) = 0; 93 virtual void InstallStringListPolicy(const std::string& policy_name, 94 const base::ListValue* policy_value) = 0; 95 virtual void InstallDictionaryPolicy( 96 const std::string& policy_name, 97 const base::DictionaryValue* policy_value) = 0; 98 99 // Not every provider supports installing 3rd party policy. Those who do 100 // should override this method; the default just makes the test fail. 101 virtual void Install3rdPartyPolicy(const base::DictionaryValue* policies); 102 103 private: 104 PolicyLevel level_; 105 PolicyScope scope_; 106 107 DISALLOW_COPY_AND_ASSIGN(PolicyProviderTestHarness); 108 }; 109 110 // A factory method for creating a test harness. 111 typedef PolicyProviderTestHarness* (*CreatePolicyProviderTestHarness)(); 112 113 // Abstract policy provider test. This is meant to be instantiated for each 114 // policy provider implementation, passing in a suitable harness factory 115 // function as the test parameter. 116 class ConfigurationPolicyProviderTest 117 : public PolicyTestBase, 118 public testing::WithParamInterface<CreatePolicyProviderTestHarness> { 119 protected: 120 ConfigurationPolicyProviderTest(); 121 virtual ~ConfigurationPolicyProviderTest(); 122 123 virtual void SetUp() OVERRIDE; 124 virtual void TearDown() OVERRIDE; 125 126 // Installs a valid policy and checks whether the provider returns the 127 // |expected_value|. 128 void CheckValue(const char* policy_name, 129 const base::Value& expected_value, 130 base::Closure install_value); 131 132 scoped_ptr<PolicyProviderTestHarness> test_harness_; 133 scoped_ptr<ConfigurationPolicyProvider> provider_; 134 135 private: 136 DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyProviderTest); 137 }; 138 139 // An extension of ConfigurationPolicyProviderTest that also tests loading of 140 // 3rd party policy. Policy provider implementations that support loading of 141 // 3rd party policy should also instantiate these tests. 142 class Configuration3rdPartyPolicyProviderTest 143 : public ConfigurationPolicyProviderTest { 144 protected: 145 Configuration3rdPartyPolicyProviderTest(); 146 virtual ~Configuration3rdPartyPolicyProviderTest(); 147 148 private: 149 DISALLOW_COPY_AND_ASSIGN(Configuration3rdPartyPolicyProviderTest); 150 }; 151 152 } // namespace policy 153 154 #endif // COMPONENTS_POLICY_CORE_COMMON_CONFIGURATION_POLICY_PROVIDER_TEST_H_ 155