Implement cloud policy invalidations using the invalidation service framework.

chrome/browser/policy/cloud/cloud_policy_manager_unittest.cc

 // Copyright (c) 2012 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/cloud_policy_manager.h"
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/test/test_simple_task_runner.h"
+#include "chrome/browser/invalidation/fake_invalidation_service.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
+#include "chrome/browser/policy/cloud/cloud_policy_invalidator.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/configuration_policy_provider_test.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
+#include "sync/notifier/invalidation_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Mock;
 using testing::_;
 
 namespace em = enterprise_management;
 
 namespace policy {
 namespace {
@@ skipping 107 matching lines @@
                                dm_protocol::kChromeUserPolicyType,
                                std::string()),
                            store) {}
   virtual ~TestCloudPolicyManager() {}
 
   // Publish the protected members for testing.
   using CloudPolicyManager::client;
   using CloudPolicyManager::store;
   using CloudPolicyManager::service;
   using CloudPolicyManager::CheckAndPublishPolicy;
+  using CloudPolicyManager::StartRefreshScheduler;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestCloudPolicyManager);
 };
 
 MATCHER_P(ProtoMatches, proto, "") {
   return arg.SerializePartialAsString() == proto.SerializePartialAsString();
 }
 
 class CloudPolicyManagerTest : public testing::Test {
@@ skipping 16 matching lines @@
     manager_->Init();
     Mock::VerifyAndClearExpectations(&store_);
     manager_->AddObserver(&observer_);
   }
 
   virtual void TearDown() OVERRIDE {
     manager_->RemoveObserver(&observer_);
     manager_->Shutdown();
   }
 
+  // Sets up for an invalidations test.
+  void CreateInvalidator() {
+    // Add the invalidation registration info to the policy data.
+    em::PolicyData* policy_data = new em::PolicyData(policy_.policy_data());
+    policy_data->set_invalidation_source(12345);
+    policy_data->set_invalidation_name("12345");
+    store_.policy_.reset(policy_data);
+
+    // Connect the core.
+    MockCloudPolicyClient* client = new MockCloudPolicyClient();
+    EXPECT_CALL(*client, SetupRegistration(_, _));
+    manager_->core()->Connect(scoped_ptr<CloudPolicyClient>(client));
+
+    // Create invalidation objects.
+    task_runner_ = new base::TestSimpleTaskRunner();
+    invalidation_service_.reset(new invalidation::FakeInvalidationService());
+    invalidator_.reset(new CloudPolicyInvalidator(
+        manager_.get(),
+        manager_->core()->store(),
+        task_runner_));
+  }
+
+  void ShutdownInvalidator() {
+    invalidator_->Shutdown();
+  }
+
+  // Call EnableInvalidations on the manager.
+  void EnableInvalidations() {
+    manager_->EnableInvalidations(
+        base::Bind(
+            &CloudPolicyInvalidator::InitializeWithService,
+            base::Unretained(invalidator_.get()),
+            base::Unretained(invalidation_service_.get())));
+  }
+
+  // Determine if the invalidator has registered with the invalidation service.
+  bool IsInvalidatorRegistered() {
+    syncer::ObjectIdSet object_ids =
+        invalidation_service_->invalidator_registrar().GetAllRegisteredIds();
+    return object_ids.size() == 1 &&
+        object_ids.begin()->source() == 12345 &&
+        object_ids.begin()->name() == "12345";
+  }
+
+  // Determine if the invalidator is unregistered with the invalidation service.
+  bool IsInvalidatorUnregistered() {
+    syncer::ObjectIdSet object_ids =
+        invalidation_service_->invalidator_registrar().GetAllRegisteredIds();
+    return object_ids.empty();
+  }
+
   // Required by the refresh scheduler that's created by the manager.
   base::MessageLoop loop_;
 
   // Testing policy.
   const PolicyNamespaceKey policy_ns_key_;
   UserPolicyBuilder policy_;
   PolicyMap policy_map_;
   PolicyBundle expected_bundle_;
 
   // Policy infrastructure.
   MockConfigurationPolicyObserver observer_;
   MockCloudPolicyStore store_;
   scoped_ptr<TestCloudPolicyManager> manager_;
 
+  // Invalidation objects.
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+  scoped_ptr<invalidation::FakeInvalidationService> invalidation_service_;
+  scoped_ptr<CloudPolicyInvalidator> invalidator_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyManagerTest);
 };
 
 TEST_F(CloudPolicyManagerTest, InitAndShutdown) {
   PolicyBundle empty_bundle;
   EXPECT_TRUE(empty_bundle.Equals(manager_->policies()));
   EXPECT_FALSE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
 
   EXPECT_CALL(observer_, OnUpdatePolicy(_)).Times(0);
@@ skipping 124 matching lines @@
 TEST_F(CloudPolicyManagerTest, SignalOnError) {
   // Simulate a failed load and verify that it triggers OnUpdatePolicy().
   store_.policy_.reset(new em::PolicyData(policy_.policy_data()));
   EXPECT_CALL(observer_, OnUpdatePolicy(manager_.get()));
   store_.NotifyStoreError();
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
 }
 
+TEST_F(CloudPolicyManagerTest, EnableInvalidationsBeforeRefreshScheduler) {
+  CreateInvalidator();
+  EXPECT_TRUE(IsInvalidatorUnregistered());
+  EnableInvalidations();
+  EXPECT_TRUE(IsInvalidatorUnregistered());
+  manager_->StartRefreshScheduler();
+  EXPECT_TRUE(IsInvalidatorRegistered());
+  ShutdownInvalidator();
+}
+
+TEST_F(CloudPolicyManagerTest, EnableInvalidationsAfterRefreshScheduler) {
+  CreateInvalidator();
+  EXPECT_TRUE(IsInvalidatorUnregistered());
+  manager_->StartRefreshScheduler();
+  EXPECT_TRUE(IsInvalidatorUnregistered());
+  EnableInvalidations();
+  EXPECT_TRUE(IsInvalidatorRegistered());
+  ShutdownInvalidator();
+}
+
 }  // namespace
 }  // namespace policy