// Copyright 2014 The Chromium Authors
// 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_ios.h"
#import <UIKit/UIKit.h>
#include <memory>
#include "base/apple/scoped_cftyperef.h"
#include "base/files/file_path.h"
#include "base/functional/callback.h"
#include "base/json/json_string_value_serializer.h"
#include "base/strings/sys_string_conversions.h"
#import "base/task/sequenced_task_runner.h"
#include "base/task/sequenced_task_runner.h"
#include "base/test/test_simple_task_runner.h"
#import "base/time/time.h"
#include "base/types/expected.h"
#include "base/types/expected_macros.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/policy_bundle.h"
#import "components/policy/core/common/policy_loader_ios_constants.h"
#include "components/policy/core/common/policy_map.h"
#import "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 "components/policy/core/common/schema.h"
#include "components/policy/core/common/schema_registry.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
namespace policy {
namespace {
class TestHarness : public PolicyProviderTestHarness {
public:
TestHarness(bool encode_complex_data_as_json);
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::Value::List& policy_value) override;
void InstallDictionaryPolicy(const std::string& policy_name,
const base::Value::Dict& policy_value) override;
static PolicyProviderTestHarness* Create();
static PolicyProviderTestHarness* CreateWithJSONEncoding();
private:
// Merges the policies in |policy| into the current policy dictionary
// in NSUserDefaults, after making sure that the policy dictionary
// exists.
void AddPolicies(NSDictionary* policy);
// If true, the test harness will encode complex data (dicts and lists) as
// JSON strings.
bool encode_complex_data_as_json_;
};
TestHarness::TestHarness(bool encode_complex_data_as_json)
: PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY,
POLICY_SCOPE_MACHINE,
POLICY_SOURCE_PLATFORM),
encode_complex_data_as_json_(encode_complex_data_as_json) {}
TestHarness::~TestHarness() {
// Cleanup any policies left from the test.
[[NSUserDefaults standardUserDefaults]
removeObjectForKey:kPolicyLoaderIOSConfigurationKey];
}
void TestHarness::SetUp() {
// Make sure there is no pre-existing policy present.
[[NSUserDefaults standardUserDefaults]
removeObjectForKey:kPolicyLoaderIOSConfigurationKey];
}
ConfigurationPolicyProvider* TestHarness::CreateProvider(
SchemaRegistry* registry,
scoped_refptr<base::SequencedTaskRunner> task_runner) {
return new AsyncPolicyProvider(
registry, std::make_unique<PolicyLoaderIOS>(registry, task_runner));
}
void TestHarness::InstallEmptyPolicy() {
AddPolicies(@{});
}
void TestHarness::InstallStringPolicy(const std::string& policy_name,
const std::string& policy_value) {
NSString* key = base::SysUTF8ToNSString(policy_name);
NSString* value = base::SysUTF8ToNSString(policy_value);
AddPolicies(@{
key: value
});
}
void TestHarness::InstallIntegerPolicy(const std::string& policy_name,
int policy_value) {
NSString* key = base::SysUTF8ToNSString(policy_name);
AddPolicies(@{
key: [NSNumber numberWithInt:policy_value]
});
}
void TestHarness::InstallBooleanPolicy(const std::string& policy_name,
bool policy_value) {
NSString* key = base::SysUTF8ToNSString(policy_name);
AddPolicies(@{
key: [NSNumber numberWithBool:policy_value]
});
}
void TestHarness::InstallStringListPolicy(
const std::string& policy_name,
const base::Value::List& policy_value) {
NSString* key = base::SysUTF8ToNSString(policy_name);
base::apple::ScopedCFTypeRef<CFPropertyListRef> value =
ValueToProperty(base::Value(policy_value.Clone()));
if (encode_complex_data_as_json_) {
// Convert |policy_value| to a JSON-encoded string.
std::string json_string;
JSONStringValueSerializer serializer(&json_string);
ASSERT_TRUE(serializer.Serialize(policy_value));
AddPolicies(@{key : base::SysUTF8ToNSString(json_string)});
} else {
AddPolicies(@{key : (__bridge NSArray*)(value.get())});
}
}
void TestHarness::InstallDictionaryPolicy(
const std::string& policy_name,
const base::Value::Dict& policy_value) {
NSString* key = base::SysUTF8ToNSString(policy_name);
if (encode_complex_data_as_json_) {
// Convert |policy_value| to a JSON-encoded string.
std::string json_string;
JSONStringValueSerializer serializer(&json_string);
ASSERT_TRUE(serializer.Serialize(policy_value));
AddPolicies(@{key : base::SysUTF8ToNSString(json_string)});
} else {
base::apple::ScopedCFTypeRef<CFPropertyListRef> value =
ValueToProperty(base::Value(policy_value.Clone()));
AddPolicies(@{key : (__bridge NSDictionary*)(value.get())});
}
}
// static
PolicyProviderTestHarness* TestHarness::Create() {
return new TestHarness(false);
}
// static
PolicyProviderTestHarness* TestHarness::CreateWithJSONEncoding() {
return new TestHarness(true);
}
void TestHarness::AddPolicies(NSDictionary* policy) {
NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
NSMutableDictionary* chromePolicy = [[NSMutableDictionary alloc] init];
NSDictionary* previous =
[defaults dictionaryForKey:kPolicyLoaderIOSConfigurationKey];
if (previous) {
[chromePolicy addEntriesFromDictionary:previous];
}
[chromePolicy addEntriesFromDictionary:policy];
[[NSUserDefaults standardUserDefaults]
setObject:chromePolicy
forKey:kPolicyLoaderIOSConfigurationKey];
}
} // namespace
INSTANTIATE_TEST_SUITE_P(PolicyProviderIOSChromePolicyTest,
ConfigurationPolicyProviderTest,
testing::Values(TestHarness::Create));
INSTANTIATE_TEST_SUITE_P(PolicyProviderIOSChromePolicyJSONTest,
ConfigurationPolicyProviderTest,
testing::Values(TestHarness::CreateWithJSONEncoding));
const char kTestChromeSchema[] =
"{"
" \"type\": \"object\","
" \"properties\": {"
" \"StringPolicy\": { \"type\": \"string\" },"
" }"
"}";
PolicyNamespace GetPolicyNamespace() {
return PolicyNamespace(POLICY_DOMAIN_CHROME, "");
}
// Tests cases not covered by the test harnest.
class PolicyLoaderIosTest : public PlatformTest {
protected:
PolicyLoaderIosTest()
: task_environment_(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
void SetUp() override {
auto result = RegisterSchema(GetPolicyNamespace(), kTestChromeSchema);
ASSERT_TRUE(result.has_value())
<< "Registration of schema failed with error: " << result.error();
}
void TearDown() override {
task_environment_.RunUntilIdle();
provider_->Shutdown();
// Clear App Config.
[[NSUserDefaults standardUserDefaults]
removeObjectForKey:kPolicyLoaderIOSConfigurationKey];
}
void InitProvider() {
std::unique_ptr<PolicyLoaderIOS> loader = std::make_unique<PolicyLoaderIOS>(
&schema_registry_, task_environment_.GetMainThreadTaskRunner());
provider_ = std::make_unique<AsyncPolicyProvider>(&schema_registry_,
std::move(loader));
provider_->Init(&schema_registry_);
task_environment_.RunUntilIdle();
}
base::test::TaskEnvironment task_environment_;
SchemaRegistry schema_registry_;
std::unique_ptr<AsyncPolicyProvider> provider_;
private:
base::expected<void, std::string> RegisterSchema(const PolicyNamespace& ns,
const std::string& schema) {
ASSIGN_OR_RETURN(const auto parsed_schema, Schema::Parse(schema));
schema_registry_.RegisterComponent(ns, parsed_schema);
return base::ok();
}
};
TEST_F(PolicyLoaderIosTest, ReloadIntervalWhenBrowserManagedPostStartup) {
InitProvider();
// Verify that there are no policies loaded at startup.
EXPECT_TRUE(provider_->policies().Equals(PolicyBundle()));
// Set a policy in the App Config at runtime to replicate the situation where
// the browser is put under management after startup.
NSDictionary* policies = @{@"StringPolicy" : @"string_value"};
[[NSUserDefaults standardUserDefaults]
setObject:policies
forKey:kPolicyLoaderIOSConfigurationKey];
// Verify that the new policy changes aren't picked up after 10 minutes
// when the browser wasn't managed at startup. This is to make sure that the
// first reload was scheduled with an interval of 15 minutes.
task_environment_.FastForwardBy(base::Minutes(10));
EXPECT_TRUE(provider_->policies().Equals(PolicyBundle()));
// Verify that the new policy changes are picked up after 15 minutes +
// epsilon.
task_environment_.FastForwardBy(base::Minutes(5) + base::Seconds(1));
ASSERT_TRUE(task_environment_.MainThreadIsIdle());
PolicyBundle bundle;
bundle.Get(GetPolicyNamespace())
.Set("StringPolicy", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
POLICY_SOURCE_PLATFORM, base::Value("string_value"), nullptr);
EXPECT_TRUE(provider_->policies().Equals(bundle));
// Simulate the situation where the App Config is updated with new values
// before the next reload.
NSDictionary* new_policies = @{@"StringPolicy" : @"string_value_new"};
[[NSUserDefaults standardUserDefaults]
setObject:new_policies
forKey:kPolicyLoaderIOSConfigurationKey];
// Verify that the interval was adjusted to 30 seconds after first reload.
task_environment_.FastForwardBy(base::Seconds(31));
ASSERT_TRUE(task_environment_.MainThreadIsIdle());
PolicyBundle new_bundle;
new_bundle.Get(GetPolicyNamespace())
.Set("StringPolicy", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
POLICY_SOURCE_PLATFORM, base::Value("string_value_new"), nullptr);
EXPECT_TRUE(provider_->policies().Equals(new_bundle));
}
TEST_F(PolicyLoaderIosTest, ReloadIntervalWhenManagedByPlatformBeforeStartup) {
// Set a policy in the App Config to replicate the situation where the browser
// is put under management before startup.
NSDictionary* policies = @{@"StringPolicy" : @"string_value"};
[[NSUserDefaults standardUserDefaults]
setObject:policies
forKey:kPolicyLoaderIOSConfigurationKey];
InitProvider();
// Verify that the new policy changes are picked up after 30 seconds +
// epsilon.
task_environment_.FastForwardBy(base::Seconds(31));
ASSERT_TRUE(task_environment_.MainThreadIsIdle());
PolicyBundle bundle;
bundle.Get(GetPolicyNamespace())
.Set("StringPolicy", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
POLICY_SOURCE_PLATFORM, base::Value("string_value"), nullptr);
EXPECT_TRUE(provider_->policies().Equals(bundle));
}
} // namespace policy
Codebase Browser
chromium