1 files changed, 201 insertions, 0 deletions
diff --git a/chromium/components/policy/core/common/policy_loader_mac_unittest.cc b/chromium/components/policy/core/common/policy_loader_mac_unittest.cc
new file mode 100644
index 00000000000..c8f0ca85231
--- /dev/null
+++ b/chromium/components/policy/core/common/policy_loader_mac_unittest.cc
@@ -0,0 +1,201 @@
+// Copyright (c) 2012 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/policy_loader_mac.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <memory>
+#include <utility>
+
+#include "base/callback.h"
+#include "base/files/file_path.h"
+#include "base/mac/scoped_cftyperef.h"
+#include "base/run_loop.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/task/sequenced_task_runner.h"
+#include "base/values.h"
+#include "components/policy/core/common/async_policy_provider.h"
+#include "components/policy/core/common/configuration_policy_provider_test.h"
+#include "components/policy/core/common/external_data_fetcher.h"
+#include "components/policy/core/common/policy_bundle.h"
+#include "components/policy/core/common/policy_map.h"
+#include "components/policy/core/common/policy_test_utils.h"
+#include "components/policy/core/common/policy_types.h"
+#include "components/policy/core/common/preferences_mock_mac.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using base::ScopedCFTypeRef;
+
+namespace policy {
+
+namespace {
+
+class TestHarness : public PolicyProviderTestHarness {
+ public:
+  TestHarness();
+  TestHarness(const TestHarness&) = delete;
+  TestHarness& operator=(const TestHarness&) = delete;
+  ~TestHarness() override;
+
+  void SetUp() override;
+
+  ConfigurationPolicyProvider* CreateProvider(
+      SchemaRegistry* registry,
+      scoped_refptr<base::SequencedTaskRunner> task_runner) override;
+
+  void InstallEmptyPolicy() override;
+  void InstallStringPolicy(const std::string& policy_name,
+                           const std::string& policy_value) override;
+  void InstallIntegerPolicy(const std::string& policy_name,
+                            int policy_value) override;
+  void InstallBooleanPolicy(const std::string& policy_name,
+                            bool policy_value) override;
+  void InstallStringListPolicy(const std::string& policy_name,
+                               const base::ListValue* policy_value) override;
+  void InstallDictionaryPolicy(const std::string& policy_name,
+                               const base::Value* policy_value) override;
+
+  static PolicyProviderTestHarness* Create();
+
+ private:
+  MockPreferences* prefs_;
+};
+
+TestHarness::TestHarness()
+    : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY,
+                                POLICY_SCOPE_MACHINE,
+                                POLICY_SOURCE_PLATFORM) {}
+
+TestHarness::~TestHarness() {}
+
+void TestHarness::SetUp() {}
+
+ConfigurationPolicyProvider* TestHarness::CreateProvider(
+    SchemaRegistry* registry,
+    scoped_refptr<base::SequencedTaskRunner> task_runner) {
+  prefs_ = new MockPreferences();
+  std::unique_ptr<AsyncPolicyLoader> loader(
+      new PolicyLoaderMac(task_runner, base::FilePath(), prefs_));
+  return new AsyncPolicyProvider(registry, std::move(loader));
+}
+
+void TestHarness::InstallEmptyPolicy() {}
+
+void TestHarness::InstallStringPolicy(const std::string& policy_name,
+                                      const std::string& policy_value) {
+  ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
+  ScopedCFTypeRef<CFStringRef> value(base::SysUTF8ToCFStringRef(policy_value));
+  prefs_->AddTestItem(name, value, true);
+}
+
+void TestHarness::InstallIntegerPolicy(const std::string& policy_name,
+                                       int policy_value) {
+  ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
+  ScopedCFTypeRef<CFNumberRef> value(
+      CFNumberCreate(NULL, kCFNumberIntType, &policy_value));
+  prefs_->AddTestItem(name, value, true);
+}
+
+void TestHarness::InstallBooleanPolicy(const std::string& policy_name,
+                                       bool policy_value) {
+  ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
+  prefs_->AddTestItem(name,
+                      policy_value ? kCFBooleanTrue : kCFBooleanFalse,
+                      true);
+}
+
+void TestHarness::InstallStringListPolicy(const std::string& policy_name,
+                                          const base::ListValue* policy_value) {
+  ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
+  ScopedCFTypeRef<CFPropertyListRef> array(ValueToProperty(*policy_value));
+  ASSERT_TRUE(array);
+  prefs_->AddTestItem(name, array, true);
+}
+
+void TestHarness::InstallDictionaryPolicy(const std::string& policy_name,
+                                          const base::Value* policy_value) {
+  ScopedCFTypeRef<CFStringRef> name(base::SysUTF8ToCFStringRef(policy_name));
+  ScopedCFTypeRef<CFPropertyListRef> dict(ValueToProperty(*policy_value));
+  ASSERT_TRUE(dict);
+  prefs_->AddTestItem(name, dict, true);
+}
+
+// static
+PolicyProviderTestHarness* TestHarness::Create() {
+  return new TestHarness();
+}
+
+}  // namespace
+
+// Instantiate abstract test case for basic policy reading tests.
+INSTANTIATE_TEST_SUITE_P(PolicyProviderMacTest,
+                         ConfigurationPolicyProviderTest,
+                         testing::Values(TestHarness::Create));
+
+// TODO(joaodasilva): instantiate Configuration3rdPartyPolicyProviderTest too
+// once the mac loader supports 3rd party policy. http://crbug.com/108995
+
+// Special test cases for some mac preferences details.
+class PolicyLoaderMacTest : public PolicyTestBase {
+ protected:
+  PolicyLoaderMacTest()
+      : prefs_(new MockPreferences()) {}
+
+  void SetUp() override {
+    PolicyTestBase::SetUp();
+    std::unique_ptr<AsyncPolicyLoader> loader(new PolicyLoaderMac(
+        task_environment_.GetMainThreadTaskRunner(), base::FilePath(), prefs_));
+    provider_ = std::make_unique<AsyncPolicyProvider>(&schema_registry_,
+                                                      std::move(loader));
+    provider_->Init(&schema_registry_);
+  }
+
+  void TearDown() override {
+    provider_->Shutdown();
+    PolicyTestBase::TearDown();
+  }
+
+  MockPreferences* prefs_;
+  std::unique_ptr<AsyncPolicyProvider> provider_;
+};
+
+TEST_F(PolicyLoaderMacTest, Invalid) {
+  ScopedCFTypeRef<CFStringRef> name(
+      base::SysUTF8ToCFStringRef(test_keys::kKeyString));
+  const char buffer[] = "binary \xde\xad\xbe\xef data";
+  ScopedCFTypeRef<CFDataRef> invalid_data(
+      CFDataCreate(kCFAllocatorDefault, reinterpret_cast<const UInt8*>(buffer),
+                   std::size(buffer)));
+  ASSERT_TRUE(invalid_data);
+  prefs_->AddTestItem(name, invalid_data.get(), true);
+  prefs_->AddTestItem(name, invalid_data.get(), false);
+
+  // Make the provider read the updated |prefs_|.
+  provider_->RefreshPolicies();
+  task_environment_.RunUntilIdle();
+  const PolicyBundle kEmptyBundle;
+  EXPECT_TRUE(provider_->policies().Equals(kEmptyBundle));
+}
+
+TEST_F(PolicyLoaderMacTest, TestNonForcedValue) {
+  ScopedCFTypeRef<CFStringRef> name(
+      base::SysUTF8ToCFStringRef(test_keys::kKeyString));
+  ScopedCFTypeRef<CFPropertyListRef> test_value(
+      base::SysUTF8ToCFStringRef("string value"));
+  ASSERT_TRUE(test_value.get());
+  prefs_->AddTestItem(name, test_value.get(), false);
+
+  // Make the provider read the updated |prefs_|.
+  provider_->RefreshPolicies();
+  task_environment_.RunUntilIdle();
+  PolicyBundle expected_bundle;
+  expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
+      .Set(test_keys::kKeyString, POLICY_LEVEL_RECOMMENDED,
+           POLICY_SCOPE_MACHINE, POLICY_SOURCE_PLATFORM,
+           base::Value("string value"), nullptr);
+  EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
+}
+
+}  // namespace policy