src/chrome/browser/chromeos/policy/auto_enrollment_client_unittest.cc

   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 #include "chrome/browser/chromeos/policy/auto_enrollment_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/prefs/testing_pref_service.h"
  12 #include "base/run_loop.h"
  13 #include "base/strings/stringprintf.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/browser_process.h"
  16 #include "chrome/browser/chromeos/policy/server_backed_device_state.h"
  17 #include "chrome/common/pref_names.h"
  18 #include "chrome/test/base/scoped_testing_local_state.h"
  19 #include "chrome/test/base/testing_browser_process.h"
  20 #include "components/policy/core/common/cloud/mock_device_management_service.h"
  21 #include "content/public/test/test_browser_thread_bundle.h"
  22 #include "crypto/sha2.h"
  23 #include "net/url_request/url_request_context_getter.h"
  24 #include "net/url_request/url_request_test_util.h"
  25 #include "testing/gmock/include/gmock/gmock.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27
  28 namespace em = enterprise_management;
  29
  30 namespace policy {
  31
  32 namespace {
  33
  34 const char kStateKey[] = "state_key";
  35 const char kStateKeyHash[] =
  36     "\xde\x74\xcd\xf0\x03\x36\x8c\x21\x79\xba\xb1\x5a\xc4\x32\xee\xd6"
  37     "\xb3\x4a\x5e\xff\x73\x7e\x92\xd9\xf8\x6e\x72\x44\xd0\x97\xc3\xe6";
  38 const char kDisabledMessage[] = "This device has been disabled.";
  39
  40 using ::testing::InSequence;
  41 using ::testing::Mock;
  42 using ::testing::SaveArg;
  43 using ::testing::_;
  44
  45 class AutoEnrollmentClientTest : public testing::Test {
  46  protected:
  47   AutoEnrollmentClientTest()
  48       : scoped_testing_local_state_(
  49             TestingBrowserProcess::GetGlobal()),
  50         local_state_(scoped_testing_local_state_.Get()),
  51         state_(AUTO_ENROLLMENT_STATE_PENDING) {}
  52
  53   virtual void SetUp() override {
  54     CreateClient(kStateKey, true, 4, 8);
  55     ASSERT_FALSE(local_state_->GetUserPref(prefs::kShouldAutoEnroll));
  56     ASSERT_FALSE(local_state_->GetUserPref(prefs::kAutoEnrollmentPowerLimit));
  57   }
  58
  59   virtual void TearDown() override {
  60     // Flush any deletion tasks.
  61     base::RunLoop().RunUntilIdle();
  62   }
  63
  64   void CreateClient(const std::string& state_key,
  65                     bool retrieve_device_state,
  66                     int power_initial,
  67                     int power_limit) {
  68     state_ = AUTO_ENROLLMENT_STATE_PENDING;
  69     service_.reset(new MockDeviceManagementService());
  70     EXPECT_CALL(*service_, StartJob(_, _, _, _, _, _, _))
  71         .WillRepeatedly(SaveArg<6>(&last_request_));
  72     client_.reset(new AutoEnrollmentClient(
  73         base::Bind(&AutoEnrollmentClientTest::ProgressCallback,
  74                    base::Unretained(this)),
  75         service_.get(),
  76         local_state_,
  77         new net::TestURLRequestContextGetter(
  78             base::MessageLoop::current()->message_loop_proxy()),
  79         state_key,
  80         retrieve_device_state,
  81         power_initial,
  82         power_limit));
  83   }
  84
  85   void ProgressCallback(AutoEnrollmentState state) {
  86     state_ = state;
  87   }
  88
  89   void ServerWillFail(DeviceManagementStatus error) {
  90     em::DeviceManagementResponse dummy_response;
  91     EXPECT_CALL(*service_,
  92                 CreateJob(DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT, _))
  93         .WillOnce(service_->FailJob(error));
  94   }
  95
  96   void ServerWillReply(int64 modulus, bool with_hashes, bool with_id_hash) {
  97     em::DeviceManagementResponse response;
  98     em::DeviceAutoEnrollmentResponse* enrollment_response =
  99         response.mutable_auto_enrollment_response();
 100     if (modulus >= 0)
 101       enrollment_response->set_expected_modulus(modulus);
 102     if (with_hashes) {
 103       for (int i = 0; i < 10; ++i) {
 104         std::string state_key = base::StringPrintf("state_key %d", i);
 105         std::string hash = crypto::SHA256HashString(state_key);
 106         enrollment_response->mutable_hash()->Add()->assign(hash);
 107       }
 108     }
 109     if (with_id_hash) {
 110       enrollment_response->mutable_hash()->Add()->assign(kStateKeyHash,
 111                                                          crypto::kSHA256Length);
 112     }
 113     EXPECT_CALL(*service_,
 114                 CreateJob(DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT, _))
 115         .WillOnce(service_->SucceedJob(response));
 116   }
 117
 118   void ServerWillSendState(
 119       const std::string& management_domain,
 120       em::DeviceStateRetrievalResponse::RestoreMode restore_mode,
 121       const std::string& device_disabled_message) {
 122     em::DeviceManagementResponse response;
 123     em::DeviceStateRetrievalResponse* state_response =
 124         response.mutable_device_state_retrieval_response();
 125     state_response->set_restore_mode(restore_mode);
 126     state_response->set_management_domain(management_domain);
 127     state_response->mutable_disabled_state()->set_message(
 128         device_disabled_message);
 129     EXPECT_CALL(
 130         *service_,
 131         CreateJob(DeviceManagementRequestJob::TYPE_DEVICE_STATE_RETRIEVAL, _))
 132         .WillOnce(service_->SucceedJob(response));
 133   }
 134
 135   void ServerWillReplyAsync(MockDeviceManagementJob** job) {
 136     EXPECT_CALL(*service_,
 137                 CreateJob(DeviceManagementRequestJob::TYPE_AUTO_ENROLLMENT, _))
 138         .WillOnce(service_->CreateAsyncJob(job));
 139   }
 140
 141   bool HasCachedDecision() {
 142     return local_state_->GetUserPref(prefs::kShouldAutoEnroll);
 143   }
 144
 145   void VerifyCachedResult(bool should_enroll, int power_limit) {
 146     base::FundamentalValue value_should_enroll(should_enroll);
 147     base::FundamentalValue value_power_limit(power_limit);
 148     EXPECT_TRUE(base::Value::Equals(
 149         &value_should_enroll,
 150         local_state_->GetUserPref(prefs::kShouldAutoEnroll)));
 151     EXPECT_TRUE(base::Value::Equals(
 152         &value_power_limit,
 153         local_state_->GetUserPref(prefs::kAutoEnrollmentPowerLimit)));
 154   }
 155
 156   bool HasServerBackedState() {
 157     return local_state_->GetUserPref(prefs::kServerBackedDeviceState);
 158   }
 159
 160   void VerifyServerBackedState(
 161       const std::string& expected_management_domain,
 162       const std::string& expected_restore_mode,
 163       const std::string& expected_disabled_message) {
 164     const base::Value* state =
 165         local_state_->GetUserPref(prefs::kServerBackedDeviceState);
 166     ASSERT_TRUE(state);
 167     const base::DictionaryValue* state_dict = nullptr;
 168     ASSERT_TRUE(state->GetAsDictionary(&state_dict));
 169
 170     std::string actual_management_domain;
 171     EXPECT_TRUE(state_dict->GetString(kDeviceStateManagementDomain,
 172                                       &actual_management_domain));
 173     EXPECT_EQ(expected_management_domain, actual_management_domain);
 174
 175     if (!expected_restore_mode.empty()) {
 176       std::string actual_restore_mode;
 177       EXPECT_TRUE(state_dict->GetString(kDeviceStateRestoreMode,
 178                                         &actual_restore_mode));
 179       EXPECT_EQ(expected_restore_mode, actual_restore_mode);
 180     } else {
 181       EXPECT_FALSE(state_dict->HasKey(kDeviceStateRestoreMode));
 182     }
 183
 184     std::string actual_disabled_message;
 185     EXPECT_TRUE(state_dict->GetString(kDeviceStateDisabledMessage,
 186                                       &actual_disabled_message));
 187     EXPECT_EQ(expected_disabled_message, actual_disabled_message);
 188   }
 189
 190   const em::DeviceAutoEnrollmentRequest& auto_enrollment_request() {
 191     return last_request_.auto_enrollment_request();
 192   }
 193
 194   content::TestBrowserThreadBundle browser_threads_;
 195   ScopedTestingLocalState scoped_testing_local_state_;
 196   TestingPrefServiceSimple* local_state_;
 197   scoped_ptr<MockDeviceManagementService> service_;
 198   scoped_ptr<AutoEnrollmentClient> client_;
 199   em::DeviceManagementRequest last_request_;
 200   AutoEnrollmentState state_;
 201
 202  private:
 203   DISALLOW_COPY_AND_ASSIGN(AutoEnrollmentClientTest);
 204 };
 205
 206 TEST_F(AutoEnrollmentClientTest, NetworkFailure) {
 207   ServerWillFail(DM_STATUS_TEMPORARY_UNAVAILABLE);
 208   client_->Start();
 209   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
 210   EXPECT_FALSE(HasCachedDecision());
 211   EXPECT_FALSE(HasServerBackedState());
 212 }
 213
 214 TEST_F(AutoEnrollmentClientTest, EmptyReply) {
 215   ServerWillReply(-1, false, false);
 216   client_->Start();
 217   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 218   VerifyCachedResult(false, 8);
 219   EXPECT_FALSE(HasServerBackedState());
 220 }
 221
 222 TEST_F(AutoEnrollmentClientTest, ClientUploadsRightBits) {
 223   ServerWillReply(-1, false, false);
 224   client_->Start();
 225   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 226
 227   EXPECT_TRUE(auto_enrollment_request().has_remainder());
 228   EXPECT_TRUE(auto_enrollment_request().has_modulus());
 229   EXPECT_EQ(16, auto_enrollment_request().modulus());
 230   EXPECT_EQ(kStateKeyHash[31] & 0xf, auto_enrollment_request().remainder());
 231   VerifyCachedResult(false, 8);
 232   EXPECT_FALSE(HasServerBackedState());
 233 }
 234
 235 TEST_F(AutoEnrollmentClientTest, AskForMoreThenFail) {
 236   InSequence sequence;
 237   ServerWillReply(32, false, false);
 238   ServerWillFail(DM_STATUS_TEMPORARY_UNAVAILABLE);
 239   client_->Start();
 240   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
 241   EXPECT_FALSE(HasCachedDecision());
 242   EXPECT_FALSE(HasServerBackedState());
 243 }
 244
 245 TEST_F(AutoEnrollmentClientTest, AskForMoreThenEvenMore) {
 246   InSequence sequence;
 247   ServerWillReply(32, false, false);
 248   ServerWillReply(64, false, false);
 249   client_->Start();
 250   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
 251   EXPECT_FALSE(HasCachedDecision());
 252   EXPECT_FALSE(HasServerBackedState());
 253 }
 254
 255 TEST_F(AutoEnrollmentClientTest, AskForLess) {
 256   InSequence sequence;
 257   ServerWillReply(8, false, false);
 258   ServerWillReply(-1, true, true);
 259   ServerWillSendState(
 260       "example.com",
 261       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
 262       kDisabledMessage);
 263   client_->Start();
 264   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 265   VerifyCachedResult(true, 8);
 266   VerifyServerBackedState("example.com",
 267                           kDeviceStateRestoreModeReEnrollmentEnforced,
 268                           kDisabledMessage);
 269 }
 270
 271 TEST_F(AutoEnrollmentClientTest, AskForSame) {
 272   InSequence sequence;
 273   ServerWillReply(16, false, false);
 274   ServerWillReply(-1, true, true);
 275   ServerWillSendState(
 276       "example.com",
 277       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
 278       kDisabledMessage);
 279   client_->Start();
 280   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 281   VerifyCachedResult(true, 8);
 282   VerifyServerBackedState("example.com",
 283                           kDeviceStateRestoreModeReEnrollmentEnforced,
 284                           kDisabledMessage);
 285 }
 286
 287 TEST_F(AutoEnrollmentClientTest, AskForSameTwice) {
 288   InSequence sequence;
 289   ServerWillReply(16, false, false);
 290   ServerWillReply(16, false, false);
 291   client_->Start();
 292   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
 293   EXPECT_FALSE(HasCachedDecision());
 294   EXPECT_FALSE(HasServerBackedState());
 295 }
 296
 297 TEST_F(AutoEnrollmentClientTest, AskForTooMuch) {
 298   ServerWillReply(512, false, false);
 299   client_->Start();
 300   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
 301   EXPECT_FALSE(HasCachedDecision());
 302   EXPECT_FALSE(HasServerBackedState());
 303 }
 304
 305 TEST_F(AutoEnrollmentClientTest, AskNonPowerOf2) {
 306   InSequence sequence;
 307   ServerWillReply(100, false, false);
 308   ServerWillReply(-1, false, false);
 309   client_->Start();
 310   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 311   EXPECT_TRUE(auto_enrollment_request().has_remainder());
 312   EXPECT_TRUE(auto_enrollment_request().has_modulus());
 313   EXPECT_EQ(128, auto_enrollment_request().modulus());
 314   EXPECT_EQ(kStateKeyHash[31] & 0x7f, auto_enrollment_request().remainder());
 315   VerifyCachedResult(false, 8);
 316   EXPECT_FALSE(HasServerBackedState());
 317 }
 318
 319 TEST_F(AutoEnrollmentClientTest, ConsumerDevice) {
 320   ServerWillReply(-1, true, false);
 321   client_->Start();
 322   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 323   VerifyCachedResult(false, 8);
 324   EXPECT_FALSE(HasServerBackedState());
 325
 326   // Network changes don't trigger retries after obtaining a response from
 327   // the server.
 328   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 329   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 330 }
 331
 332 TEST_F(AutoEnrollmentClientTest, ForcedReEnrollment) {
 333   ServerWillReply(-1, true, true);
 334   ServerWillSendState(
 335       "example.com",
 336       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
 337       kDisabledMessage);
 338   client_->Start();
 339   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 340   VerifyCachedResult(true, 8);
 341   VerifyServerBackedState("example.com",
 342                           kDeviceStateRestoreModeReEnrollmentEnforced,
 343                           kDisabledMessage);
 344
 345   // Network changes don't trigger retries after obtaining a response from
 346   // the server.
 347   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 348   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 349 }
 350
 351 TEST_F(AutoEnrollmentClientTest, RequestedReEnrollment) {
 352   ServerWillReply(-1, true, true);
 353   ServerWillSendState(
 354       "example.com",
 355       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_REQUESTED,
 356       kDisabledMessage);
 357   client_->Start();
 358   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 359   VerifyCachedResult(true, 8);
 360   VerifyServerBackedState("example.com",
 361                           kDeviceStateRestoreModeReEnrollmentRequested,
 362                           kDisabledMessage);
 363 }
 364
 365 TEST_F(AutoEnrollmentClientTest, DeviceDisabled) {
 366   ServerWillReply(-1, true, true);
 367   ServerWillSendState(
 368       "example.com",
 369       em::DeviceStateRetrievalResponse::RESTORE_MODE_DISABLED,
 370       kDisabledMessage);
 371   client_->Start();
 372   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 373   VerifyCachedResult(true, 8);
 374   VerifyServerBackedState("example.com",
 375                           kDeviceStateRestoreModeDisabled,
 376                           kDisabledMessage);
 377 }
 378
 379 TEST_F(AutoEnrollmentClientTest, NoSerial) {
 380   CreateClient("", true, 4, 8);
 381   client_->Start();
 382   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 383   EXPECT_FALSE(HasCachedDecision());
 384   EXPECT_FALSE(HasServerBackedState());
 385 }
 386
 387 TEST_F(AutoEnrollmentClientTest, NoBitsUploaded) {
 388   CreateClient(kStateKey, true, 0, 0);
 389   ServerWillReply(-1, false, false);
 390   client_->Start();
 391   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 392   EXPECT_TRUE(auto_enrollment_request().has_remainder());
 393   EXPECT_TRUE(auto_enrollment_request().has_modulus());
 394   EXPECT_EQ(1, auto_enrollment_request().modulus());
 395   EXPECT_EQ(0, auto_enrollment_request().remainder());
 396   VerifyCachedResult(false, 0);
 397   EXPECT_FALSE(HasServerBackedState());
 398 }
 399
 400 TEST_F(AutoEnrollmentClientTest, ManyBitsUploaded) {
 401   int64 bottom62 = GG_INT64_C(0x386e7244d097c3e6);
 402   for (int i = 0; i <= 62; ++i) {
 403     CreateClient(kStateKey, true, i, i);
 404     ServerWillReply(-1, false, false);
 405     client_->Start();
 406     EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 407     EXPECT_TRUE(auto_enrollment_request().has_remainder());
 408     EXPECT_TRUE(auto_enrollment_request().has_modulus());
 409     EXPECT_EQ(GG_INT64_C(1) << i, auto_enrollment_request().modulus());
 410     EXPECT_EQ(bottom62 % (GG_INT64_C(1) << i),
 411               auto_enrollment_request().remainder());
 412     VerifyCachedResult(false, i);
 413     EXPECT_FALSE(HasServerBackedState());
 414   }
 415 }
 416
 417 TEST_F(AutoEnrollmentClientTest, MoreThan32BitsUploaded) {
 418   CreateClient(kStateKey, true, 10, 37);
 419   InSequence sequence;
 420   ServerWillReply(GG_INT64_C(1) << 37, false, false);
 421   ServerWillReply(-1, true, true);
 422   ServerWillSendState(
 423       "example.com",
 424       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
 425       kDisabledMessage);
 426   client_->Start();
 427   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 428   VerifyCachedResult(true, 37);
 429   VerifyServerBackedState("example.com",
 430                           kDeviceStateRestoreModeReEnrollmentEnforced,
 431                           kDisabledMessage);
 432 }
 433
 434 TEST_F(AutoEnrollmentClientTest, ReuseCachedDecision) {
 435   EXPECT_CALL(*service_, CreateJob(_, _)).Times(0);
 436   local_state_->SetUserPref(prefs::kShouldAutoEnroll,
 437                             new base::FundamentalValue(true));
 438   local_state_->SetUserPref(prefs::kAutoEnrollmentPowerLimit,
 439                             new base::FundamentalValue(8));
 440   ServerWillSendState(
 441       "example.com",
 442       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
 443       kDisabledMessage);
 444   client_->Start();
 445   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 446   VerifyServerBackedState("example.com",
 447                           kDeviceStateRestoreModeReEnrollmentEnforced,
 448                           kDisabledMessage);
 449   AutoEnrollmentClient::CancelAutoEnrollment();
 450   client_->Start();
 451   EXPECT_EQ(AUTO_ENROLLMENT_STATE_NO_ENROLLMENT, state_);
 452   EXPECT_FALSE(HasServerBackedState());
 453 }
 454
 455 TEST_F(AutoEnrollmentClientTest, RetryIfPowerLargerThanCached) {
 456   local_state_->SetUserPref(prefs::kShouldAutoEnroll,
 457                             new base::FundamentalValue(false));
 458   local_state_->SetUserPref(prefs::kAutoEnrollmentPowerLimit,
 459                             new base::FundamentalValue(8));
 460   CreateClient(kStateKey, true, 5, 10);
 461   ServerWillReply(-1, true, true);
 462   ServerWillSendState(
 463       "example.com",
 464       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
 465       kDisabledMessage);
 466   client_->Start();
 467   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 468   VerifyServerBackedState("example.com",
 469                           kDeviceStateRestoreModeReEnrollmentEnforced,
 470                           kDisabledMessage);
 471 }
 472
 473 TEST_F(AutoEnrollmentClientTest, NetworkChangeRetryAfterErrors) {
 474   ServerWillFail(DM_STATUS_TEMPORARY_UNAVAILABLE);
 475   client_->Start();
 476   // Don't invoke the callback if there was a network failure.
 477   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
 478   EXPECT_FALSE(HasCachedDecision());
 479   EXPECT_FALSE(HasServerBackedState());
 480
 481   // The client doesn't retry if no new connection became available.
 482   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_NONE);
 483   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
 484   EXPECT_FALSE(HasCachedDecision());
 485   EXPECT_FALSE(HasServerBackedState());
 486
 487   // Retry once the network is back.
 488   ServerWillReply(-1, true, true);
 489   ServerWillSendState(
 490       "example.com",
 491       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
 492       kDisabledMessage);
 493   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 494   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 495   EXPECT_TRUE(HasCachedDecision());
 496   VerifyServerBackedState("example.com",
 497                           kDeviceStateRestoreModeReEnrollmentEnforced,
 498                           kDisabledMessage);
 499
 500   // Subsequent network changes don't trigger retries.
 501   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_NONE);
 502   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 503   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 504   EXPECT_TRUE(HasCachedDecision());
 505   VerifyServerBackedState("example.com",
 506                           kDeviceStateRestoreModeReEnrollmentEnforced,
 507                           kDisabledMessage);
 508 }
 509
 510 TEST_F(AutoEnrollmentClientTest, CancelAndDeleteSoonWithPendingRequest) {
 511   MockDeviceManagementJob* job = NULL;
 512   ServerWillReplyAsync(&job);
 513   EXPECT_FALSE(job);
 514   client_->Start();
 515   ASSERT_TRUE(job);
 516   EXPECT_EQ(AUTO_ENROLLMENT_STATE_PENDING, state_);
 517
 518   // Cancel while a request is in flight.
 519   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 520   client_.release()->CancelAndDeleteSoon();
 521   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 522
 523   // The client cleans itself up once a reply is received.
 524   job->SendResponse(DM_STATUS_TEMPORARY_UNAVAILABLE,
 525                     em::DeviceManagementResponse());
 526   // The DeleteSoon task has been posted:
 527   EXPECT_FALSE(base::MessageLoop::current()->IsIdleForTesting());
 528   EXPECT_EQ(AUTO_ENROLLMENT_STATE_PENDING, state_);
 529 }
 530
 531 TEST_F(AutoEnrollmentClientTest, NetworkChangedAfterCancelAndDeleteSoon) {
 532   MockDeviceManagementJob* job = NULL;
 533   ServerWillReplyAsync(&job);
 534   EXPECT_FALSE(job);
 535   client_->Start();
 536   ASSERT_TRUE(job);
 537   EXPECT_EQ(AUTO_ENROLLMENT_STATE_PENDING, state_);
 538
 539   // Cancel while a request is in flight.
 540   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 541   AutoEnrollmentClient* client = client_.release();
 542   client->CancelAndDeleteSoon();
 543   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 544
 545   // Network change events are ignored while a request is pending.
 546   client->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 547   EXPECT_EQ(AUTO_ENROLLMENT_STATE_PENDING, state_);
 548
 549   // The client cleans itself up once a reply is received.
 550   job->SendResponse(DM_STATUS_TEMPORARY_UNAVAILABLE,
 551                     em::DeviceManagementResponse());
 552   // The DeleteSoon task has been posted:
 553   EXPECT_FALSE(base::MessageLoop::current()->IsIdleForTesting());
 554   EXPECT_EQ(AUTO_ENROLLMENT_STATE_PENDING, state_);
 555
 556   // Network changes that have been posted before are also ignored:
 557   client->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 558   EXPECT_EQ(AUTO_ENROLLMENT_STATE_PENDING, state_);
 559 }
 560
 561 TEST_F(AutoEnrollmentClientTest, CancelAndDeleteSoonAfterCompletion) {
 562   ServerWillReply(-1, true, true);
 563   ServerWillSendState(
 564       "example.com",
 565       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
 566       kDisabledMessage);
 567   client_->Start();
 568   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 569   VerifyServerBackedState("example.com",
 570                           kDeviceStateRestoreModeReEnrollmentEnforced,
 571                           kDisabledMessage);
 572
 573   // The client will delete itself immediately if there are no pending
 574   // requests.
 575   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 576   client_.release()->CancelAndDeleteSoon();
 577   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 578 }
 579
 580 TEST_F(AutoEnrollmentClientTest, CancelAndDeleteSoonAfterNetworkFailure) {
 581   ServerWillFail(DM_STATUS_TEMPORARY_UNAVAILABLE);
 582   client_->Start();
 583   EXPECT_EQ(AUTO_ENROLLMENT_STATE_SERVER_ERROR, state_);
 584
 585   // The client will delete itself immediately if there are no pending
 586   // requests.
 587   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 588   client_.release()->CancelAndDeleteSoon();
 589   EXPECT_TRUE(base::MessageLoop::current()->IsIdleForTesting());
 590 }
 591
 592 TEST_F(AutoEnrollmentClientTest, NetworkFailureThenRequireUpdatedModulus) {
 593   // This test verifies that if the first request fails due to a network
 594   // problem then the second request will correctly handle an updated
 595   // modulus request from the server.
 596
 597   ServerWillFail(DM_STATUS_REQUEST_FAILED);
 598   client_->Start();
 599   // Callback should signal the connection error.
 600   EXPECT_EQ(AUTO_ENROLLMENT_STATE_CONNECTION_ERROR, state_);
 601   EXPECT_FALSE(HasCachedDecision());
 602   EXPECT_FALSE(HasServerBackedState());
 603   Mock::VerifyAndClearExpectations(service_.get());
 604
 605   InSequence sequence;
 606   // The default client uploads 4 bits. Make the server ask for 5.
 607   ServerWillReply(1 << 5, false, false);
 608   EXPECT_CALL(*service_, StartJob(_, _, _, _, _, _, _));
 609   // Then reply with a valid response and include the hash.
 610   ServerWillReply(-1, true, true);
 611   EXPECT_CALL(*service_, StartJob(_, _, _, _, _, _, _));
 612   // State download triggers.
 613   ServerWillSendState(
 614       "example.com",
 615       em::DeviceStateRetrievalResponse::RESTORE_MODE_REENROLLMENT_ENFORCED,
 616       kDisabledMessage);
 617   EXPECT_CALL(*service_, StartJob(_, _, _, _, _, _, _));
 618
 619   // Trigger a network change event.
 620   client_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 621   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 622   EXPECT_TRUE(HasCachedDecision());
 623   VerifyServerBackedState("example.com",
 624                           kDeviceStateRestoreModeReEnrollmentEnforced,
 625                           kDisabledMessage);
 626   Mock::VerifyAndClearExpectations(service_.get());
 627 }
 628
 629 TEST_F(AutoEnrollmentClientTest, NoDeviceStateRetrieval) {
 630   CreateClient(kStateKey, false, 4, 8);
 631   ServerWillReply(-1, true, true);
 632   EXPECT_CALL(*service_,
 633               CreateJob(DeviceManagementRequestJob::TYPE_DEVICE_STATE_RETRIEVAL,
 634                         _)).Times(0);
 635   client_->Start();
 636   EXPECT_EQ(AUTO_ENROLLMENT_STATE_TRIGGER_ENROLLMENT, state_);
 637   VerifyCachedResult(true, 8);
 638   EXPECT_FALSE(HasServerBackedState());
 639 }
 640
 641 }  // namespace
 642 }  // namespace policy