Precache policy-for-extensions for device-local accounts.

components/policy/core/common/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 "components/policy/core/common/cloud/component_cloud_policy_service.h"
 
 #include <map>
 #include <string>
 
 #include "base/callback.h"
@@ skipping 147 matching lines @@
     core_.Connect(scoped_ptr<CloudPolicyClient>(client_));
 
     // |expected_namespaces_in_client| is the expected number of components
     // that the ComponentCloudPolicyService will set at the |client_| at
     // OnCoreConnected.
     EXPECT_EQ(expected_namespaces_in_client,
               client_->namespaces_to_fetch_.size());
 
     // Also initialize the refresh scheduler, so that calls to
     // core()->RefreshSoon() trigger a FetchPolicy() call on the mock |client_|.
+    // The |service_| should never trigger new fetches.
     EXPECT_CALL(*client_, FetchPolicy());
     core_.StartRefreshScheduler();
     RunUntilIdle();
     Mock::VerifyAndClearExpectations(client_);
   }
 
   void LoadStore() {
     EXPECT_FALSE(store_.is_initialized());
 
     em::PolicyData* data = new em::PolicyData();
@@ skipping 71 matching lines @@
   service_.reset(new ComponentCloudPolicyService(&delegate_,
                                                  &registry_,
                                                  &core_,
                                                  make_scoped_ptr(cache_),
                                                  request_context_,
                                                  loop_.message_loop_proxy(),
                                                  loop_.message_loop_proxy()));
   EXPECT_FALSE(service_->is_initialized());
 
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
-  EXPECT_CALL(*client_, FetchPolicy());
+  EXPECT_CALL(*client_, FetchPolicy()).Times(0);
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(&client_);
   Mock::VerifyAndClearExpectations(&delegate_);
 
   EXPECT_TRUE(service_->is_initialized());
   EXPECT_EQ(2u, client_->namespaces_to_fetch_.size());
   const PolicyBundle empty_bundle;
   EXPECT_TRUE(service_->policy().Equals(empty_bundle));
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, InitializeStoreThenRegistry) {
-  Connect(1u);
+  Connect(2u);
 
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated()).Times(0);
   EXPECT_CALL(*client_, FetchPolicy()).Times(0);
   LoadStore();
   Mock::VerifyAndClearExpectations(client_);
   Mock::VerifyAndClearExpectations(&delegate_);
   EXPECT_FALSE(service_->is_initialized());
 
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
-  EXPECT_CALL(*client_, FetchPolicy());
+  EXPECT_CALL(*client_, FetchPolicy()).Times(0);
   InitializeRegistry();
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_);
   Mock::VerifyAndClearExpectations(&delegate_);
   EXPECT_TRUE(service_->is_initialized());
 
   const PolicyBundle empty_bundle;
   EXPECT_TRUE(service_->policy().Equals(empty_bundle));
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, InitializeRegistryThenStore) {
-  Connect(1u);
+  Connect(2u);
 
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated()).Times(0);
   EXPECT_CALL(*client_, FetchPolicy()).Times(0);
   InitializeRegistry();
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_);
   Mock::VerifyAndClearExpectations(&delegate_);
   EXPECT_FALSE(service_->is_initialized());
 
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
-  EXPECT_CALL(*client_, FetchPolicy());
+  EXPECT_CALL(*client_, FetchPolicy()).Times(0);
   LoadStore();
   Mock::VerifyAndClearExpectations(client_);
   Mock::VerifyAndClearExpectations(&delegate_);
   EXPECT_TRUE(service_->is_initialized());
   EXPECT_EQ(2u, client_->namespaces_to_fetch_.size());
   const PolicyBundle empty_bundle;
   EXPECT_TRUE(service_->policy().Equals(empty_bundle));
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, InitializeWithCachedPolicy) {
   PopulateCache();
-  Connect(1u);
+  Connect(2u);
 
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
-  EXPECT_CALL(*client_, FetchPolicy());
+  EXPECT_CALL(*client_, FetchPolicy()).Times(0);
   InitializeRegistry();
   LoadStore();
   Mock::VerifyAndClearExpectations(client_);
   Mock::VerifyAndClearExpectations(&delegate_);
 
   EXPECT_TRUE(service_->is_initialized());
   EXPECT_EQ(2u, client_->namespaces_to_fetch_.size());
 
   // kTestExtension2 is not in the registry so it was dropped.
   std::map<std::string, std::string> contents;
   cache_->LoadAllSubkeys("extension-policy", &contents);
   ASSERT_EQ(1u, contents.size());
   EXPECT_EQ(kTestExtension, contents.begin()->first);
 
   PolicyBundle expected_bundle;
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, kTestExtension);
   expected_bundle.Get(ns).CopyFrom(expected_policy_);
   EXPECT_TRUE(service_->policy().Equals(expected_bundle));
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, FetchPolicy) {
-  Connect(1u);
+  Connect(2u);
   // Initialize the store and create the backend.
   // A refresh is not needed, because no components are registered yet.
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
   EXPECT_CALL(*client_, FetchPolicy()).Times(0);
   registry_.SetReady(POLICY_DOMAIN_CHROME);
   registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
   LoadStore();
   Mock::VerifyAndClearExpectations(client_);
   Mock::VerifyAndClearExpectations(&delegate_);
   EXPECT_TRUE(service_->is_initialized());
 
-  // Register the components to fetch.
-  EXPECT_CALL(*client_, FetchPolicy());
+  // Register the components to fetch. The |service_| issues a new update
+  // because the new schema may filter different policies from the store.
+  EXPECT_CALL(*client_, FetchPolicy()).Times(0);
+  EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
   registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension),
       CreateTestSchema());
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_);
+  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.
   net::TestURLFetcher* fetcher = fetcher_factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(GURL(kTestDownload), fetcher->GetOriginalURL());
   fetcher->set_response_code(200);
   fetcher->SetResponseString(kTestPolicy);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(&delegate_);
 
   // The policy is now being served.
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, kTestExtension);
   PolicyBundle expected_bundle;
   expected_bundle.Get(ns).CopyFrom(expected_policy_);
   EXPECT_TRUE(service_->policy().Equals(expected_bundle));
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, LoadAndPurgeCache) {
-  Connect(1u);
+  Connect(2u);
   // Insert data in the cache.
   PopulateCache();
   registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension2),
       CreateTestSchema());
   InitializeRegistry();
 
   // Load the initial cache.
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
-  EXPECT_CALL(*client_, FetchPolicy());
+  EXPECT_CALL(*client_, FetchPolicy()).Times(0);
   LoadStore();
   Mock::VerifyAndClearExpectations(client_);
   Mock::VerifyAndClearExpectations(&delegate_);
 
   PolicyBundle expected_bundle;
   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());
