src/chrome/browser/chromeos/policy/consumer_management_service_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 "chrome/browser/chromeos/policy/consumer_management_service.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/callback.h"
  10 #include "base/prefs/pref_registry_simple.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "chrome/browser/browser_process.h"
  13 #include "chrome/browser/chromeos/policy/device_policy_builder.h"
  14 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
  15 #include "chrome/common/pref_names.h"
  16 #include "chrome/test/base/browser_with_test_window_test.h"
  17 #include "chrome/test/base/scoped_testing_local_state.h"
  18 #include "chrome/test/base/testing_browser_process.h"
  19 #include "chrome/test/base/testing_profile_manager.h"
  20 #include "chromeos/dbus/cryptohome/rpc.pb.h"
  21 #include "chromeos/dbus/cryptohome_client.h"
  22 #include "chromeos/dbus/mock_cryptohome_client.h"
  23 #include "policy/proto/device_management_backend.pb.h"
  24 #include "testing/gmock/include/gmock/gmock.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26
  27 using testing::Invoke;
  28 using testing::NiceMock;
  29 using testing::_;
  30
  31 namespace em = enterprise_management;
  32
  33 namespace {
  34 const char kAttributeOwnerId[] = "consumer_management.owner_id";
  35 const char kTestOwner[] = "test@chromium.org.test";
  36 }
  37
  38 namespace policy {
  39
  40 class ConsumerManagementServiceTest : public BrowserWithTestWindowTest {
  41  public:
  42   ConsumerManagementServiceTest()
  43       : cryptohome_result_(false),
  44         set_owner_status_(false) {
  45     ON_CALL(mock_cryptohome_client_, GetBootAttribute(_, _))
  46         .WillByDefault(
  47             Invoke(this, &ConsumerManagementServiceTest::MockGetBootAttribute));
  48     ON_CALL(mock_cryptohome_client_, SetBootAttribute(_, _))
  49         .WillByDefault(
  50             Invoke(this, &ConsumerManagementServiceTest::MockSetBootAttribute));
  51     ON_CALL(mock_cryptohome_client_, FlushAndSignBootAttributes(_, _))
  52         .WillByDefault(
  53             Invoke(this,
  54                    &ConsumerManagementServiceTest::
  55                        MockFlushAndSignBootAttributes));
  56   }
  57
  58   virtual void SetUp() override {
  59     BrowserWithTestWindowTest::SetUp();
  60
  61     testing_profile_manager_.reset(new TestingProfileManager(
  62         TestingBrowserProcess::GetGlobal()));
  63     ASSERT_TRUE(testing_profile_manager_->SetUp());
  64     service_.reset(new ConsumerManagementService(&mock_cryptohome_client_,
  65                                                  NULL));
  66   }
  67
  68   virtual void TearDown() override {
  69     testing_profile_manager_.reset();
  70     service_.reset();
  71
  72     BrowserWithTestWindowTest::TearDown();
  73   }
  74
  75   ConsumerManagementService::EnrollmentStage GetEnrollmentStage() {
  76     return static_cast<ConsumerManagementService::EnrollmentStage>(
  77         g_browser_process->local_state()->GetInteger(
  78             prefs::kConsumerManagementEnrollmentStage));
  79   }
  80
  81   void SetEnrollmentStage(ConsumerManagementService::EnrollmentStage stage) {
  82     g_browser_process->local_state()->SetInteger(
  83         prefs::kConsumerManagementEnrollmentStage, stage);
  84   }
  85
  86   void MockGetBootAttribute(
  87       const cryptohome::GetBootAttributeRequest& request,
  88       const chromeos::CryptohomeClient::ProtobufMethodCallback& callback) {
  89     get_boot_attribute_request_ = request;
  90     callback.Run(cryptohome_status_, cryptohome_result_, cryptohome_reply_);
  91   }
  92
  93   void MockSetBootAttribute(
  94       const cryptohome::SetBootAttributeRequest& request,
  95       const chromeos::CryptohomeClient::ProtobufMethodCallback& callback) {
  96     set_boot_attribute_request_ = request;
  97     callback.Run(cryptohome_status_, cryptohome_result_, cryptohome_reply_);
  98   }
  99
 100   void MockFlushAndSignBootAttributes(
 101       const cryptohome::FlushAndSignBootAttributesRequest& request,
 102       const chromeos::CryptohomeClient::ProtobufMethodCallback& callback) {
 103     callback.Run(cryptohome_status_, cryptohome_result_, cryptohome_reply_);
 104   }
 105
 106   void OnGetOwnerDone(const std::string& owner) {
 107     owner_ = owner;
 108   }
 109
 110   void OnSetOwnerDone(bool status) {
 111     set_owner_status_ = status;
 112   }
 113
 114   NiceMock<chromeos::MockCryptohomeClient> mock_cryptohome_client_;
 115   scoped_ptr<ConsumerManagementService> service_;
 116   scoped_ptr<TestingProfileManager> testing_profile_manager_;
 117
 118   // Variables for setting the return value or catching the arguments of mock
 119   // functions.
 120   chromeos::DBusMethodCallStatus cryptohome_status_;
 121   bool cryptohome_result_;
 122   cryptohome::BaseReply cryptohome_reply_;
 123   cryptohome::GetBootAttributeRequest get_boot_attribute_request_;
 124   cryptohome::SetBootAttributeRequest set_boot_attribute_request_;
 125   std::string owner_;
 126   bool set_owner_status_;
 127 };
 128
 129 TEST_F(ConsumerManagementServiceTest, CanGetEnrollmentStage) {
 130   EXPECT_EQ(ConsumerManagementService::ENROLLMENT_STAGE_NONE,
 131             service_->GetEnrollmentStage());
 132
 133   SetEnrollmentStage(ConsumerManagementService::ENROLLMENT_STAGE_REQUESTED);
 134
 135   EXPECT_EQ(ConsumerManagementService::ENROLLMENT_STAGE_REQUESTED,
 136             service_->GetEnrollmentStage());
 137 }
 138
 139 TEST_F(ConsumerManagementServiceTest, CanSetEnrollmentStage) {
 140   EXPECT_EQ(ConsumerManagementService::ENROLLMENT_STAGE_NONE,
 141             GetEnrollmentStage());
 142
 143   service_->SetEnrollmentStage(
 144       ConsumerManagementService::ENROLLMENT_STAGE_REQUESTED);
 145
 146   EXPECT_EQ(ConsumerManagementService::ENROLLMENT_STAGE_REQUESTED,
 147             GetEnrollmentStage());
 148 }
 149
 150 TEST_F(ConsumerManagementServiceTest, CanGetOwner) {
 151   cryptohome_status_ = chromeos::DBUS_METHOD_CALL_SUCCESS;
 152   cryptohome_result_ = true;
 153   cryptohome_reply_.MutableExtension(cryptohome::GetBootAttributeReply::reply)->
 154       set_value(kTestOwner);
 155
 156   service_->GetOwner(base::Bind(&ConsumerManagementServiceTest::OnGetOwnerDone,
 157                                 base::Unretained(this)));
 158
 159   EXPECT_EQ(kAttributeOwnerId, get_boot_attribute_request_.name());
 160   EXPECT_EQ(kTestOwner, owner_);
 161 }
 162
 163 TEST_F(ConsumerManagementServiceTest, GetOwnerReturnsAnEmptyStringWhenItFails) {
 164   cryptohome_status_ = chromeos::DBUS_METHOD_CALL_FAILURE;
 165   cryptohome_result_ = false;
 166   cryptohome_reply_.MutableExtension(cryptohome::GetBootAttributeReply::reply)->
 167       set_value(kTestOwner);
 168
 169   service_->GetOwner(base::Bind(&ConsumerManagementServiceTest::OnGetOwnerDone,
 170                                 base::Unretained(this)));
 171
 172   EXPECT_EQ("", owner_);
 173 }
 174
 175 TEST_F(ConsumerManagementServiceTest, CanSetOwner) {
 176   cryptohome_status_ = chromeos::DBUS_METHOD_CALL_SUCCESS;
 177   cryptohome_result_ = true;
 178
 179   service_->SetOwner(kTestOwner,
 180                      base::Bind(&ConsumerManagementServiceTest::OnSetOwnerDone,
 181                                 base::Unretained(this)));
 182
 183   EXPECT_EQ(kAttributeOwnerId, set_boot_attribute_request_.name());
 184   EXPECT_EQ(kTestOwner, set_boot_attribute_request_.value());
 185   EXPECT_TRUE(set_owner_status_);
 186 }
 187
 188 TEST_F(ConsumerManagementServiceTest, SetOwnerReturnsFalseWhenItFails) {
 189   cryptohome_status_ = chromeos::DBUS_METHOD_CALL_FAILURE;
 190   cryptohome_result_ = false;
 191
 192   service_->SetOwner(kTestOwner,
 193                      base::Bind(&ConsumerManagementServiceTest::OnSetOwnerDone,
 194                                 base::Unretained(this)));
 195
 196   EXPECT_FALSE(set_owner_status_);
 197 }
 198
 199 class ConsumerManagementServiceStatusTest
 200     : public chromeos::DeviceSettingsTestBase {
 201  public:
 202   ConsumerManagementServiceStatusTest()
 203       : testing_local_state_(TestingBrowserProcess::GetGlobal()),
 204         service_(NULL, &device_settings_service_) {
 205   }
 206
 207   void SetEnrollmentStage(ConsumerManagementService::EnrollmentStage stage) {
 208     testing_local_state_.Get()->SetInteger(
 209         prefs::kConsumerManagementEnrollmentStage, stage);
 210   }
 211
 212   void SetManagementMode(em::PolicyData::ManagementMode mode) {
 213     device_policy_.policy_data().set_management_mode(mode);
 214     device_policy_.Build();
 215     device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
 216     ReloadDeviceSettings();
 217   }
 218
 219   ScopedTestingLocalState testing_local_state_;
 220   ConsumerManagementService service_;
 221 };
 222
 223 TEST_F(ConsumerManagementServiceStatusTest,
 224        GetStatusGetStatusStringAndHasPendingEnrollmentNotificationWork) {
 225   EXPECT_EQ(ConsumerManagementService::STATUS_UNKNOWN, service_.GetStatus());
 226   EXPECT_EQ("StatusUnknown", service_.GetStatusString());
 227
 228   SetManagementMode(em::PolicyData::NOT_MANAGED);
 229   SetEnrollmentStage(ConsumerManagementService::ENROLLMENT_STAGE_NONE);
 230
 231   EXPECT_EQ(ConsumerManagementService::STATUS_UNENROLLED, service_.GetStatus());
 232   EXPECT_EQ("StatusUnenrolled", service_.GetStatusString());
 233   EXPECT_FALSE(service_.HasPendingEnrollmentNotification());
 234
 235   SetEnrollmentStage(ConsumerManagementService::ENROLLMENT_STAGE_REQUESTED);
 236
 237   EXPECT_EQ(ConsumerManagementService::STATUS_ENROLLING, service_.GetStatus());
 238   EXPECT_EQ("StatusEnrolling", service_.GetStatusString());
 239
 240   SetManagementMode(em::PolicyData::CONSUMER_MANAGED);
 241   SetEnrollmentStage(ConsumerManagementService::ENROLLMENT_STAGE_SUCCESS);
 242
 243   EXPECT_EQ(ConsumerManagementService::STATUS_ENROLLED, service_.GetStatus());
 244   EXPECT_EQ("StatusEnrolled", service_.GetStatusString());
 245   EXPECT_TRUE(service_.HasPendingEnrollmentNotification());
 246
 247   // TODO(davidyu): Test for STATUS_UNENROLLING when it is implemented.
 248   // http://crbug.com/353050.
 249 }
 250
 251 }  // namespace policy