Tests for cloud policy UMA metrics.

chrome/browser/policy/device_policy_cache_unittest.cc

 // Copyright (c) 2011 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/device_policy_cache.h"
 
 #include "chrome/browser/chromeos/cros/cryptohome_library.h"
+#include "chrome/browser/chromeos/login/mock_signed_settings_helper.h"
 #include "chrome/browser/policy/cloud_policy_data_store.h"
 #include "chrome/browser/policy/enterprise_install_attributes.h"
 #include "policy/configuration_policy_type.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace policy {
 
 namespace {
 
 // Test registration user name.
 const char kTestUser[] = "test@example.com";
 
 using ::chromeos::SignedSettings;
 using ::chromeos::SignedSettingsHelper;
 using ::testing::_;
 using ::testing::InSequence;
 
-class MockSignedSettingsHelper : public SignedSettingsHelper {
- public:
-  MockSignedSettingsHelper() {}
-  virtual ~MockSignedSettingsHelper() {}
-
-  MOCK_METHOD2(StartStorePolicyOp, void(const em::PolicyFetchResponse&,
-                                        SignedSettingsHelper::Callback*));
-  MOCK_METHOD1(StartRetrievePolicyOp, void(SignedSettingsHelper::Callback*));
-  MOCK_METHOD1(CancelCallback, void(SignedSettingsHelper::Callback*));
-
-  // This test doesn't need these methods, but since they're pure virtual in
-  // SignedSettingsHelper, they must be implemented:
-  MOCK_METHOD2(StartCheckWhitelistOp, void(const std::string&,
-                                           SignedSettingsHelper::Callback*));
-  MOCK_METHOD3(StartWhitelistOp, void(const std::string&, bool,
-                                      SignedSettingsHelper::Callback*));
-  MOCK_METHOD3(StartStorePropertyOp, void(const std::string&,
-                                          const std::string&,
-                                          SignedSettingsHelper::Callback*));
-  MOCK_METHOD2(StartRetrieveProperty, void(const std::string&,
-                                           SignedSettingsHelper::Callback*));
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(MockSignedSettingsHelper);
-};
-
-ACTION_P(MockSignedSettingsHelperStorePolicy, status_code) {
-  arg1->OnStorePolicyCompleted(status_code);
-}
-
-ACTION_P2(MockSignedSettingsHelperRetrievePolicy, status_code, policy) {
-  arg0->OnRetrievePolicyCompleted(status_code, policy);
-}
-
 void CreateRefreshRatePolicy(em::PolicyFetchResponse* policy,
                              const std::string& user,
                              int refresh_rate) {
   // This method omits a few fields which currently aren't needed by tests:
   // timestamp, machine_name, policy_type, public key info.
   em::PolicyData signed_response;
   em::ChromeDeviceSettingsProto settings;
   settings.mutable_device_policy_refresh_rate()->
       set_device_policy_refresh_rate(refresh_rate);
   signed_response.set_username(user);
@@ skipping 59 matching lines @@
     return cache_->mandatory_policy_.Get(policy);
   }
 
   const Value* GetRecommendedPolicy(ConfigurationPolicyType policy) {
     return cache_->recommended_policy_.Get(policy);
   }
 
   scoped_ptr<chromeos::CryptohomeLibrary> cryptohome_;
   EnterpriseInstallAttributes install_attributes_;
   scoped_ptr<CloudPolicyDataStore> data_store_;
-  MockSignedSettingsHelper signed_settings_helper_;
+  chromeos::MockSignedSettingsHelper signed_settings_helper_;
   scoped_ptr<DevicePolicyCache> cache_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DevicePolicyCacheTest);
 };
 
 TEST_F(DevicePolicyCacheTest, Startup) {
   em::PolicyFetchResponse policy;
   CreateRefreshRatePolicy(&policy, kTestUser, 120);
   EXPECT_CALL(signed_settings_helper_, StartRetrievePolicyOp(_)).WillOnce(
@@ skipping 26 matching lines @@
                                 kPolicyDevicePolicyRefreshRate)));
 
   // Set new policy information.
   em::PolicyFetchResponse new_policy;
   CreateRefreshRatePolicy(&new_policy, kTestUser, 300);
   EXPECT_CALL(signed_settings_helper_, StartStorePolicyOp(_, _)).WillOnce(
       MockSignedSettingsHelperStorePolicy(chromeos::SignedSettings::SUCCESS));
   EXPECT_CALL(signed_settings_helper_, StartRetrievePolicyOp(_)).WillOnce(
       MockSignedSettingsHelperRetrievePolicy(SignedSettings::SUCCESS,
                                              new_policy));
+  EXPECT_CALL(signed_settings_helper_, CancelCallback(_));
   cache_->SetPolicy(new_policy);
   testing::Mock::VerifyAndClearExpectations(&signed_settings_helper_);
   FundamentalValue updated_expected(300);
   EXPECT_TRUE(Value::Equals(&updated_expected,
                             GetMandatoryPolicy(
                                 kPolicyDevicePolicyRefreshRate)));
 }
 
 TEST_F(DevicePolicyCacheTest, SetPolicyWrongUser) {
   InSequence s;
@@ skipping 69 matching lines @@
                             GetRecommendedPolicy(kPolicyProxyMode)));
   EXPECT_TRUE(Value::Equals(&expected_proxy_server,
                             GetRecommendedPolicy(kPolicyProxyServer)));
   EXPECT_TRUE(Value::Equals(&expected_proxy_pac_url,
                             GetRecommendedPolicy(kPolicyProxyPacUrl)));
   EXPECT_TRUE(Value::Equals(&expected_proxy_bypass_list,
                             GetRecommendedPolicy(kPolicyProxyBypassList)));
 }
 
 }  // namespace policy