components/policy/core/common/policy_loader_mac_unittest.cc

   1 // Copyright (c) 2012 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 #include <CoreFoundation/CoreFoundation.h>
   6
   7 #include "base/basictypes.h"
   8 #include "base/callback.h"
   9 #include "base/files/file_path.h"
  10 #include "base/mac/scoped_cftyperef.h"
  11 #include "base/strings/sys_string_conversions.h"
  12 #include "base/values.h"
  13 #include "components/policy/core/common/async_policy_provider.h"
  14 #include "components/policy/core/common/configuration_policy_provider_test.h"
  15 #include "components/policy/core/common/external_data_fetcher.h"
  16 #include "components/policy/core/common/policy_bundle.h"
  17 #include "components/policy/core/common/policy_loader_mac.h"
  18 #include "components/policy/core/common/policy_map.h"
  19 #include "components/policy/core/common/policy_test_utils.h"
  20 #include "components/policy/core/common/preferences_mock_mac.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 using base::ScopedCFTypeRef;
  24
  25 namespace policy {
  26
  27 namespace {
  28
  29 class TestHarness : public PolicyProviderTestHarness {
  30  public:
  31   TestHarness();
  32   ~TestHarness() override;
  33
  34   void SetUp() override;
  35
  36   ConfigurationPolicyProvider* CreateProvider(
  37       SchemaRegistry* registry,
  38       scoped_refptr<base::SequencedTaskRunner> task_runner) override;
  39
  40   void InstallEmptyPolicy() override;
  41   void InstallStringPolicy(const std::string& policy_name,
  42                            const std::string& policy_value) override;
  43   void InstallIntegerPolicy(const std::string& policy_name,
  44                             int policy_value) override;
  45   void InstallBooleanPolicy(const std::string& policy_name,
  46                             bool policy_value) override;
  47   void InstallStringListPolicy(const std::string& policy_name,
  48                                const base::ListValue* policy_value) override;
  49   void InstallDictionaryPolicy(
  50       const std::string& policy_name,
  51       const base::DictionaryValue* policy_value) override;
  52
  53   static PolicyProviderTestHarness* Create();
  54
  55  private:
  56   MockPreferences* prefs_;
  57
  58   DISALLOW_COPY_AND_ASSIGN(TestHarness);
  59 };
  60
  61 TestHarness::TestHarness()
  62     : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER) {}
  63
  64 TestHarness::~TestHarness() {}
  65
  66 void TestHarness::SetUp() {}
  67
  68 ConfigurationPolicyProvider* TestHarness::CreateProvider(
  69     SchemaRegistry* registry,
  70     scoped_refptr<base::SequencedTaskRunner> task_runner) {
  71   prefs_ = new MockPreferences();
  72   scoped_ptr<AsyncPolicyLoader> loader(
  73       new PolicyLoaderMac(task_runner, base::FilePath(), prefs_));
  74   return new AsyncPolicyProvider(registry, loader.Pass());
  75 }
  76
  77 void TestHarness::InstallEmptyPolicy() {}
  78
  79 void TestHarness::InstallStringPolicy(const std::string& policy_name,
  80                                       const std::string& policy_value) {
  81   ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
  82   ScopedCFTypeRef<CFStringRef> value(base::SysUTF8ToCFStringRef(policy_value));
  83   prefs_->AddTestItem(name, value, true);
  84 }
  85
  86 void TestHarness::InstallIntegerPolicy(const std::string& policy_name,
  87                                        int policy_value) {
  88   ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
  89   ScopedCFTypeRef<CFNumberRef> value(
  90       CFNumberCreate(NULL, kCFNumberIntType, &policy_value));
  91   prefs_->AddTestItem(name, value, true);
  92 }
  93
  94 void TestHarness::InstallBooleanPolicy(const std::string& policy_name,
  95                                        bool policy_value) {
  96   ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
  97   prefs_->AddTestItem(name,
  98                       policy_value ? kCFBooleanTrue : kCFBooleanFalse,
  99                       true);
 100 }
 101
 102 void TestHarness::InstallStringListPolicy(const std::string& policy_name,
 103                                           const base::ListValue* policy_value) {
 104   ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
 105   ScopedCFTypeRef<CFPropertyListRef> array(ValueToProperty(policy_value));
 106   ASSERT_TRUE(array);
 107   prefs_->AddTestItem(name, array, true);
 108 }
 109
 110 void TestHarness::InstallDictionaryPolicy(
 111     const std::string& policy_name,
 112     const base::DictionaryValue* policy_value) {
 113   ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
 114   ScopedCFTypeRef<CFPropertyListRef> dict(ValueToProperty(policy_value));
 115   ASSERT_TRUE(dict);
 116   prefs_->AddTestItem(name, dict, true);
 117 }
 118
 119 // static
 120 PolicyProviderTestHarness* TestHarness::Create() {
 121   return new TestHarness();
 122 }
 123
 124 }  // namespace
 125
 126 // Instantiate abstract test case for basic policy reading tests.
 127 INSTANTIATE_TEST_CASE_P(
 128     PolicyProviderMacTest,
 129     ConfigurationPolicyProviderTest,
 130     testing::Values(TestHarness::Create));
 131
 132 // TODO(joaodasilva): instantiate Configuration3rdPartyPolicyProviderTest too
 133 // once the mac loader supports 3rd party policy. http://crbug.com/108995
 134
 135 // Special test cases for some mac preferences details.
 136 class PolicyLoaderMacTest : public PolicyTestBase {
 137  protected:
 138   PolicyLoaderMacTest()
 139       : prefs_(new MockPreferences()) {}
 140
 141   void SetUp() override {
 142     PolicyTestBase::SetUp();
 143     scoped_ptr<AsyncPolicyLoader> loader(
 144         new PolicyLoaderMac(loop_.task_runner(), base::FilePath(), prefs_));
 145     provider_.reset(new AsyncPolicyProvider(&schema_registry_, loader.Pass()));
 146     provider_->Init(&schema_registry_);
 147   }
 148
 149   void TearDown() override {
 150     provider_->Shutdown();
 151     PolicyTestBase::TearDown();
 152   }
 153
 154   MockPreferences* prefs_;
 155   scoped_ptr<AsyncPolicyProvider> provider_;
 156 };
 157
 158 TEST_F(PolicyLoaderMacTest, Invalid) {
 159   ScopedCFTypeRef<CFStringRef> name(
 160       base::SysUTF8ToCFStringRef(test_keys::kKeyString));
 161   const char buffer[] = "binary \xde\xad\xbe\xef data";
 162   ScopedCFTypeRef<CFDataRef> invalid_data(
 163       CFDataCreate(kCFAllocatorDefault,
 164                    reinterpret_cast<const UInt8 *>(buffer),
 165                    arraysize(buffer)));
 166   ASSERT_TRUE(invalid_data);
 167   prefs_->AddTestItem(name, invalid_data.get(), true);
 168   prefs_->AddTestItem(name, invalid_data.get(), false);
 169
 170   // Make the provider read the updated |prefs_|.
 171   provider_->RefreshPolicies();
 172   loop_.RunUntilIdle();
 173   const PolicyBundle kEmptyBundle;
 174   EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
 175 }
 176
 177 TEST_F(PolicyLoaderMacTest, TestNonForcedValue) {
 178   ScopedCFTypeRef<CFStringRef> name(
 179       base::SysUTF8ToCFStringRef(test_keys::kKeyString));
 180   ScopedCFTypeRef<CFPropertyListRef> test_value(
 181       base::SysUTF8ToCFStringRef("string value"));
 182   ASSERT_TRUE(test_value.get());
 183   prefs_->AddTestItem(name, test_value.get(), false);
 184
 185   // Make the provider read the updated |prefs_|.
 186   provider_->RefreshPolicies();
 187   loop_.RunUntilIdle();
 188   PolicyBundle expected_bundle;
 189   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
 190       .Set(test_keys::kKeyString,
 191            POLICY_LEVEL_RECOMMENDED,
 192            POLICY_SCOPE_USER,
 193            new base::StringValue("string value"),
 194            NULL);
 195   EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
 196 }
 197
 198 }  // namespace policy