Added a PolicyDomainDescriptor.

chrome/browser/policy/cloud/component_cloud_policy_service_unittest.cc

 // Copyright (c) 2013 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 "chrome/browser/policy/cloud/component_cloud_policy_service.h"
 
 #include "base/files/scoped_temp_dir.h"
+#include "base/memory/ref_counted.h"

[bartfab (slow), 2013/05/21 12:10:56]

Nit: Already included by component_cloud_policy_service.h.

[Joao da Silva, 2013/05/21 17:50:14]

Done.

 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/run_loop.h"
 #include "base/sha1.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/cloud/mock_cloud_policy_client.h"
 #include "chrome/browser/policy/cloud/mock_cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/policy_builder.h"
 #include "chrome/browser/policy/cloud/resource_cache.h"
+#include "chrome/browser/policy/policy_domain_descriptor.h"
 #include "chrome/browser/policy/policy_map.h"
+#include "chrome/browser/policy/policy_schema.h"
 #include "chrome/browser/policy/policy_types.h"
 #include "chrome/browser/policy/proto/cloud/chrome_extension_policy.pb.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace em = enterprise_management;
 
 using testing::Mock;
 
 namespace policy {
 
 namespace {
 
 const char kTestExtension[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 const char kTestExtension2[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 const char kTestExtension3[] = "cccccccccccccccccccccccccccccccc";
 const char kTestDownload[] = "http://example.com/getpolicy?id=123";
 const char kTestDownload2[] = "http://example.com/getpolicy?id=456";
+
 const char kTestPolicy[] =
     "{"
     "  \"Name\": {"
     "    \"Value\": \"disabled\""
     "  },"
     "  \"Second\": {"
     "    \"Value\": \"maybe\","
     "    \"Level\": \"Recommended\""
     "  }"
     "}";
 
+const char kTestSchema[] =
+    "{"
+    "  \"$schema\": \"http://json-schema.org/draft-03/schema#\","
+    "  \"type\": \"object\","
+    "  \"properties\": {"
+    "    \"Name\": { \"type\": \"string\" },"
+    "    \"Second\": { \"type\": \"string\" }"
+    "  }"
+    "}";
+
 class MockComponentCloudPolicyDelegate
     : public ComponentCloudPolicyService::Delegate {
  public:
   virtual ~MockComponentCloudPolicyDelegate() {}
 
   MOCK_METHOD0(OnComponentCloudPolicyRefreshNeeded, void());
   MOCK_METHOD0(OnComponentCloudPolicyUpdated, void());
 };
 
 class TestURLRequestContextGetter : public net::URLRequestContextGetter {
@@ skipping 102 matching lines @@
   scoped_ptr<em::PolicyFetchResponse> CreateResponse() {
     builder_.Build();
     return make_scoped_ptr(new em::PolicyFetchResponse(builder_.policy()));
   }
 
   std::string CreateSerializedResponse() {
     builder_.Build();
     return builder_.GetBlob();
   }
 
+  scoped_ptr<PolicySchema> CreateTestSchema() {
+    std::string error;
+    scoped_ptr<PolicySchema> schema = PolicySchema::Parse(kTestSchema, &error);
+    EXPECT_TRUE(schema) << error;
+    return schema.Pass();
+  }
+
   MessageLoop loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   base::ScopedTempDir temp_dir_;
   scoped_refptr<TestURLRequestContextGetter> request_context_;
   net::TestURLFetcherFactory fetcher_factory_;
   MockComponentCloudPolicyDelegate delegate_;
   // |cache_| is owned by the |service_| and is invalid once the |service_|
   // is destroyed.
   ResourceCache* cache_;
@@ skipping 54 matching lines @@
   std::map<std::string, std::string> contents;
   cache_->LoadAllSubkeys(ComponentCloudPolicyService::kComponentNamespaceCache,
                          &contents);
   ASSERT_EQ(1u, contents.size());
   EXPECT_EQ(std::string(dm_protocol::kChromeExtensionPolicyType),
             contents.begin()->first);
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, ConnectAfterRegister) {
   // Add some components.
-  std::set<std::string> components;
-  components.insert(kTestExtension);
-  components.insert(kTestExtension2);
-  service_->RegisterPolicyDomain(POLICY_DOMAIN_EXTENSIONS, components);
+  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
+      POLICY_DOMAIN_EXTENSIONS);
+  descriptor->SetComponent(kTestExtension, CreateTestSchema());
+  descriptor->SetComponent(kTestExtension2, CreateTestSchema());
+  service_->RegisterPolicyDomain(descriptor);
 
   // Now connect the client.
   EXPECT_TRUE(client_.namespaces_to_fetch_.empty());
   service_->Connect(&client_, request_context_);
   EXPECT_TRUE(client_.namespaces_to_fetch_.empty());
 
   // It receives the namespaces once the backend is initialized.
   LoadStore();
   std::set<PolicyNamespaceKey> set;
   set.insert(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
@@ skipping 14 matching lines @@
   PickleIterator pickit(pickle);
   std::string value0;
   std::string value1;
   std::string tmp;
   ASSERT_TRUE(pickit.ReadString(&value0));
   ASSERT_TRUE(pickit.ReadString(&value1));
   EXPECT_FALSE(pickit.ReadString(&tmp));
   std::set<std::string> unpickled;
   unpickled.insert(value0);
   unpickled.insert(value1);
-  EXPECT_EQ(components, unpickled);
+
+  std::set<std::string> expected_components;
+  expected_components.insert(kTestExtension);
+  expected_components.insert(kTestExtension2);
+
+  EXPECT_EQ(expected_components, unpickled);
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, StoreReadyAfterConnectAndRegister) {
   // Add some previous data to the cache.
   PopulateCache();
 
   // Add some components.
-  std::set<std::string> components;
-  components.insert(kTestExtension);
-  service_->RegisterPolicyDomain(POLICY_DOMAIN_EXTENSIONS, components);
+  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
+      POLICY_DOMAIN_EXTENSIONS);
+  descriptor->SetComponent(kTestExtension, CreateTestSchema());
+  service_->RegisterPolicyDomain(descriptor);
 
   // And connect the client. Make the client have some policies, with a new
   // download_url.
   builder_.payload().set_download_url(kTestDownload2);
   client_.SetPolicy(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
                                        kTestExtension),
                     *CreateResponse());
   service_->Connect(&client_, request_context_);
 
   // Now make the store ready.
@@ skipping 15 matching lines @@
   EXPECT_EQ(GURL(kTestDownload2), fetcher->GetOriginalURL());
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, ConnectThenRegisterThenStoreReady) {
   // Connect right after creating the service.
   service_->Connect(&client_, request_context_);
 
   // Now register the current components, before the backend has been
   // initialized.
   EXPECT_TRUE(client_.namespaces_to_fetch_.empty());
-  std::set<std::string> components;
-  components.insert(kTestExtension);
-  service_->RegisterPolicyDomain(POLICY_DOMAIN_EXTENSIONS, components);
+  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
+      POLICY_DOMAIN_EXTENSIONS);
+  descriptor->SetComponent(kTestExtension, CreateTestSchema());
+  service_->RegisterPolicyDomain(descriptor);
   EXPECT_TRUE(client_.namespaces_to_fetch_.empty());
 
   // Now load the store. The client gets the namespaces.
   LoadStore();
   std::set<PolicyNamespaceKey> set;
   set.insert(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
                                 kTestExtension));
   EXPECT_EQ(set, client_.namespaces_to_fetch_);
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, FetchPolicy) {
   // Initialize the store and create the backend, and connect the client.
   LoadStore();
   // A refresh is not needed, because no components were found.
   EXPECT_CALL(delegate_, OnComponentCloudPolicyRefreshNeeded()).Times(0);
   service_->Connect(&client_, request_context_);
   Mock::VerifyAndClearExpectations(&delegate_);
 
   // Register the components to fetch.
-  std::set<std::string> components;
-  components.insert(kTestExtension);
+  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
+      POLICY_DOMAIN_EXTENSIONS);
+  descriptor->SetComponent(kTestExtension, CreateTestSchema());
   EXPECT_CALL(delegate_, OnComponentCloudPolicyRefreshNeeded());
