chrome/browser/chromeos/ownership/owner_settings_service_chromeos_unittest.cc

   1 // Copyright 2014 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 #include <queue>
   6 #include <utility>
   7
   8 #include "base/macros.h"
   9 #include "base/memory/linked_ptr.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/run_loop.h"
  12 #include "base/test/scoped_path_override.h"
  13 #include "base/values.h"
  14 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
  15 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
  16 #include "chrome/browser/chromeos/settings/device_settings_provider.h"
  17 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
  18 #include "chrome/common/chrome_paths.h"
  19 #include "chrome/test/base/scoped_testing_local_state.h"
  20 #include "chrome/test/base/testing_browser_process.h"
  21 #include "chrome/test/base/testing_profile.h"
  22 #include "chromeos/settings/cros_settings_names.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 namespace chromeos {
  26
  27 namespace {
  28
  29 void OnPrefChanged(const std::string& /* setting */) {
  30 }
  31
  32 class PrefsChecker : public ownership::OwnerSettingsService::Observer {
  33  public:
  34   PrefsChecker(OwnerSettingsServiceChromeOS* service,
  35                DeviceSettingsProvider* provider)
  36       : service_(service), provider_(provider) {
  37     CHECK(service_);
  38     CHECK(provider_);
  39     service_->AddObserver(this);
  40   }
  41
  42   virtual ~PrefsChecker() { service_->RemoveObserver(this); }
  43
  44   // OwnerSettingsService::Observer implementation:
  45   virtual void OnSignedPolicyStored(bool success) override {
  46     if (service_->has_pending_changes())
  47       return;
  48
  49     while (!set_requests_.empty()) {
  50       SetRequest request = set_requests_.front();
  51       set_requests_.pop();
  52       const base::Value* value = provider_->Get(request.first);
  53       ASSERT_TRUE(request.second->Equals(value));
  54     }
  55     loop_.Quit();
  56   }
  57
  58   bool Set(const std::string& setting, const base::Value& value) {
  59     if (!service_->Set(setting, value))
  60       return false;
  61     set_requests_.push(
  62         SetRequest(setting, linked_ptr<base::Value>(value.DeepCopy())));
  63     return true;
  64   }
  65
  66   void Wait() { loop_.Run(); }
  67
  68  private:
  69   OwnerSettingsServiceChromeOS* service_;
  70   DeviceSettingsProvider* provider_;
  71   base::RunLoop loop_;
  72
  73   typedef std::pair<std::string, linked_ptr<base::Value>> SetRequest;
  74   std::queue<SetRequest> set_requests_;
  75
  76   DISALLOW_COPY_AND_ASSIGN(PrefsChecker);
  77 };
  78
  79 }  // namespace
  80
  81 class OwnerSettingsServiceChromeOSTest : public DeviceSettingsTestBase {
  82  public:
  83   OwnerSettingsServiceChromeOSTest()
  84       : service_(nullptr),
  85         local_state_(TestingBrowserProcess::GetGlobal()),
  86         user_data_dir_override_(chrome::DIR_USER_DATA) {}
  87
  88   virtual void SetUp() override {
  89     DeviceSettingsTestBase::SetUp();
  90     provider_.reset(new DeviceSettingsProvider(base::Bind(&OnPrefChanged),
  91                                                &device_settings_service_));
  92     owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
  93     InitOwner(device_policy_.policy_data().username(), true);
  94     FlushDeviceSettings();
  95
  96     service_ = OwnerSettingsServiceChromeOSFactory::GetForBrowserContext(
  97         profile_.get());
  98     ASSERT_TRUE(service_);
  99     ASSERT_TRUE(service_->IsOwner());
 100   }
 101
 102   virtual void TearDown() override { DeviceSettingsTestBase::TearDown(); }
 103
 104   void TestSingleSet(OwnerSettingsServiceChromeOS* service,
 105                      const std::string& setting,
 106                      const base::Value& in_value) {
 107     PrefsChecker checker(service, provider_.get());
 108     checker.Set(setting, in_value);
 109     FlushDeviceSettings();
 110     checker.Wait();
 111   }
 112
 113   OwnerSettingsServiceChromeOS* service_;
 114   ScopedTestingLocalState local_state_;
 115   scoped_ptr<DeviceSettingsProvider> provider_;
 116   base::ScopedPathOverride user_data_dir_override_;
 117
 118  private:
 119   DISALLOW_COPY_AND_ASSIGN(OwnerSettingsServiceChromeOSTest);
 120 };
 121
 122 TEST_F(OwnerSettingsServiceChromeOSTest, SingleSetTest) {
 123   TestSingleSet(service_, kReleaseChannel, base::StringValue("dev-channel"));
 124   TestSingleSet(service_, kReleaseChannel, base::StringValue("beta-channel"));
 125   TestSingleSet(service_, kReleaseChannel, base::StringValue("stable-channel"));
 126 }
 127
 128 TEST_F(OwnerSettingsServiceChromeOSTest, MultipleSetTest) {
 129   base::FundamentalValue allow_guest(false);
 130   base::StringValue release_channel("stable-channel");
 131   base::FundamentalValue show_user_names(true);
 132
 133   PrefsChecker checker(service_, provider_.get());
 134
 135   checker.Set(kAccountsPrefAllowGuest, allow_guest);
 136   checker.Set(kReleaseChannel, release_channel);
 137   checker.Set(kAccountsPrefShowUserNamesOnSignIn, show_user_names);
 138
 139   FlushDeviceSettings();
 140   checker.Wait();
 141 }
 142
 143 TEST_F(OwnerSettingsServiceChromeOSTest, FailedSetRequest) {
 144   device_settings_test_helper_.set_store_result(false);
 145   std::string current_channel;
 146   ASSERT_TRUE(provider_->Get(kReleaseChannel)->GetAsString(&current_channel));
 147   ASSERT_NE(current_channel, "stable-channel");
 148
 149   // Check that DeviceSettingsProvider's cache is updated.
 150   PrefsChecker checker(service_, provider_.get());
 151   checker.Set(kReleaseChannel, base::StringValue("stable-channel"));
 152   FlushDeviceSettings();
 153   checker.Wait();
 154
 155   // Check that DeviceSettingsService's policy isn't updated.
 156   ASSERT_EQ(current_channel, device_settings_service_.device_settings()
 157                                  ->release_channel()
 158                                  .release_channel());
 159 }
 160
 161 class OwnerSettingsServiceChromeOSNoOwnerTest
 162     : public OwnerSettingsServiceChromeOSTest {
 163  public:
 164   OwnerSettingsServiceChromeOSNoOwnerTest() {}
 165   virtual ~OwnerSettingsServiceChromeOSNoOwnerTest() {}
 166
 167   virtual void SetUp() override {
 168     DeviceSettingsTestBase::SetUp();
 169     provider_.reset(new DeviceSettingsProvider(base::Bind(&OnPrefChanged),
 170                                                &device_settings_service_));
 171     FlushDeviceSettings();
 172     service_ = OwnerSettingsServiceChromeOSFactory::GetForBrowserContext(
 173         profile_.get());
 174     ASSERT_TRUE(service_);
 175     ASSERT_FALSE(service_->IsOwner());
 176   }
 177
 178   virtual void TearDown() override { DeviceSettingsTestBase::TearDown(); }
 179
 180  private:
 181   DISALLOW_COPY_AND_ASSIGN(OwnerSettingsServiceChromeOSNoOwnerTest);
 182 };
 183
 184 TEST_F(OwnerSettingsServiceChromeOSNoOwnerTest, SingleSetTest) {
 185   ASSERT_FALSE(service_->SetBoolean(kAccountsPrefAllowGuest, false));
 186 }
 187
 188 }  // namespace chromeos