src/components/policy/core/common/policy_loader_win_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 "components/policy/core/common/policy_loader_win.h"
   6
   7 #include <windows.h>
   8 #include <userenv.h>
   9
  10 #include <algorithm>
  11 #include <cstring>
  12 #include <functional>
  13 #include <iterator>
  14 #include <vector>
  15
  16 #include "base/base_paths.h"
  17 #include "base/callback.h"
  18 #include "base/file_util.h"
  19 #include "base/files/file_path.h"
  20 #include "base/files/scoped_temp_dir.h"
  21 #include "base/json/json_writer.h"
  22 #include "base/path_service.h"
  23 #include "base/process/process.h"
  24 #include "base/strings/string16.h"
  25 #include "base/strings/string_number_conversions.h"
  26 #include "base/strings/string_util.h"
  27 #include "base/strings/stringprintf.h"
  28 #include "base/strings/utf_string_conversions.h"
  29 #include "base/sys_byteorder.h"
  30 #include "base/win/registry.h"
  31 #include "base/win/win_util.h"
  32 #include "components/policy/core/common/async_policy_provider.h"
  33 #include "components/policy/core/common/configuration_policy_provider_test.h"
  34 #include "components/policy/core/common/external_data_fetcher.h"
  35 #include "components/policy/core/common/policy_bundle.h"
  36 #include "components/policy/core/common/policy_map.h"
  37 #include "components/policy/core/common/preg_parser_win.h"
  38 #include "components/policy/core/common/schema_map.h"
  39 #include "testing/gtest/include/gtest/gtest.h"
  40
  41 using base::UTF8ToUTF16;
  42 using base::UTF16ToUTF8;
  43 using base::win::RegKey;
  44
  45 namespace policy {
  46
  47 namespace {
  48
  49 // Constants for registry key names.
  50 const wchar_t kPathSep[] = L"\\";
  51 const wchar_t kThirdParty[] = L"3rdparty";
  52 const wchar_t kMandatory[] = L"policy";
  53 const wchar_t kRecommended[] = L"recommended";
  54 const char kSchema[] = "schema";
  55 const wchar_t kTestPolicyKey[] = L"chrome.policy.key";
  56
  57 // Installs |value| in the given registry |path| and |hive|, under the key
  58 // |name|. Returns false on errors.
  59 // Some of the possible Value types are stored after a conversion (e.g. doubles
  60 // are stored as strings), and can only be retrieved if a corresponding schema
  61 // is written.
  62 bool InstallValue(const base::Value& value,
  63                   HKEY hive,
  64                   const base::string16& path,
  65                   const base::string16& name) {
  66   // KEY_ALL_ACCESS causes the ctor to create the key if it does not exist yet.
  67   RegKey key(hive, path.c_str(), KEY_ALL_ACCESS);
  68   EXPECT_TRUE(key.Valid());
  69   switch (value.GetType()) {
  70     case base::Value::TYPE_NULL:
  71       return key.WriteValue(name.c_str(), L"") == ERROR_SUCCESS;
  72
  73     case base::Value::TYPE_BOOLEAN: {
  74       bool bool_value;
  75       if (!value.GetAsBoolean(&bool_value))
  76         return false;
  77       return key.WriteValue(name.c_str(), bool_value ? 1 : 0) == ERROR_SUCCESS;
  78     }
  79
  80     case base::Value::TYPE_INTEGER: {
  81       int int_value;
  82       if (!value.GetAsInteger(&int_value))
  83         return false;
  84       return key.WriteValue(name.c_str(), int_value) == ERROR_SUCCESS;
  85     }
  86
  87     case base::Value::TYPE_DOUBLE: {
  88       double double_value;
  89       if (!value.GetAsDouble(&double_value))
  90         return false;
  91       base::string16 str_value =
  92           UTF8ToUTF16(base::DoubleToString(double_value));
  93       return key.WriteValue(name.c_str(), str_value.c_str()) == ERROR_SUCCESS;
  94     }
  95
  96     case base::Value::TYPE_STRING: {
  97       base::string16 str_value;
  98       if (!value.GetAsString(&str_value))
  99         return false;
 100       return key.WriteValue(name.c_str(), str_value.c_str()) == ERROR_SUCCESS;
 101     }
 102
 103     case base::Value::TYPE_DICTIONARY: {
 104       const base::DictionaryValue* sub_dict = NULL;
 105       if (!value.GetAsDictionary(&sub_dict))
 106         return false;
 107       for (base::DictionaryValue::Iterator it(*sub_dict);
 108            !it.IsAtEnd(); it.Advance()) {
 109         if (!InstallValue(it.value(), hive, path + kPathSep + name,
 110                           UTF8ToUTF16(it.key()))) {
 111           return false;
 112         }
 113       }
 114       return true;
 115     }
 116
 117     case base::Value::TYPE_LIST: {
 118       const base::ListValue* list = NULL;
 119       if (!value.GetAsList(&list))
 120         return false;
 121       for (size_t i = 0; i < list->GetSize(); ++i) {
 122         const base::Value* item;
 123         if (!list->Get(i, &item))
 124           return false;
 125         if (!InstallValue(*item, hive, path + kPathSep + name,
 126                           base::UintToString16(i + 1))) {
 127           return false;
 128         }
 129       }
 130       return true;
 131     }
 132
 133     case base::Value::TYPE_BINARY:
 134       return false;
 135   }
 136   NOTREACHED();
 137   return false;
 138 }
 139
 140 // This class provides sandboxing and mocking for the parts of the Windows
 141 // Registry implementing Group Policy. It prepares two temporary sandbox keys,
 142 // one for HKLM and one for HKCU. A test's calls to the registry are redirected
 143 // by Windows to these sandboxes, allowing the tests to manipulate and access
 144 // policy as if it were active, but without actually changing the parts of the
 145 // Registry that are managed by Group Policy.
 146 class ScopedGroupPolicyRegistrySandbox {
 147  public:
 148   ScopedGroupPolicyRegistrySandbox();
 149   ~ScopedGroupPolicyRegistrySandbox();
 150
 151  private:
 152   void ActivateOverrides();
 153   void RemoveOverrides();
 154
 155   // Deletes the sandbox keys.
 156   void DeleteKeys();
 157
 158   std::wstring key_name_;
 159
 160   // Keys are created for the lifetime of a test to contain
 161   // the sandboxed HKCU and HKLM hives, respectively.
 162   RegKey temp_hkcu_hive_key_;
 163   RegKey temp_hklm_hive_key_;
 164
 165   DISALLOW_COPY_AND_ASSIGN(ScopedGroupPolicyRegistrySandbox);
 166 };
 167
 168 // A test harness that feeds policy via the Chrome GPO registry subtree.
 169 class RegistryTestHarness : public PolicyProviderTestHarness,
 170                             public AppliedGPOListProvider {
 171  public:
 172   RegistryTestHarness(HKEY hive, PolicyScope scope);
 173   virtual ~RegistryTestHarness();
 174
 175   // PolicyProviderTestHarness:
 176   virtual void SetUp() OVERRIDE;
 177
 178   virtual ConfigurationPolicyProvider* CreateProvider(
 179       SchemaRegistry* registry,
 180       scoped_refptr<base::SequencedTaskRunner> task_runner) OVERRIDE;
 181
 182   virtual void InstallEmptyPolicy() OVERRIDE;
 183   virtual void InstallStringPolicy(const std::string& policy_name,
 184                                    const std::string& policy_value) OVERRIDE;
 185   virtual void InstallIntegerPolicy(const std::string& policy_name,
 186                                     int policy_value) OVERRIDE;
 187   virtual void InstallBooleanPolicy(const std::string& policy_name,
 188                                     bool policy_value) OVERRIDE;
 189   virtual void InstallStringListPolicy(
 190       const std::string& policy_name,
 191       const base::ListValue* policy_value) OVERRIDE;
 192   virtual void InstallDictionaryPolicy(
 193       const std::string& policy_name,
 194       const base::DictionaryValue* policy_value) OVERRIDE;
 195   virtual void Install3rdPartyPolicy(
 196       const base::DictionaryValue* policies) OVERRIDE;
 197
 198   // AppliedGPOListProvider:
 199   virtual DWORD GetAppliedGPOList(DWORD flags,
 200                                   LPCTSTR machine_name,
 201                                   PSID sid_user,
 202                                   GUID* extension_guid,
 203                                   PGROUP_POLICY_OBJECT* gpo_list) OVERRIDE;
 204   virtual BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) OVERRIDE;
 205
 206   // Creates a harness instance that will install policy in HKCU or HKLM,
 207   // respectively.
 208   static PolicyProviderTestHarness* CreateHKCU();
 209   static PolicyProviderTestHarness* CreateHKLM();
 210
 211  private:
 212   HKEY hive_;
 213
 214   ScopedGroupPolicyRegistrySandbox registry_sandbox_;
 215
 216   DISALLOW_COPY_AND_ASSIGN(RegistryTestHarness);
 217 };
 218
 219 // A test harness that generates PReg files for the provider to read.
 220 class PRegTestHarness : public PolicyProviderTestHarness,
 221                         public AppliedGPOListProvider {
 222  public:
 223   PRegTestHarness();
 224   virtual ~PRegTestHarness();
 225
 226   // PolicyProviderTestHarness:
 227   virtual void SetUp() OVERRIDE;
 228
 229   virtual ConfigurationPolicyProvider* CreateProvider(
 230       SchemaRegistry* registry,
 231       scoped_refptr<base::SequencedTaskRunner> task_runner) OVERRIDE;
 232
 233   virtual void InstallEmptyPolicy() OVERRIDE;
 234   virtual void InstallStringPolicy(const std::string& policy_name,
 235                                    const std::string& policy_value) OVERRIDE;
 236   virtual void InstallIntegerPolicy(const std::string& policy_name,
 237                                     int policy_value) OVERRIDE;
 238   virtual void InstallBooleanPolicy(const std::string& policy_name,
 239                                     bool policy_value) OVERRIDE;
 240   virtual void InstallStringListPolicy(
 241       const std::string& policy_name,
 242       const base::ListValue* policy_value) OVERRIDE;
 243   virtual void InstallDictionaryPolicy(
 244       const std::string& policy_name,
 245       const base::DictionaryValue* policy_value) OVERRIDE;
 246   virtual void Install3rdPartyPolicy(
 247       const base::DictionaryValue* policies) OVERRIDE;
 248
 249   // AppliedGPOListProvider:
 250   virtual DWORD GetAppliedGPOList(DWORD flags,
 251                                   LPCTSTR machine_name,
 252                                   PSID sid_user,
 253                                   GUID* extension_guid,
 254                                   PGROUP_POLICY_OBJECT* gpo_list) OVERRIDE;
 255   virtual BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) OVERRIDE;
 256
 257   // Creates a harness instance.
 258   static PolicyProviderTestHarness* Create();
 259
 260  private:
 261   // Helper to append a base::string16 to an uint8 buffer.
 262   static void AppendChars(std::vector<uint8>* buffer,
 263                           const base::string16& chars);
 264
 265   // Appends a record with the given fields to the PReg file.
 266   void AppendRecordToPRegFile(const base::string16& path,
 267                               const std::string& key,
 268                               DWORD type,
 269                               DWORD size,
 270                               uint8* data);
 271
 272   // Appends the given DWORD |value| for |path| + |key| to the PReg file.
 273   void AppendDWORDToPRegFile(const base::string16& path,
 274                              const std::string& key,
 275                              DWORD value);
 276
 277   // Appends the given string |value| for |path| + |key| to the PReg file.
 278   void AppendStringToPRegFile(const base::string16& path,
 279                               const std::string& key,
 280                               const std::string& value);
 281
 282   // Appends the given policy |value| for |path| + |key| to the PReg file,
 283   // converting and recursing as necessary.
 284   void AppendPolicyToPRegFile(const base::string16& path,
 285                               const std::string& key,
 286                               const base::Value* value);
 287
 288   base::ScopedTempDir temp_dir_;
 289   base::FilePath preg_file_path_;
 290   GROUP_POLICY_OBJECT gpo_;
 291
 292   DISALLOW_COPY_AND_ASSIGN(PRegTestHarness);
 293 };
 294
 295 ScopedGroupPolicyRegistrySandbox::ScopedGroupPolicyRegistrySandbox() {
 296   // Generate a unique registry key for the override for each test. This
 297   // makes sure that tests executing in parallel won't delete each other's
 298   // key, at DeleteKeys().
 299   key_name_ = base::ASCIIToWide(base::StringPrintf(
 300         "SOFTWARE\\chromium unittest %d",
 301         base::Process::Current().pid()));
 302   std::wstring hklm_key_name = key_name_ + L"\\HKLM";
 303   std::wstring hkcu_key_name = key_name_ + L"\\HKCU";
 304
 305   // Create the subkeys to hold the overridden HKLM and HKCU
 306   // policy settings.
 307   temp_hklm_hive_key_.Create(HKEY_CURRENT_USER,
 308                              hklm_key_name.c_str(),
 309                              KEY_ALL_ACCESS);
 310   temp_hkcu_hive_key_.Create(HKEY_CURRENT_USER,
 311                              hkcu_key_name.c_str(),
 312                              KEY_ALL_ACCESS);
 313
 314   ActivateOverrides();
 315 }
 316
 317 ScopedGroupPolicyRegistrySandbox::~ScopedGroupPolicyRegistrySandbox() {
 318   RemoveOverrides();
 319   DeleteKeys();
 320 }
 321
 322 void ScopedGroupPolicyRegistrySandbox::ActivateOverrides() {
 323   ASSERT_HRESULT_SUCCEEDED(RegOverridePredefKey(HKEY_LOCAL_MACHINE,
 324                                                 temp_hklm_hive_key_.Handle()));
 325   ASSERT_HRESULT_SUCCEEDED(RegOverridePredefKey(HKEY_CURRENT_USER,
 326                                                 temp_hkcu_hive_key_.Handle()));
 327 }
 328
 329 void ScopedGroupPolicyRegistrySandbox::RemoveOverrides() {
 330   ASSERT_HRESULT_SUCCEEDED(RegOverridePredefKey(HKEY_LOCAL_MACHINE, 0));
 331   ASSERT_HRESULT_SUCCEEDED(RegOverridePredefKey(HKEY_CURRENT_USER, 0));
 332 }
 333
 334 void ScopedGroupPolicyRegistrySandbox::DeleteKeys() {
 335   RegKey key(HKEY_CURRENT_USER, key_name_.c_str(), KEY_ALL_ACCESS);
 336   ASSERT_TRUE(key.Valid());
 337   key.DeleteKey(L"");
 338 }
 339
 340 RegistryTestHarness::RegistryTestHarness(HKEY hive, PolicyScope scope)
 341     : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, scope), hive_(hive) {}
 342
 343 RegistryTestHarness::~RegistryTestHarness() {}
 344
 345 void RegistryTestHarness::SetUp() {}
 346
 347 ConfigurationPolicyProvider* RegistryTestHarness::CreateProvider(
 348     SchemaRegistry* registry,
 349     scoped_refptr<base::SequencedTaskRunner> task_runner) {
 350   base::win::SetDomainStateForTesting(true);
 351   scoped_ptr<AsyncPolicyLoader> loader(
 352       new PolicyLoaderWin(task_runner, kTestPolicyKey, this));
 353   return new AsyncPolicyProvider(registry, loader.Pass());
 354 }
 355
 356 void RegistryTestHarness::InstallEmptyPolicy() {}
 357
 358 void RegistryTestHarness::InstallStringPolicy(
 359     const std::string& policy_name,
 360     const std::string& policy_value) {
 361   RegKey key(hive_, kTestPolicyKey, KEY_ALL_ACCESS);
 362   ASSERT_TRUE(key.Valid());
 363   ASSERT_HRESULT_SUCCEEDED(key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
 364                                           UTF8ToUTF16(policy_value).c_str()));
 365 }
 366
 367 void RegistryTestHarness::InstallIntegerPolicy(
 368     const std::string& policy_name,
 369     int policy_value) {
 370   RegKey key(hive_, kTestPolicyKey, KEY_ALL_ACCESS);
 371   ASSERT_TRUE(key.Valid());
 372   key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
 373                  static_cast<DWORD>(policy_value));
 374 }
 375
 376 void RegistryTestHarness::InstallBooleanPolicy(
 377     const std::string& policy_name,
 378     bool policy_value) {
 379   RegKey key(hive_, kTestPolicyKey, KEY_ALL_ACCESS);
 380   ASSERT_TRUE(key.Valid());
 381   key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
 382                  static_cast<DWORD>(policy_value));
 383 }
 384
 385 void RegistryTestHarness::InstallStringListPolicy(
 386     const std::string& policy_name,
 387     const base::ListValue* policy_value) {
 388   RegKey key(hive_,
 389              (base::string16(kTestPolicyKey) + base::ASCIIToUTF16("\\") +
 390               UTF8ToUTF16(policy_name)).c_str(),
 391              KEY_ALL_ACCESS);
 392   ASSERT_TRUE(key.Valid());
 393   int index = 1;
 394   for (base::ListValue::const_iterator element(policy_value->begin());
 395        element != policy_value->end();
 396        ++element) {
 397     std::string element_value;
 398     if (!(*element)->GetAsString(&element_value))
 399       continue;
 400     std::string name(base::IntToString(index++));
 401     key.WriteValue(UTF8ToUTF16(name).c_str(),
 402                    UTF8ToUTF16(element_value).c_str());
 403   }
 404 }
 405
 406 void RegistryTestHarness::InstallDictionaryPolicy(
 407     const std::string& policy_name,
 408     const base::DictionaryValue* policy_value) {
 409   std::string json;
 410   base::JSONWriter::Write(policy_value, &json);
 411   RegKey key(hive_, kTestPolicyKey, KEY_ALL_ACCESS);
 412   ASSERT_TRUE(key.Valid());
 413   key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
 414                  UTF8ToUTF16(json).c_str());
 415 }
 416
 417 void RegistryTestHarness::Install3rdPartyPolicy(
 418     const base::DictionaryValue* policies) {
 419   // The first level entries are domains, and the second level entries map
 420   // components to their policy.
 421   const base::string16 kPathPrefix =
 422       base::string16(kTestPolicyKey) + kPathSep + kThirdParty + kPathSep;
 423   for (base::DictionaryValue::Iterator domain(*policies);
 424        !domain.IsAtEnd(); domain.Advance()) {
 425     const base::DictionaryValue* components = NULL;
 426     if (!domain.value().GetAsDictionary(&components)) {
 427       ADD_FAILURE();
 428       continue;
 429     }
 430     for (base::DictionaryValue::Iterator component(*components);
 431          !component.IsAtEnd(); component.Advance()) {
 432       const base::string16 path = kPathPrefix +
 433           UTF8ToUTF16(domain.key()) + kPathSep + UTF8ToUTF16(component.key());
 434       InstallValue(component.value(), hive_, path, kMandatory);
 435     }
 436   }
 437 }
 438
 439 DWORD RegistryTestHarness::GetAppliedGPOList(DWORD flags,
 440                                              LPCTSTR machine_name,
 441                                              PSID sid_user,
 442                                              GUID* extension_guid,
 443                                              PGROUP_POLICY_OBJECT* gpo_list) {
 444   *gpo_list = NULL;
 445   return ERROR_ACCESS_DENIED;
 446 }
 447
 448 BOOL RegistryTestHarness::FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) {
 449   return TRUE;
 450 }
 451
 452 // static
 453 PolicyProviderTestHarness* RegistryTestHarness::CreateHKCU() {
 454   return new RegistryTestHarness(HKEY_CURRENT_USER, POLICY_SCOPE_USER);
 455 }
 456
 457 // static
 458 PolicyProviderTestHarness* RegistryTestHarness::CreateHKLM() {
 459   return new RegistryTestHarness(HKEY_LOCAL_MACHINE, POLICY_SCOPE_MACHINE);
 460 }
 461
 462 PRegTestHarness::PRegTestHarness()
 463     : PolicyProviderTestHarness(POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE) {}
 464
 465 PRegTestHarness::~PRegTestHarness() {}
 466
 467 void PRegTestHarness::SetUp() {
 468   base::win::SetDomainStateForTesting(false);
 469   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 470   preg_file_path_ = temp_dir_.path().Append(PolicyLoaderWin::kPRegFileName);
 471   ASSERT_TRUE(base::WriteFile(preg_file_path_,
 472                                    preg_parser::kPRegFileHeader,
 473                                    arraysize(preg_parser::kPRegFileHeader)));
 474
 475   memset(&gpo_, 0, sizeof(GROUP_POLICY_OBJECT));
 476   gpo_.lpFileSysPath = const_cast<wchar_t*>(temp_dir_.path().value().c_str());
 477 }
 478
 479 ConfigurationPolicyProvider* PRegTestHarness::CreateProvider(
 480     SchemaRegistry* registry,
 481     scoped_refptr<base::SequencedTaskRunner> task_runner) {
 482   scoped_ptr<AsyncPolicyLoader> loader(
 483       new PolicyLoaderWin(task_runner, kTestPolicyKey, this));
 484   return new AsyncPolicyProvider(registry, loader.Pass());
 485 }
 486
 487 void PRegTestHarness::InstallEmptyPolicy() {}
 488
 489 void PRegTestHarness::InstallStringPolicy(const std::string& policy_name,
 490                                           const std::string& policy_value) {
 491   AppendStringToPRegFile(kTestPolicyKey, policy_name, policy_value);
 492 }
 493
 494 void PRegTestHarness::InstallIntegerPolicy(const std::string& policy_name,
 495                                            int policy_value) {
 496   AppendDWORDToPRegFile(kTestPolicyKey, policy_name, policy_value);
 497 }
 498
 499 void PRegTestHarness::InstallBooleanPolicy(const std::string& policy_name,
 500                                            bool policy_value) {
 501   AppendDWORDToPRegFile(kTestPolicyKey, policy_name, policy_value);
 502 }
 503
 504 void PRegTestHarness::InstallStringListPolicy(
 505     const std::string& policy_name,
 506     const base::ListValue* policy_value) {
 507   AppendPolicyToPRegFile(kTestPolicyKey, policy_name, policy_value);
 508 }
 509
 510 void PRegTestHarness::InstallDictionaryPolicy(
 511     const std::string& policy_name,
 512     const base::DictionaryValue* policy_value) {
 513   std::string json;
 514   base::JSONWriter::Write(policy_value, &json);
 515   AppendStringToPRegFile(kTestPolicyKey, policy_name, json);
 516 }
 517
 518 void PRegTestHarness::Install3rdPartyPolicy(
 519     const base::DictionaryValue* policies) {
 520   // The first level entries are domains, and the second level entries map
 521   // components to their policy.
 522   const base::string16 kPathPrefix =
 523       base::string16(kTestPolicyKey) + kPathSep + kThirdParty + kPathSep;
 524   for (base::DictionaryValue::Iterator domain(*policies);
 525        !domain.IsAtEnd(); domain.Advance()) {
 526     const base::DictionaryValue* components = NULL;
 527     if (!domain.value().GetAsDictionary(&components)) {
 528       ADD_FAILURE();
 529       continue;
 530     }
 531     const base::string16 domain_path = kPathPrefix + UTF8ToUTF16(domain.key());
 532     for (base::DictionaryValue::Iterator component(*components);
 533          !component.IsAtEnd(); component.Advance()) {
 534       const base::string16 component_path =
 535           domain_path + kPathSep + UTF8ToUTF16(component.key());
 536       AppendPolicyToPRegFile(component_path, UTF16ToUTF8(kMandatory),
 537                              &component.value());
 538     }
 539   }
 540 }
 541
 542 DWORD PRegTestHarness::GetAppliedGPOList(DWORD flags,
 543                                          LPCTSTR machine_name,
 544                                          PSID sid_user,
 545                                          GUID* extension_guid,
 546                                          PGROUP_POLICY_OBJECT* gpo_list) {
 547   *gpo_list = flags & GPO_LIST_FLAG_MACHINE ? &gpo_ : NULL;
 548   return ERROR_SUCCESS;
 549 }
 550
 551 BOOL PRegTestHarness::FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) {
 552   return TRUE;
 553 }
 554
 555 // static
 556 PolicyProviderTestHarness* PRegTestHarness::Create() {
 557   return new PRegTestHarness();
 558 }
 559
 560 // static
 561 void PRegTestHarness::AppendChars(std::vector<uint8>* buffer,
 562                                   const base::string16& chars) {
 563   for (base::string16::const_iterator c(chars.begin()); c != chars.end(); ++c) {
 564     buffer->push_back(*c & 0xff);
 565     buffer->push_back((*c >> 8) & 0xff);
 566   }
 567 }
 568
 569 void PRegTestHarness::AppendRecordToPRegFile(const base::string16& path,
 570                                              const std::string& key,
 571                                              DWORD type,
 572                                              DWORD size,
 573                                              uint8* data) {
 574   std::vector<uint8> buffer;
 575   AppendChars(&buffer, L"[");
 576   AppendChars(&buffer, path);
 577   AppendChars(&buffer, base::string16(L"\0;", 2));
 578   AppendChars(&buffer, UTF8ToUTF16(key));
 579   AppendChars(&buffer, base::string16(L"\0;", 2));
 580   type = base::ByteSwapToLE32(type);
 581   uint8* type_data = reinterpret_cast<uint8*>(&type);
 582   buffer.insert(buffer.end(), type_data, type_data + sizeof(DWORD));
 583   AppendChars(&buffer, L";");
 584   size = base::ByteSwapToLE32(size);
 585   uint8* size_data = reinterpret_cast<uint8*>(&size);
 586   buffer.insert(buffer.end(), size_data, size_data + sizeof(DWORD));
 587   AppendChars(&buffer, L";");
 588   buffer.insert(buffer.end(), data, data + size);
 589   AppendChars(&buffer, L"]");
 590
 591   ASSERT_EQ(buffer.size(),
 592             base::AppendToFile(
 593                 preg_file_path_,
 594                 reinterpret_cast<const char*>(vector_as_array(&buffer)),
 595                 buffer.size()));
 596 }
 597
 598 void PRegTestHarness::AppendDWORDToPRegFile(const base::string16& path,
 599                                             const std::string& key,
 600                                             DWORD value) {
 601   value = base::ByteSwapToLE32(value);
 602   AppendRecordToPRegFile(path, key, REG_DWORD, sizeof(DWORD),
 603                          reinterpret_cast<uint8*>(&value));
 604 }
 605
 606 void PRegTestHarness::AppendStringToPRegFile(const base::string16& path,
 607                                              const std::string& key,
 608                                              const std::string& value) {
 609   base::string16 string16_value(UTF8ToUTF16(value));
 610   std::vector<base::char16> data;
 611   std::transform(string16_value.begin(), string16_value.end(),
 612                  std::back_inserter(data), std::ptr_fun(base::ByteSwapToLE16));
 613   data.push_back(base::ByteSwapToLE16(L'\0'));
 614
 615   AppendRecordToPRegFile(path, key, REG_SZ, data.size() * sizeof(base::char16),
 616                          reinterpret_cast<uint8*>(vector_as_array(&data)));
 617 }
 618
 619 void PRegTestHarness::AppendPolicyToPRegFile(const base::string16& path,
 620                                              const std::string& key,
 621                                              const base::Value* value) {
 622   switch (value->GetType()) {
 623     case base::Value::TYPE_BOOLEAN: {
 624       bool boolean_value = false;
 625       ASSERT_TRUE(value->GetAsBoolean(&boolean_value));
 626       AppendDWORDToPRegFile(path, key, boolean_value);
 627       break;
 628     }
 629     case base::Value::TYPE_INTEGER: {
 630       int int_value = 0;
 631       ASSERT_TRUE(value->GetAsInteger(&int_value));
 632       AppendDWORDToPRegFile(path, key, int_value);
 633       break;
 634     }
 635     case base::Value::TYPE_DOUBLE: {
 636       double double_value = 0;
 637       ASSERT_TRUE(value->GetAsDouble(&double_value));
 638       AppendStringToPRegFile(path, key, base::DoubleToString(double_value));
 639       break;
 640     }
 641     case base::Value::TYPE_STRING: {
 642       std::string string_value;
 643       ASSERT_TRUE(value->GetAsString(&string_value));
 644       AppendStringToPRegFile(path, key, string_value);
 645       break;
 646     }
 647     case base::Value::TYPE_DICTIONARY: {
 648       base::string16 subpath = path + kPathSep + UTF8ToUTF16(key);
 649       const base::DictionaryValue* dict = NULL;
 650       ASSERT_TRUE(value->GetAsDictionary(&dict));
 651       for (base::DictionaryValue::Iterator entry(*dict); !entry.IsAtEnd();
 652            entry.Advance()) {
 653         AppendPolicyToPRegFile(subpath, entry.key(), &entry.value());
 654       }
 655       break;
 656     }
 657     case base::Value::TYPE_LIST: {
 658       base::string16 subpath = path + kPathSep + UTF8ToUTF16(key);
 659       const base::ListValue* list = NULL;
 660       ASSERT_TRUE(value->GetAsList(&list));
 661       for (size_t i = 0; i < list->GetSize(); ++i) {
 662         const base::Value* entry = NULL;
 663         ASSERT_TRUE(list->Get(i, &entry));
 664         AppendPolicyToPRegFile(subpath, base::IntToString(i + 1), entry);
 665       }
 666       break;
 667     }
 668     case base::Value::TYPE_BINARY:
 669     case base::Value::TYPE_NULL: {
 670       ADD_FAILURE();
 671       break;
 672     }
 673   }
 674 }
 675
 676 }  // namespace
 677
 678 // Instantiate abstract test case for basic policy reading tests.
 679 INSTANTIATE_TEST_CASE_P(
 680     PolicyProviderWinTest,
 681     ConfigurationPolicyProviderTest,
 682     testing::Values(RegistryTestHarness::CreateHKCU,
 683                     RegistryTestHarness::CreateHKLM,
 684                     PRegTestHarness::Create));
 685
 686 // Instantiate abstract test case for 3rd party policy reading tests.
 687 INSTANTIATE_TEST_CASE_P(
 688     ThirdPartyPolicyProviderWinTest,
 689     Configuration3rdPartyPolicyProviderTest,
 690     testing::Values(RegistryTestHarness::CreateHKCU,
 691                     RegistryTestHarness::CreateHKLM,
 692                     PRegTestHarness::Create));
 693
 694 // Test cases for windows policy provider specific functionality.
 695 class PolicyLoaderWinTest : public PolicyTestBase,
 696                             public AppliedGPOListProvider {
 697  protected:
 698   // The policy key this tests places data under. This must match the data
 699   // files in chrome/test/data/policy/gpo.
 700   static const base::char16 kTestPolicyKey[];
 701
 702   PolicyLoaderWinTest()
 703       : gpo_list_(NULL),
 704         gpo_list_status_(ERROR_ACCESS_DENIED) {}
 705   virtual ~PolicyLoaderWinTest() {}
 706
 707   virtual void SetUp() OVERRIDE {
 708     base::win::SetDomainStateForTesting(false);
 709     PolicyTestBase::SetUp();
 710
 711     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &test_data_dir_));
 712     test_data_dir_ = test_data_dir_.AppendASCII("chrome")
 713                                    .AppendASCII("test")
 714                                    .AppendASCII("data")
 715                                    .AppendASCII("policy")
 716                                    .AppendASCII("gpo");
 717   }
 718
 719   // AppliedGPOListProvider:
 720   virtual DWORD GetAppliedGPOList(DWORD flags,
 721                                   LPCTSTR machine_name,
 722                                   PSID sid_user,
 723                                   GUID* extension_guid,
 724                                   PGROUP_POLICY_OBJECT* gpo_list) OVERRIDE {
 725     *gpo_list = gpo_list_;
 726     return gpo_list_status_;
 727   }
 728   virtual BOOL FreeGPOList(PGROUP_POLICY_OBJECT gpo_list) OVERRIDE {
 729     return TRUE;
 730   }
 731
 732   void InitGPO(GROUP_POLICY_OBJECT* gpo,
 733                DWORD options,
 734                const base::FilePath& path,
 735                GROUP_POLICY_OBJECT* next,
 736                GROUP_POLICY_OBJECT* prev) {
 737     memset(gpo, 0, sizeof(GROUP_POLICY_OBJECT));
 738     gpo->dwOptions = options;
 739     gpo->lpFileSysPath = const_cast<wchar_t*>(path.value().c_str());
 740     gpo->pNext = next;
 741     gpo->pPrev = prev;
 742   }
 743
 744   bool Matches(const PolicyBundle& expected) {
 745     PolicyLoaderWin loader(loop_.message_loop_proxy(), kTestPolicyKey, this);
 746     scoped_ptr<PolicyBundle> loaded(
 747         loader.InitialLoad(schema_registry_.schema_map()));
 748     return loaded->Equals(expected);
 749   }
 750
 751   void InstallRegistrySentinel() {
 752     RegKey hklm_key(HKEY_CURRENT_USER, kTestPolicyKey, KEY_ALL_ACCESS);
 753     ASSERT_TRUE(hklm_key.Valid());
 754     hklm_key.WriteValue(
 755         UTF8ToUTF16(test_keys::kKeyString).c_str(),
 756         UTF8ToUTF16("registry").c_str());
 757   }
 758
 759   bool MatchesRegistrySentinel() {
 760     base::DictionaryValue expected_policy;
 761     expected_policy.SetString(test_keys::kKeyString, "registry");
 762     PolicyBundle expected;
 763     expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
 764         .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
 765     return Matches(expected);
 766   }
 767
 768   bool MatchesTestBundle() {
 769     base::DictionaryValue expected_policy;
 770     expected_policy.SetBoolean(test_keys::kKeyBoolean, true);
 771     expected_policy.SetString(test_keys::kKeyString, "GPO");
 772     expected_policy.SetInteger(test_keys::kKeyInteger, 42);
 773     scoped_ptr<base::ListValue> list(new base::ListValue());
 774     list->AppendString("GPO 1");
 775     list->AppendString("GPO 2");
 776     expected_policy.Set(test_keys::kKeyStringList, list.release());
 777     PolicyBundle expected;
 778     expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
 779         .LoadFrom(&expected_policy, POLICY_LEVEL_MANDATORY,
 780                   POLICY_SCOPE_MACHINE);
 781     return Matches(expected);
 782   }
 783
 784   ScopedGroupPolicyRegistrySandbox registry_sandbox_;
 785   PGROUP_POLICY_OBJECT gpo_list_;
 786   DWORD gpo_list_status_;
 787   base::FilePath test_data_dir_;
 788 };
 789
 790 const base::char16 PolicyLoaderWinTest::kTestPolicyKey[] =
 791     L"SOFTWARE\\Policies\\Chromium";
 792
 793 TEST_F(PolicyLoaderWinTest, HKLMOverHKCU) {
 794   RegKey hklm_key(HKEY_LOCAL_MACHINE, kTestPolicyKey, KEY_ALL_ACCESS);
 795   ASSERT_TRUE(hklm_key.Valid());
 796   hklm_key.WriteValue(UTF8ToUTF16(test_keys::kKeyString).c_str(),
 797                       UTF8ToUTF16("hklm").c_str());
 798   RegKey hkcu_key(HKEY_CURRENT_USER, kTestPolicyKey, KEY_ALL_ACCESS);
 799   ASSERT_TRUE(hkcu_key.Valid());
 800   hkcu_key.WriteValue(UTF8ToUTF16(test_keys::kKeyString).c_str(),
 801                       UTF8ToUTF16("hkcu").c_str());
 802
 803   PolicyBundle expected;
 804   expected.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
 805       .Set(test_keys::kKeyString,
 806            POLICY_LEVEL_MANDATORY,
 807            POLICY_SCOPE_MACHINE,
 808            new base::StringValue("hklm"),
 809            NULL);
 810   EXPECT_TRUE(Matches(expected));
 811 }
 812
 813 TEST_F(PolicyLoaderWinTest, Merge3rdPartyPolicies) {
 814   // Policy for the same extension will be provided at the 4 level/scope
 815   // combinations, to verify that they overlap as expected.
 816   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "merge");
 817   ASSERT_TRUE(RegisterSchema(
 818       ns,
 819       "{"
 820       "  \"type\": \"object\","
 821       "  \"properties\": {"
 822       "    \"a\": { \"type\": \"string\" },"
 823       "    \"b\": { \"type\": \"string\" },"
 824       "    \"c\": { \"type\": \"string\" },"
 825       "    \"d\": { \"type\": \"string\" }"
 826       "  }"
 827       "}"));
 828
 829   const base::string16 kPathSuffix =
 830       kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\merge");
 831
 832   const char kUserMandatory[] = "user-mandatory";
 833   const char kUserRecommended[] = "user-recommended";
 834   const char kMachineMandatory[] = "machine-mandatory";
 835   const char kMachineRecommended[] = "machine-recommended";
 836
 837   base::DictionaryValue policy;
 838   policy.SetString("a", kMachineMandatory);
 839   EXPECT_TRUE(InstallValue(policy, HKEY_LOCAL_MACHINE,
 840                            kPathSuffix, kMandatory));
 841   policy.SetString("a", kUserMandatory);
 842   policy.SetString("b", kUserMandatory);
 843   EXPECT_TRUE(InstallValue(policy, HKEY_CURRENT_USER,
 844                            kPathSuffix, kMandatory));
 845   policy.SetString("a", kMachineRecommended);
 846   policy.SetString("b", kMachineRecommended);
 847   policy.SetString("c", kMachineRecommended);
 848   EXPECT_TRUE(InstallValue(policy, HKEY_LOCAL_MACHINE,
 849                            kPathSuffix, kRecommended));
 850   policy.SetString("a", kUserRecommended);
 851   policy.SetString("b", kUserRecommended);
 852   policy.SetString("c", kUserRecommended);
 853   policy.SetString("d", kUserRecommended);
 854   EXPECT_TRUE(InstallValue(policy, HKEY_CURRENT_USER,
 855                            kPathSuffix, kRecommended));
 856
 857   PolicyBundle expected;
 858   PolicyMap& expected_policy = expected.Get(ns);
 859   expected_policy.Set("a",
 860                       POLICY_LEVEL_MANDATORY,
 861                       POLICY_SCOPE_MACHINE,
 862                       new base::StringValue(kMachineMandatory),
 863                       NULL);
 864   expected_policy.Set("b",
 865                       POLICY_LEVEL_MANDATORY,
 866                       POLICY_SCOPE_USER,
 867                       new base::StringValue(kUserMandatory),
 868                       NULL);
 869   expected_policy.Set("c",
 870                       POLICY_LEVEL_RECOMMENDED,
 871                       POLICY_SCOPE_MACHINE,
 872                       new base::StringValue(kMachineRecommended),
 873                       NULL);
 874   expected_policy.Set("d",
 875                       POLICY_LEVEL_RECOMMENDED,
 876                       POLICY_SCOPE_USER,
 877                       new base::StringValue(kUserRecommended),
 878                       NULL);
 879   EXPECT_TRUE(Matches(expected));
 880 }
 881
 882 TEST_F(PolicyLoaderWinTest, LoadStringEncodedValues) {
 883   // Create a dictionary with all the types that can be stored encoded in a
 884   // string.
 885   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "string");
 886   ASSERT_TRUE(RegisterSchema(
 887       ns,
 888       "{"
 889       "  \"type\": \"object\","
 890       "  \"id\": \"MainType\","
 891       "  \"properties\": {"
 892       "    \"null\": { \"type\": \"null\" },"
 893       "    \"bool\": { \"type\": \"boolean\" },"
 894       "    \"int\": { \"type\": \"integer\" },"
 895       "    \"double\": { \"type\": \"number\" },"
 896       "    \"list\": {"
 897       "      \"type\": \"array\","
 898       "      \"items\": { \"$ref\": \"MainType\" }"
 899       "    },"
 900       "    \"dict\": { \"$ref\": \"MainType\" }"
 901       "  }"
 902       "}"));
 903
 904   base::DictionaryValue policy;
 905   policy.Set("null", base::Value::CreateNullValue());
 906   policy.SetBoolean("bool", true);
 907   policy.SetInteger("int", -123);
 908   policy.SetDouble("double", 456.78e9);
 909   base::ListValue list;
 910   list.Append(policy.DeepCopy());
 911   list.Append(policy.DeepCopy());
 912   policy.Set("list", list.DeepCopy());
 913   // Encode |policy| before adding the "dict" entry.
 914   std::string encoded_dict;
 915   base::JSONWriter::Write(&policy, &encoded_dict);
 916   ASSERT_FALSE(encoded_dict.empty());
 917   policy.Set("dict", policy.DeepCopy());
 918   std::string encoded_list;
 919   base::JSONWriter::Write(&list, &encoded_list);
 920   ASSERT_FALSE(encoded_list.empty());
 921   base::DictionaryValue encoded_policy;
 922   encoded_policy.SetString("null", "");
 923   encoded_policy.SetString("bool", "1");
 924   encoded_policy.SetString("int", "-123");
 925   encoded_policy.SetString("double", "456.78e9");
 926   encoded_policy.SetString("list", encoded_list);
 927   encoded_policy.SetString("dict", encoded_dict);
 928
 929   const base::string16 kPathSuffix =
 930       kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\string");
 931   EXPECT_TRUE(
 932       InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 933
 934   PolicyBundle expected;
 935   expected.Get(ns).LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
 936   EXPECT_TRUE(Matches(expected));
 937 }
 938
 939 TEST_F(PolicyLoaderWinTest, LoadIntegerEncodedValues) {
 940   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "int");
 941   ASSERT_TRUE(RegisterSchema(
 942       ns,
 943       "{"
 944       "  \"type\": \"object\","
 945       "  \"properties\": {"
 946       "    \"bool\": { \"type\": \"boolean\" },"
 947       "    \"int\": { \"type\": \"integer\" },"
 948       "    \"double\": { \"type\": \"number\" }"
 949       "  }"
 950       "}"));
 951
 952   base::DictionaryValue encoded_policy;
 953   encoded_policy.SetInteger("bool", 1);
 954   encoded_policy.SetInteger("int", 123);
 955   encoded_policy.SetInteger("double", 456);
 956
 957   const base::string16 kPathSuffix =
 958       kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\int");
 959   EXPECT_TRUE(
 960       InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 961
 962   base::DictionaryValue policy;
 963   policy.SetBoolean("bool", true);
 964   policy.SetInteger("int", 123);
 965   policy.SetDouble("double", 456.0);
 966   PolicyBundle expected;
 967   expected.Get(ns).LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
 968   EXPECT_TRUE(Matches(expected));
 969 }
 970
 971 TEST_F(PolicyLoaderWinTest, DefaultPropertySchemaType) {
 972   // Build a schema for an "object" with a default schema for its properties.
 973   // Note that the top-level object can't have "additionalProperties", so
 974   // a "policy" property is used instead.
 975   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "test");
 976   ASSERT_TRUE(RegisterSchema(
 977       ns,
 978       "{"
 979       "  \"type\": \"object\","
 980       "  \"properties\": {"
 981       "    \"policy\": {"
 982       "      \"type\": \"object\","
 983       "      \"properties\": {"
 984       "        \"special-int1\": { \"type\": \"integer\" },"
 985       "        \"special-int2\": { \"type\": \"integer\" }"
 986       "      },"
 987       "      \"additionalProperties\": { \"type\": \"number\" }"
 988       "    }"
 989       "  }"
 990       "}"));
 991
 992   // Write some test values.
 993   base::DictionaryValue policy;
 994   // These special values have a specific schema for them.
 995   policy.SetInteger("special-int1", 123);
 996   policy.SetString("special-int2", "-456");
 997   // Other values default to be loaded as doubles.
 998   policy.SetInteger("double1", 789.0);
 999   policy.SetString("double2", "123.456e7");