+  // Now purge one of the extensions. This generates 2 notifications: one for
+  // the new, immediate filtering, and another once the backend comes back
+  // after purging the cache.
+  EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated()).Times(2);
   registry_.UnregisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension));
   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());
   EXPECT_TRUE(ContainsKey(contents, kTestExtension2));
 }
 
 TEST_F(ComponentCloudPolicyServiceTest, SignInAfterStartup) {
   registry_.SetReady(POLICY_DOMAIN_CHROME);
   registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
 
   // Initialize the store without credentials.
   EXPECT_FALSE(store_.is_initialized());
   EXPECT_FALSE(service_->is_initialized());
   EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
   store_.NotifyStoreLoaded();
   RunUntilIdle();
   Mock::VerifyAndClearExpectations(&delegate_);
   EXPECT_TRUE(service_->is_initialized());
 
   // Register an extension.
+  EXPECT_CALL(delegate_, OnComponentCloudPolicyUpdated());
   registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, kTestExtension),
       CreateTestSchema());
   RunUntilIdle();
+  Mock::VerifyAndClearExpectations(&delegate_);
 
   // Now signin. A fetch will be requested for the new extension.
   Connect(2u);
 
   // Send the response to the service. The response data will be ignored,
   // because the store doesn't have the updated credentials yet.
   client_->SetPolicy(PolicyNamespaceKey(dm_protocol::kChromeExtensionPolicyType,
                                         kTestExtension),
                      *CreateResponse());
   service_->OnPolicyFetched(client_);
@@ skipping 87 matching lines @@
 
   PolicyBundle expected_bundle;
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, kTestExtension);
   expected_bundle.Get(ns).Set("Name", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                               base::Value::CreateStringValue("published"),
                               NULL);
   EXPECT_TRUE(service_->policy().Equals(expected_bundle));
 }
 
 }  // namespace policy