Pass the previous and the current PolicyMap to Observers of the PolicyService.

chrome/browser/policy/policy_service_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/policy_service_impl.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::AnyNumber;
 using ::testing::Mock;
 using ::testing::_;
 
 namespace policy {
 
 namespace {
 
 class MockPolicyServiceObserver : public PolicyService::Observer {
  public:
   virtual ~MockPolicyServiceObserver() {}
-  MOCK_METHOD2(OnPolicyUpdated, void(PolicyDomain, const std::string&));
+  MOCK_METHOD4(OnPolicyUpdated, void(PolicyDomain,
+                                     const std::string&,
+                                     const PolicyMap& previous,
+                                     const PolicyMap& current));
 };
 
+// Helper to copy the PolicyMaps passed as arguments to an EXPECT_CALL of
+// OnPolicyUpdated.
+ACTION_P2(CopyPolicies, previous, current) {
+  previous->CopyFrom(arg2);
+  current->CopyFrom(arg3);
+}
+
 class PolicyServiceTest : public testing::Test {
  public:
   PolicyServiceTest() {}
 
   void SetUp() OVERRIDE {
     provider0_.AddMandatoryPolicy("pre", base::Value::CreateIntegerValue(13));
     provider0_.SetInitializationComplete(true);
     provider1_.SetInitializationComplete(true);
     provider2_.SetInitializationComplete(true);
     PolicyServiceImpl::Providers providers;
@@ skipping 29 matching lines @@
 };
 
 TEST_F(PolicyServiceTest, LoadsPoliciesBeforeProvidersRefresh) {
   PolicyMap expected;
   expected.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                base::Value::CreateIntegerValue(13));
   EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
 }
 
 TEST_F(PolicyServiceTest, NotifyObservers) {
-  PolicyMap expected;
-  expected.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(13));
+  PolicyMap expectedPrevious;
+  expectedPrevious.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+                       base::Value::CreateIntegerValue(13));
 
-  expected.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(123));
+  PolicyMap expectedCurrent;
+  expectedCurrent.CopyFrom(expectedPrevious);
+  expectedCurrent.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+                      base::Value::CreateIntegerValue(123));
   provider0_.AddMandatoryPolicy("aaa", base::Value::CreateIntegerValue(123));
-  EXPECT_CALL(observer_, OnPolicyUpdated(POLICY_DOMAIN_CHROME, "")).Times(1);
+
+  PolicyMap previous;
+  PolicyMap current;
+  EXPECT_CALL(observer_, OnPolicyUpdated(POLICY_DOMAIN_CHROME, "", _, _))
+      .WillOnce(CopyPolicies(&previous, &current));
   provider0_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
+  EXPECT_TRUE(previous.Equals(expectedPrevious));
+  EXPECT_TRUE(current.Equals(expectedCurrent));

[Mattias Nissler (ping if slow), 2012/04/23 14:20:44]

This pattern does manually what you can achieve by using a matcher that on the
EXPECT_CALL for parameters 3 and 4 in line 98. See MATCHER_P in the gmock docs.
(Also below).

[Joao da Silva, 2012/04/23 14:53:19]

Thanks for the tip, MATCHER is quite cool! PTAL.

+
   // No changes.
-  EXPECT_CALL(observer_, OnPolicyUpdated(_, _)).Times(0);
+  EXPECT_CALL(observer_, OnPolicyUpdated(_, _, _, _)).Times(0);
   provider0_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
+  EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expectedCurrent));
+
   // New policy.
-  expected.Set("bbb", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(456));
+  expectedPrevious.CopyFrom(current);
+  expectedCurrent.Set("bbb", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+                       base::Value::CreateIntegerValue(456));
   provider0_.AddMandatoryPolicy("bbb", base::Value::CreateIntegerValue(456));
-  EXPECT_CALL(observer_, OnPolicyUpdated(POLICY_DOMAIN_CHROME, "")).Times(1);
+  EXPECT_CALL(observer_, OnPolicyUpdated(POLICY_DOMAIN_CHROME, "", _, _))
+      .WillOnce(CopyPolicies(&previous, &current));
   provider0_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
+  EXPECT_TRUE(previous.Equals(expectedPrevious));
+  EXPECT_TRUE(current.Equals(expectedCurrent));
+
   // Removed policy.
-  expected.Erase("bbb");
+  expectedPrevious.CopyFrom(current);
+  expectedCurrent.Erase("bbb");
   provider0_.RemovePolicy("bbb");
-  EXPECT_CALL(observer_, OnPolicyUpdated(POLICY_DOMAIN_CHROME, "")).Times(1);
+  EXPECT_CALL(observer_, OnPolicyUpdated(POLICY_DOMAIN_CHROME, "", _, _))
+      .WillOnce(CopyPolicies(&previous, &current));
   provider0_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
+  EXPECT_TRUE(previous.Equals(expectedPrevious));
+  EXPECT_TRUE(current.Equals(expectedCurrent));
+
   // Changed policy.
-  expected.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
-               base::Value::CreateIntegerValue(789));
+  expectedPrevious.CopyFrom(current);
+  expectedCurrent.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
+                      base::Value::CreateIntegerValue(789));
   provider0_.AddMandatoryPolicy("aaa", base::Value::CreateIntegerValue(789));
-  EXPECT_CALL(observer_, OnPolicyUpdated(POLICY_DOMAIN_CHROME, "")).Times(1);
+  EXPECT_CALL(observer_, OnPolicyUpdated(POLICY_DOMAIN_CHROME, "", _, _))
+      .WillOnce(CopyPolicies(&previous, &current));
   provider0_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
+  EXPECT_TRUE(previous.Equals(expectedPrevious));
+  EXPECT_TRUE(current.Equals(expectedCurrent));
+
   // No changes again.
-  EXPECT_CALL(observer_, OnPolicyUpdated(_, _)).Times(0);
+  EXPECT_CALL(observer_, OnPolicyUpdated(_, _, _, _)).Times(0);
   provider0_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
+  EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expectedCurrent));
 }
 
 TEST_F(PolicyServiceTest, Priorities) {
   PolicyMap expected;
   expected.Set("pre", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                base::Value::CreateIntegerValue(13));
-  EXPECT_CALL(observer_, OnPolicyUpdated(_, _)).Times(AnyNumber());
+  EXPECT_CALL(observer_, OnPolicyUpdated(_, _, _, _)).Times(AnyNumber());
 
   expected.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                base::Value::CreateIntegerValue(0));
   provider0_.AddMandatoryPolicy("aaa", base::Value::CreateIntegerValue(0));
   provider1_.AddMandatoryPolicy("aaa", base::Value::CreateIntegerValue(1));
   provider2_.AddMandatoryPolicy("aaa", base::Value::CreateIntegerValue(2));
   provider0_.RefreshPolicies();
   provider1_.RefreshPolicies();
   provider2_.RefreshPolicies();
   EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
 
   expected.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                base::Value::CreateIntegerValue(1));
   provider0_.RemovePolicy("aaa");
   provider0_.RefreshPolicies();
   EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
 
   expected.Set("aaa", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                base::Value::CreateIntegerValue(2));
   provider1_.AddRecommendedPolicy("aaa", base::Value::CreateIntegerValue(1));
   provider1_.RefreshPolicies();
   EXPECT_TRUE(VerifyPolicies(POLICY_DOMAIN_CHROME, "", expected));
 }
 
 }  // namespace
 
 }  // namespace policy