Signed settings refactoring: Proper caching and more tests.

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 "content/test/test_browser_thread.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";
@@ skipping 42 matching lines @@
   proxy_settings->set_proxy_bypass_list(proxy_bypass_list);
   CreatePolicy(policy, user, settings);
 }
 
 }  // namespace
 
 class DevicePolicyCacheTest : public testing::Test {
  protected:
   DevicePolicyCacheTest()
       : cryptohome_(chromeos::CryptohomeLibrary::GetImpl(true)),
-        install_attributes_(cryptohome_.get()) {}
+        install_attributes_(cryptohome_.get()),
+        message_loop_(MessageLoop::TYPE_UI),
+        ui_thread_(content::BrowserThread::UI, &message_loop_),
+        file_thread_(content::BrowserThread::FILE, &message_loop_) {}
 
   virtual void SetUp() {
     data_store_.reset(CloudPolicyDataStore::CreateForUserPolicies());
     cache_.reset(new DevicePolicyCache(data_store_.get(),
                                        &install_attributes_,
                                        &signed_settings_helper_));
   }
 
   virtual void TearDown() {
-    EXPECT_CALL(signed_settings_helper_, CancelCallback(_));
     cache_.reset();
   }
 
   void MakeEnterpriseDevice(const char* registration_user) {
     ASSERT_EQ(EnterpriseInstallAttributes::LOCK_SUCCESS,
               install_attributes_.LockDevice(registration_user));
   }
 
   const Value* GetMandatoryPolicy(ConfigurationPolicyType policy) {
     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_;
   chromeos::MockSignedSettingsHelper signed_settings_helper_;
   scoped_ptr<DevicePolicyCache> cache_;
 
+  MessageLoop message_loop_;
+  content::TestBrowserThread ui_thread_;
+  content::TestBrowserThread file_thread_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(DevicePolicyCacheTest);
 };
 
 TEST_F(DevicePolicyCacheTest, Startup) {
   em::PolicyFetchResponse policy;
   CreateRefreshRatePolicy(&policy, kTestUser, 120);
   EXPECT_CALL(signed_settings_helper_, StartRetrievePolicyOp(_)).WillOnce(
       MockSignedSettingsHelperRetrievePolicy(SignedSettings::SUCCESS,
                                              policy));
@@ skipping 24 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_);
   base::FundamentalValue updated_expected(300);
   EXPECT_TRUE(Value::Equals(&updated_expected,
                             GetMandatoryPolicy(
                                 kPolicyDevicePolicyRefreshRate)));
 }
 
 TEST_F(DevicePolicyCacheTest, SetPolicyWrongUser) {
   InSequence s;
@@ skipping 88 matching lines @@
                                              policy));
   cache_->Load();
   testing::Mock::VerifyAndClearExpectations(&signed_settings_helper_);
   StringValue expected_config(fake_config);
   EXPECT_TRUE(
       Value::Equals(&expected_config,
                     GetMandatoryPolicy(kPolicyDeviceOpenNetworkConfiguration)));
 }
 
 }  // namespace policy