device_settings_test_helper.h revision 5c02ac1a9c1b504631c0a3d2b6e737b5d738bae1 
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,
92                            const StartSessionCallback& callback) OVERRIDE;
93  virtual void StopSession() OVERRIDE;
94  virtual void StartDeviceWipe() OVERRIDE;
95  virtual void RequestLockScreen() OVERRIDE;
96  virtual void NotifyLockScreenShown() OVERRIDE;
97  virtual void NotifyLockScreenDismissed() OVERRIDE;
98  virtual void RetrieveActiveSessions(
99      const ActiveSessionsCallback& callback) OVERRIDE;
100  virtual void RetrieveDevicePolicy(
101      const RetrievePolicyCallback& callback) OVERRIDE;
102  virtual void RetrievePolicyForUser(
103      const std::string& username,
104      const RetrievePolicyCallback& callback) OVERRIDE;
105  virtual std::string BlockingRetrievePolicyForUser(
106      const std::string& username) OVERRIDE;
107  virtual void RetrieveDeviceLocalAccountPolicy(
108      const std::string& account_id,
109      const RetrievePolicyCallback& callback) OVERRIDE;
110  virtual void StoreDevicePolicy(const std::string& policy_blob,
111                                 const StorePolicyCallback& callback) OVERRIDE;
112  virtual void StorePolicyForUser(const std::string& username,
113                                  const std::string& policy_blob,
114                                  const std::string& policy_key,
115                                  const StorePolicyCallback& callback) OVERRIDE;
116  virtual void StoreDeviceLocalAccountPolicy(
117      const std::string& account_id,
118      const std::string& policy_blob,
119      const StorePolicyCallback& callback) OVERRIDE;
120  virtual void SetFlagsForUser(
121      const std::string& account_id,
122      const std::vector<std::string>& flags) OVERRIDE;
123
124 private:
125  struct PolicyState {
126    bool store_result_;
127    std::string policy_blob_;
128    std::vector<StorePolicyCallback> store_callbacks_;
129    std::vector<RetrievePolicyCallback> retrieve_callbacks_;
130
131    PolicyState();
132    ~PolicyState();
133
134    bool HasPendingOperations() const {
135      return !store_callbacks_.empty() || !retrieve_callbacks_.empty();
136    }
137  };
138
139  PolicyState device_policy_;
140  std::map<std::string, PolicyState> device_local_account_policy_;
141
142  DISALLOW_COPY_AND_ASSIGN(DeviceSettingsTestHelper);
143};
144
145// Wraps the singleton device settings and initializes it to the point where it
146// reports OWNERSHIP_NONE for the ownership status.
147class ScopedDeviceSettingsTestHelper : public DeviceSettingsTestHelper {
148 public:
149  ScopedDeviceSettingsTestHelper();
150  virtual ~ScopedDeviceSettingsTestHelper();
151
152 private:
153  DISALLOW_COPY_AND_ASSIGN(ScopedDeviceSettingsTestHelper);
154};
155
156// A convenience test base class that initializes a DeviceSettingsService
157// instance for testing and allows for straightforward updating of device
158// settings. |device_settings_service_| starts out in uninitialized state, so
159// startup code gets tested as well.
160class DeviceSettingsTestBase : public testing::Test {
161 protected:
162  DeviceSettingsTestBase();
163  virtual ~DeviceSettingsTestBase();
164
165  virtual void SetUp() OVERRIDE;
166  virtual void TearDown() OVERRIDE;
167
168  // Flushes any pending device settings operations.
169  void FlushDeviceSettings();
170
171  // Triggers an owner key and device settings reload on
172  // |device_settings_service_| and flushes the resulting load operation.
173  void ReloadDeviceSettings();
174
175  base::MessageLoopForUI loop_;
176  content::TestBrowserThread ui_thread_;
177  content::TestBrowserThread file_thread_;
178
179  policy::DevicePolicyBuilder device_policy_;
180
181  DeviceSettingsTestHelper device_settings_test_helper_;
182  scoped_refptr<MockOwnerKeyUtil> owner_key_util_;
183  // Local DeviceSettingsService instance for tests. Avoid using in combination
184  // with the global instance (DeviceSettingsService::Get()).
185  DeviceSettingsService device_settings_service_;
186
187  chromeos::FakeDBusThreadManager* fake_dbus_thread_manager_;
188
189 private:
190  DISALLOW_COPY_AND_ASSIGN(DeviceSettingsTestBase);
191};
192
193}  // namespace chromeos
194
195#endif  // CHROME_BROWSER_CHROMEOS_SETTINGS_DEVICE_SETTINGS_TEST_HELPER_H_
196