-  service_->RegisterPolicyDomain(POLICY_DOMAIN_EXTENSIONS, components);
+  service_->RegisterPolicyDomain(descriptor);
   Mock::VerifyAndClearExpectations(&delegate_);
 
   // Send back a fake policy fetch response.
   client_.SetPolicy(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
                                        kTestExtension),
                     *CreateResponse());
   service_->OnPolicyFetched(&client_);
   RunUntilIdle();
 
   // That should have triggered the download fetch.
@@ skipping 30 matching lines @@
   PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, kTestExtension);
   expected_bundle.Get(ns).CopyFrom(expected_policy_);
   ns.component_id = kTestExtension2;
   expected_bundle.Get(ns).CopyFrom(expected_policy_);
   EXPECT_TRUE(service_->policy().Equals(expected_bundle));
 
   // Now purge one of the extensions.
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
   // The service will start updating the components that are registered, which
   // starts by fetching policy for them.
-  std::set<std::string> keep;
-  keep.insert(kTestExtension2);
-  service_->RegisterPolicyDomain(POLICY_DOMAIN_EXTENSIONS, keep);
+  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
+      POLICY_DOMAIN_EXTENSIONS);
+  descriptor->SetComponent(kTestExtension2, CreateTestSchema());
+  service_->RegisterPolicyDomain(descriptor);
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(&delegate_);
 
   ns.component_id = kTestExtension;
   expected_bundle.Get(ns).Clear();
   EXPECT_TRUE(service_->policy().Equals(expected_bundle));
 
   std::map<std::string, std::string> contents;
   cache_->LoadAllSubkeys("extension-policy", &contents);
   EXPECT_EQ(1u, contents.size());
@@ skipping 10 matching lines @@
   store_.policy_.reset(new em::PolicyData());  //  No credentials.
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
   store_.NotifyStoreLoaded();
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(&delegate_);
   EXPECT_TRUE(service_->is_initialized());
 
   // Connect the client and register an extension.
   service_->Connect(&client_, request_context_);
   EXPECT_CALL(delegate_, OnComponentCloudPolicyRefreshNeeded());
-  std::set<std::string> components;
-  components.insert(kTestExtension);
-  service_->RegisterPolicyDomain(POLICY_DOMAIN_EXTENSIONS, components);
+  scoped_refptr<PolicyDomainDescriptor> descriptor = new PolicyDomainDescriptor(
+      POLICY_DOMAIN_EXTENSIONS);
+  descriptor->SetComponent(kTestExtension, CreateTestSchema());
+  service_->RegisterPolicyDomain(descriptor);
   Mock::VerifyAndClearExpectations(&delegate_);
 
   // Send the response to the service. The response data will be rejected,
   // because the store doesn't have the updated credentials yet.
   client_.SetPolicy(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
                                        kTestExtension),
                     *CreateResponse());
   service_->OnPolicyFetched(&client_);
   RunUntilIdle();
 
@@ skipping 23 matching lines @@
   Mock::VerifyAndClearExpectations(&delegate_);
 
   // The policy is now being served.
   PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, kTestExtension);
   PolicyBundle expected_bundle;
   expected_bundle.Get(ns).CopyFrom(expected_policy_);
   EXPECT_TRUE(service_->policy().Equals(expected_bundle));
 }
 
 }  // namespace policy