device_settings_test_helper.h revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef CHROME_BROWSER_CHROMEOS_SETTINGS_DEVICE_SETTINGS_TEST_HELPER_H_ 6#define CHROME_BROWSER_CHROMEOS_SETTINGS_DEVICE_SETTINGS_TEST_HELPER_H_ 7 8#include <map> 9#include <string> 10#include <vector> 11 12#include "base/basictypes.h" 13#include "base/compiler_specific.h" 14#include "base/memory/ref_counted.h" 15#include "base/message_loop/message_loop.h" 16#include "base/strings/string_util.h" 17#include "chrome/browser/chromeos/policy/device_policy_builder.h" 18#include "chrome/browser/chromeos/settings/device_settings_service.h" 19#include "chrome/browser/chromeos/settings/device_settings_test_helper.h" 20#include "chrome/browser/chromeos/settings/mock_owner_key_util.h" 21#include "chromeos/dbus/session_manager_client.h" 22#include "content/public/test/test_browser_thread.h" 23#include "testing/gtest/include/gtest/gtest.h" 24 25namespace chromeos { 26 27class FakeDBusThreadManager; 28 29// A helper class for tests mocking out session_manager's device settings 30// interface. The pattern is to initialize DeviceSettingsService with the helper 31// for the SessionManagerClient pointer. The helper records calls made by 32// DeviceSettingsService. The test can then verify state, after which it should 33// call one of the Flush() variants that will resume processing. 34class DeviceSettingsTestHelper : public SessionManagerClient { 35 public: 36 // Wraps a device settings service instance for testing. 37 DeviceSettingsTestHelper(); 38 virtual ~DeviceSettingsTestHelper(); 39 40 // Flushes operations on the current message loop and the blocking pool. 41 void FlushLoops(); 42 43 // Runs all pending store callbacks. 44 void FlushStore(); 45 46 // Runs all pending retrieve callbacks. 47 void FlushRetrieve(); 48 49 // Flushes all pending operations. 50 void Flush(); 51 52 // Checks whether any asynchronous Store/Retrieve operations are pending. 53 bool HasPendingOperations() const; 54 55 bool store_result() { 56 return device_policy_.store_result_; 57 } 58 void set_store_result(bool store_result) { 59 device_policy_.store_result_ = store_result; 60 } 61 62 const std::string& policy_blob() { 63 return device_policy_.policy_blob_; 64 } 65 void set_policy_blob(const std::string& policy_blob) { 66 device_policy_.policy_blob_ = policy_blob; 67 } 68 69 const std::string& device_local_account_policy_blob( 70 const std::string& id) const { 71 const std::map<std::string, PolicyState>::const_iterator entry = 72 device_local_account_policy_.find(id); 73 return entry == device_local_account_policy_.end() ? 74 base::EmptyString() : entry->second.policy_blob_; 75 } 76 77 void set_device_local_account_policy_blob(const std::string& id, 78 const std::string& policy_blob) { 79 device_local_account_policy_[id].policy_blob_ = policy_blob; 80 } 81 82 // SessionManagerClient: 83 virtual void Init(dbus::Bus* bus) OVERRIDE; 84 virtual void SetStubDelegate(SessionManagerClient::StubDelegate* delegate) 85 OVERRIDE; 86 virtual void AddObserver(Observer* observer) OVERRIDE; 87 virtual void RemoveObserver(Observer* observer) OVERRIDE; 88 virtual bool HasObserver(Observer* observer) OVERRIDE; 89 virtual void EmitLoginPromptVisible() OVERRIDE; 90 virtual void RestartJob(int pid, const std::string& command_line) OVERRIDE; 91 virtual void StartSession(const std::string& user_email) OVERRIDE; 92 virtual void StopSession() OVERRIDE; 93 virtual void StartDeviceWipe() OVERRIDE; 94 virtual void RequestLockScreen() OVERRIDE; 95 virtual void NotifyLockScreenShown() OVERRIDE; 96 virtual void NotifyLockScreenDismissed() OVERRIDE; 97 virtual void RetrieveActiveSessions( 98 const ActiveSessionsCallback& callback) OVERRIDE; 99 virtual void RetrieveDevicePolicy( 100 const RetrievePolicyCallback& callback) OVERRIDE; 101 virtual void RetrievePolicyForUser( 102 const std::string& username, 103 const RetrievePolicyCallback& callback) OVERRIDE; 104 virtual std::string BlockingRetrievePolicyForUser( 105 const std::string& username) OVERRIDE; 106 virtual void RetrieveDeviceLocalAccountPolicy( 107 const std::string& account_id, 108 const RetrievePolicyCallback& callback) OVERRIDE; 109 virtual void StoreDevicePolicy(const std::string& policy_blob, 110 const StorePolicyCallback& callback) OVERRIDE; 111 virtual void StorePolicyForUser(const std::string& username, 112 const std::string& policy_blob, 113 const std::string& policy_key, 114 const StorePolicyCallback& callback) OVERRIDE; 115 virtual void StoreDeviceLocalAccountPolicy( 116 const std::string& account_id, 117 const std::string& policy_blob, 118 const StorePolicyCallback& callback) OVERRIDE; 119 virtual void SetFlagsForUser( 120 const std::string& account_id, 121 const std::vector<std::string>& flags) OVERRIDE; 122 123 private: 124 struct PolicyState { 125 bool store_result_; 126 std::string policy_blob_; 127 std::vector<StorePolicyCallback> store_callbacks_; 128 std::vector<RetrievePolicyCallback> retrieve_callbacks_; 129 130 PolicyState(); 131 ~PolicyState(); 132 133 bool HasPendingOperations() const { 134 return !store_callbacks_.empty() || !retrieve_callbacks_.empty(); 135 } 136 }; 137 138 PolicyState device_policy_; 139 std::map<std::string, PolicyState> device_local_account_policy_; 140 141 DISALLOW_COPY_AND_ASSIGN(DeviceSettingsTestHelper); 142}; 143 144// Wraps the singleton device settings and initializes it to the point where it 145// reports OWNERSHIP_NONE for the ownership status. 146class ScopedDeviceSettingsTestHelper : public DeviceSettingsTestHelper { 147 public: 148 ScopedDeviceSettingsTestHelper(); 149 virtual ~ScopedDeviceSettingsTestHelper(); 150 151 private: 152 DISALLOW_COPY_AND_ASSIGN(ScopedDeviceSettingsTestHelper); 153}; 154 155// A convenience test base class that initializes a DeviceSettingsService 156// instance for testing and allows for straightforward updating of device 157// settings. |device_settings_service_| starts out in uninitialized state, so 158// startup code gets tested as well. 159class DeviceSettingsTestBase : public testing::Test { 160 protected: 161 DeviceSettingsTestBase(); 162 virtual ~DeviceSettingsTestBase(); 163 164 virtual void SetUp() OVERRIDE; 165 virtual void TearDown() OVERRIDE; 166 167 // Flushes any pending device settings operations. 168 void FlushDeviceSettings(); 169 170 // Triggers an owner key and device settings reload on 171 // |device_settings_service_| and flushes the resulting load operation. 172 void ReloadDeviceSettings(); 173 174 base::MessageLoopForUI loop_; 175 content::TestBrowserThread ui_thread_; 176 content::TestBrowserThread file_thread_; 177 178 policy::DevicePolicyBuilder device_policy_; 179 180 DeviceSettingsTestHelper device_settings_test_helper_; 181 scoped_refptr<MockOwnerKeyUtil> owner_key_util_; 182 // Local DeviceSettingsService instance for tests. Avoid using in combination 183 // with the global instance (DeviceSettingsService::Get()). 184 DeviceSettingsService device_settings_service_; 185 186 chromeos::FakeDBusThreadManager* fake_dbus_thread_manager_; 187 188 private: 189 DISALLOW_COPY_AND_ASSIGN(DeviceSettingsTestBase); 190}; 191 192} // namespace chromeos 193 194#endif // CHROME_BROWSER_CHROMEOS_SETTINGS_DEVICE_SETTINGS_TEST_HELPER_H_ 195