1000   policy.SetString("invalid", "omg");
1001   base::DictionaryValue all_policies;
1002   all_policies.Set("policy", policy.DeepCopy());
1003
1004   const base::string16 kPathSuffix =
1005       kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\test");
1006   EXPECT_TRUE(
1007       InstallValue(all_policies, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
1008
1009   base::DictionaryValue expected_policy;
1010   expected_policy.SetInteger("special-int1", 123);
1011   expected_policy.SetInteger("special-int2", -456);
1012   expected_policy.SetDouble("double1", 789.0);
1013   expected_policy.SetDouble("double2", 123.456e7);
1014   base::DictionaryValue expected_policies;
1015   expected_policies.Set("policy", expected_policy.DeepCopy());
1016   PolicyBundle expected;
1017   expected.Get(ns).LoadFrom(
1018       &expected_policies, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
1019   EXPECT_TRUE(Matches(expected));
1020 }
1021
1022 TEST_F(PolicyLoaderWinTest, AppliedPolicyNotPresent) {
1023   InstallRegistrySentinel();
1024   gpo_list_ = NULL;
1025   gpo_list_status_ = ERROR_SUCCESS;
1026
1027   PolicyBundle empty;
1028   EXPECT_TRUE(Matches(empty));
1029 }
1030
1031 TEST_F(PolicyLoaderWinTest, AppliedPolicyEmpty) {
1032   InstallRegistrySentinel();
1033   base::FilePath gpo_dir(test_data_dir_.AppendASCII("empty"));
1034   GROUP_POLICY_OBJECT gpo;
1035   InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
1036   gpo_list_ = &gpo;
1037   gpo_list_status_ = ERROR_SUCCESS;
1038
1039   PolicyBundle empty;
1040   EXPECT_TRUE(Matches(empty));
1041 }
1042
1043 TEST_F(PolicyLoaderWinTest, AppliedPolicyInDomain) {
1044   base::win::SetDomainStateForTesting(true);
1045   InstallRegistrySentinel();
1046   base::FilePath gpo_dir(test_data_dir_.AppendASCII("empty"));
1047   GROUP_POLICY_OBJECT gpo;
1048   InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
1049   gpo_list_ = &gpo;
1050   gpo_list_status_ = ERROR_SUCCESS;
1051
1052   PolicyBundle empty;
1053   EXPECT_TRUE(MatchesRegistrySentinel());
1054 }
1055
1056 TEST_F(PolicyLoaderWinTest, AppliedPolicyNonExistingFile) {
1057   InstallRegistrySentinel();
1058   GROUP_POLICY_OBJECT gpo;
1059   InitGPO(&gpo, 0, test_data_dir_, NULL, NULL);
1060   gpo_list_ = &gpo;
1061   gpo_list_status_ = ERROR_SUCCESS;
1062
1063   EXPECT_TRUE(MatchesRegistrySentinel());
1064 }
1065
1066 TEST_F(PolicyLoaderWinTest, AppliedPolicyBadPath) {
1067   InstallRegistrySentinel();
1068   base::FilePath gpo_dir(test_data_dir_.AppendASCII("bad"));
1069   GROUP_POLICY_OBJECT gpo;
1070   InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
1071   gpo_list_ = &gpo;
1072   gpo_list_status_ = ERROR_SUCCESS;
1073
1074   EXPECT_TRUE(MatchesRegistrySentinel());
1075 }
1076
1077 TEST_F(PolicyLoaderWinTest, AppliedPolicyPresent) {
1078   InstallRegistrySentinel();
1079   base::FilePath gpo_dir(test_data_dir_.AppendASCII("test1"));
1080   GROUP_POLICY_OBJECT gpo;
1081   InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
1082   gpo_list_ = &gpo;
1083   gpo_list_status_ = ERROR_SUCCESS;
1084
1085   EXPECT_TRUE(MatchesTestBundle());
1086 }
1087
1088 TEST_F(PolicyLoaderWinTest, AppliedPolicyMerged) {
1089   InstallRegistrySentinel();
1090   base::FilePath gpo1_dir(test_data_dir_.AppendASCII("test2"));
1091   base::FilePath gpo2_dir(test_data_dir_.AppendASCII("test1"));
1092   GROUP_POLICY_OBJECT gpo1;
1093   GROUP_POLICY_OBJECT gpo2;
1094   InitGPO(&gpo1, 0, gpo1_dir, &gpo2, NULL);
1095   InitGPO(&gpo2, 0, gpo2_dir, NULL, &gpo1);
1096   gpo_list_ = &gpo1;
1097   gpo_list_status_ = ERROR_SUCCESS;
1098
1099   EXPECT_TRUE(MatchesTestBundle());
1100 }
1101
1102 TEST_F(PolicyLoaderWinTest, AppliedPolicyDisabled) {
1103   InstallRegistrySentinel();
1104   base::FilePath gpo1_dir(test_data_dir_.AppendASCII("test1"));
1105   base::FilePath gpo2_dir(test_data_dir_.AppendASCII("test2"));
1106   GROUP_POLICY_OBJECT gpo1;
1107   GROUP_POLICY_OBJECT gpo2;
1108   InitGPO(&gpo1, 0, gpo1_dir, &gpo2, NULL);
1109   InitGPO(&gpo2, GPO_FLAG_DISABLE, gpo2_dir, NULL, &gpo1);
1110   gpo_list_ = &gpo1;
1111   gpo_list_status_ = ERROR_SUCCESS;
1112
1113   EXPECT_TRUE(MatchesTestBundle());
1114 }
1115
1116 TEST_F(PolicyLoaderWinTest, AppliedPolicyForcedPolicy) {
1117   InstallRegistrySentinel();
1118   base::FilePath gpo1_dir(test_data_dir_.AppendASCII("test1"));
1119   base::FilePath gpo2_dir(test_data_dir_.AppendASCII("test2"));
1120   GROUP_POLICY_OBJECT gpo1;
1121   GROUP_POLICY_OBJECT gpo2;
1122   InitGPO(&gpo1, GPO_FLAG_FORCE, gpo1_dir, &gpo2, NULL);
1123   InitGPO(&gpo2, 0, gpo2_dir, NULL, &gpo1);
1124   gpo_list_ = &gpo1;
1125   gpo_list_status_ = ERROR_SUCCESS;
1126
1127   EXPECT_TRUE(MatchesTestBundle());
1128 }
1129
1130 TEST_F(PolicyLoaderWinTest, AppliedPolicyUNCPath) {
1131   InstallRegistrySentinel();
1132   base::FilePath gpo_dir(test_data_dir_.AppendASCII("test1"));
1133   base::FilePath unc_path(L"\\\\some_share\\GPO");
1134   GROUP_POLICY_OBJECT gpo1;
1135   GROUP_POLICY_OBJECT gpo2;
1136   InitGPO(&gpo1, 0, gpo_dir, &gpo2, NULL);
1137   InitGPO(&gpo2, 0, unc_path, NULL, &gpo1);
1138   gpo_list_ = &gpo1;
1139   gpo_list_status_ = ERROR_SUCCESS;
1140
1141   EXPECT_TRUE(MatchesRegistrySentinel());
1142 }
1143
1144 TEST_F(PolicyLoaderWinTest, LoadExtensionPolicyAlternativeSpelling) {
1145   base::FilePath gpo_dir(
1146       test_data_dir_.AppendASCII("extension_alternative_spelling"));
1147   GROUP_POLICY_OBJECT gpo;
1148   InitGPO(&gpo, 0, gpo_dir, NULL, NULL);
1149   gpo_list_ = &gpo;
1150   gpo_list_status_ = ERROR_SUCCESS;
1151
1152   const char kTestSchema[] =
1153       "{"
1154       "  \"type\": \"object\","
1155       "  \"properties\": {"
1156       "    \"policy 1\": { \"type\": \"integer\" },"
1157       "    \"policy 2\": { \"type\": \"integer\" }"
1158       "  }"
1159       "}";
1160   const PolicyNamespace ns_a(
1161       POLICY_DOMAIN_EXTENSIONS, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
1162   const PolicyNamespace ns_b(
1163       POLICY_DOMAIN_EXTENSIONS, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
1164   ASSERT_TRUE(RegisterSchema(ns_a, kTestSchema));
1165   ASSERT_TRUE(RegisterSchema(ns_b, kTestSchema));
1166
1167   PolicyBundle expected;
1168   base::DictionaryValue expected_a;
1169   expected_a.SetInteger("policy 1", 3);
1170   expected_a.SetInteger("policy 2", 3);
1171   expected.Get(ns_a).LoadFrom(
1172       &expected_a, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
1173   base::DictionaryValue expected_b;
1174   expected_b.SetInteger("policy 1", 2);
1175   expected.Get(ns_b).LoadFrom(
1176       &expected_b, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE);
1177   EXPECT_TRUE(Matches(expected));
1178 }
1179
1180 TEST_F(PolicyLoaderWinTest, LBSSupport) {
1181   const PolicyNamespace ns(
1182       POLICY_DOMAIN_EXTENSIONS, "heildphpnddilhkemkielfhnkaagiabh");
1183   schema_registry_.RegisterComponent(ns, Schema());
1184
1185   const char kIncompleteSchema[] =
1186       "{"
1187        "  \"type\": \"object\","
1188        "  \"properties\": {"
1189        "    \"url_list\": { \"type\": \"array\" },"
1190        "    \"url_greylist\": { \"type\": \"array\" }"
1191        "  }"
1192       "}";
1193
1194   const base::string16 kPathSuffix =
1195       kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions");
1196
1197   base::ListValue list;
1198   list.AppendString("youtube.com");
1199   base::DictionaryValue policy;
1200   policy.Set("url_list", list.DeepCopy());
1201   policy.SetString("alternative_browser_path", "c:\\legacy\\browser.exe");
1202   base::DictionaryValue root;
1203   root.Set(base::UTF16ToUTF8(kMandatory), policy.DeepCopy());
1204   root.SetString(kSchema, kIncompleteSchema);
1205   EXPECT_TRUE(InstallValue(root, HKEY_LOCAL_MACHINE,
1206                            kPathSuffix, base::ASCIIToUTF16(ns.component_id)));
1207
1208   PolicyBundle expected;
1209   PolicyMap& expected_policy = expected.Get(ns);
1210   expected_policy.Set("alternative_browser_path",
1211                       POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
1212                       new base::StringValue("c:\\legacy\\browser.exe"), NULL);
1213   expected_policy.Set("url_list", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
1214                       list.DeepCopy(), NULL);
1215   EXPECT_TRUE(Matches(expected));
1216 }
1217
1218 }  // namespace policy