service_unittest.cc | Explore in Territory

// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/updater/policy/service.h"

#include <memory>
#include <optional>
#include <set>
#include <string>
#include <utility>
#include <vector>

#include "base/memory/ref_counted.h"
#include "base/time/time.h"
#include "base/values.h"
#include "chrome/updater/external_constants.h"
#include "chrome/updater/policy/dm_policy_manager.h"
#include "chrome/updater/policy/manager.h"
#include "chrome/updater/protos/omaha_settings.pb.h"
#include "testing/gtest/include/gtest/gtest.h"

#if BUILDFLAG(IS_WIN)
#include "base/test/test_reg_util_win.h"
#include "base/win/registry.h"
#include "chrome/updater/policy/win/group_policy_manager.h"
#include "chrome/updater/util/win_util.h"
#include "chrome/updater/win/win_constants.h"
#elif BUILDFLAG(IS_MAC)
#include "chrome/updater/policy/mac/managed_preference_policy_manager.h"
#endif

namespace updater {

using PolicyManagers = std::vector<scoped_refptr<PolicyManagerInterface>>;

// The Policy Manager Interface is implemented by policy managers such as Group
// Policy and Device Management.
class FakePolicyManager : public PolicyManagerInterface { … };

TEST(PolicyService, DefaultPolicyValue) { … }

TEST(PolicyService, ValidatePolicyValues) { … }

TEST(PolicyService, SinglePolicyManager) { … }

TEST(PolicyService, MultiplePolicyManagers) { … }

TEST(PolicyService, MultiplePolicyManagers_WithUnmanagedOnes) { … }

struct PolicyServiceAreUpdatesSuppressedNowTestCase { … };

class PolicyServiceAreUpdatesSuppressedNowTest
    : public ::testing::TestWithParam<
          PolicyServiceAreUpdatesSuppressedNowTestCase> { … };

INSTANTIATE_TEST_SUITE_P(…);

TEST_P(PolicyServiceAreUpdatesSuppressedNowTest, TestCases) { … }

#if BUILDFLAG(IS_WIN)
TEST(PolicyService, CreateManagers) {
  registry_util::RegistryOverrideManager registry_overrides;
  ASSERT_NO_FATAL_FAILURE(
      registry_overrides.OverrideRegistry(HKEY_LOCAL_MACHINE));

  auto omaha_settings =
      std::make_unique<::wireless_android_enterprise_devicemanagement::
                           OmahaSettingsClientProto>();
  auto dm_policy = base::MakeRefCounted<DMPolicyManager>(*omaha_settings, true);
  PolicyManagers managers =
      CreateManagers(false, CreateExternalConstants(), dm_policy);
  EXPECT_EQ(managers.size(), size_t{4});
  EXPECT_EQ(managers[0]->source(), "DictValuePolicy");
  EXPECT_EQ(managers[1]->source(), "Group Policy");
  EXPECT_EQ(managers[2]->source(), "Device Management");
  EXPECT_EQ(managers[3]->source(), "Default");

  base::win::RegKey key(HKEY_LOCAL_MACHINE, UPDATER_POLICIES_KEY,
                        Wow6432(KEY_WRITE));
  EXPECT_EQ(ERROR_SUCCESS,
            key.WriteValue(L"CloudPolicyOverridesPlatformPolicy", 1));
  managers = CreateManagers(false, CreateExternalConstants(), dm_policy);
  EXPECT_EQ(managers.size(), size_t{4});
  EXPECT_EQ(managers[0]->source(), "DictValuePolicy");
  EXPECT_EQ(managers[1]->source(), "Device Management");
  EXPECT_EQ(managers[2]->source(), "Group Policy");
  EXPECT_EQ(managers[3]->source(), "Default");
}
#elif BUILDFLAG(IS_MAC)
TEST(PolicyService, CreateManagers) {
  auto omaha_settings =
      std::make_unique<::wireless_android_enterprise_devicemanagement::
                           OmahaSettingsClientProto>();
  auto dm_policy = base::MakeRefCounted<DMPolicyManager>(*omaha_settings, true);
  PolicyManagers managers =
      CreateManagers(false, CreateExternalConstants(), dm_policy);
  EXPECT_EQ(managers.size(), size_t{4});
  EXPECT_EQ(managers[0]->source(), "DictValuePolicy");
  EXPECT_EQ(managers[1]->source(), "Device Management");
  EXPECT_EQ(managers[2]->source(), "Managed Preferences");
  EXPECT_EQ(managers[3]->source(), "Default");
}
#else
TEST(PolicyService, CreateManagers) { … }
#endif

TEST(PolicyService, PolicyServiceProxyConfiguration_Get) { … }

}  // namespace updater
chromium/chrome/updater/policy/service_unittest.cc
