Home | History | Annotate | Download | only in common 
      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