chrome/browser/chromeos/settings/device_settings_test_helper.h

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