Implemented consumer management unenrollment.

chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_initializer.h"
 #include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h"
 #include "chrome/browser/chromeos/policy/enterprise_install_attributes.h"
+#include "chrome/browser/chromeos/policy/fake_consumer_management_service.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chromeos/cryptohome/system_salt_getter.h"
 #include "chromeos/dbus/dbus_client_implementation_type.h"
@@ skipping 121 matching lines @@
     manager_->AddObserver(this);
     initializer_.reset(new DeviceCloudPolicyInitializer(
         &local_state_,
         &device_management_service_,
         &consumer_device_management_service_,
         base::MessageLoopProxy::current(),
         install_attributes_.get(),
         &state_keys_broker_,
         store_,
         manager_.get(),
-        &device_settings_service_));
+        &device_settings_service_,
+        &consumer_management_service_));
     initializer_->Init();
   }
 
   void VerifyPolicyPopulated() {
     PolicyBundle bundle;
     bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .Set(key::kDeviceMetricsReportingEnabled,
              POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_MACHINE,
              new base::FundamentalValue(false),
              NULL);
     EXPECT_TRUE(manager_->policies().Equals(bundle));
   }
 
   MOCK_METHOD0(OnDeviceCloudPolicyManagerConnected, void());
+  MOCK_METHOD0(OnDeviceCloudPolicyManagerDisconnected, void());
 
   scoped_ptr<EnterpriseInstallAttributes> install_attributes_;
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   net::TestURLFetcherFactory url_fetcher_factory_;
   int url_fetcher_response_code_;
   string url_fetcher_response_string_;
   TestingPrefServiceSimple local_state_;
   MockDeviceManagementService device_management_service_;
   MockDeviceManagementService consumer_device_management_service_;
   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
   chromeos::ScopedTestCrosSettings test_cros_settings_;
   chromeos::system::ScopedFakeStatisticsProvider fake_statistics_provider_;
   chromeos::FakeSessionManagerClient fake_session_manager_client_;
   chromeos::FakeCryptohomeClient* fake_cryptohome_client_;
   ServerBackedStateKeysBroker state_keys_broker_;
 
   DeviceCloudPolicyStoreChromeOS* store_;
   SchemaRegistry schema_registry_;
   scoped_ptr<DeviceCloudPolicyManagerChromeOS> manager_;
+  FakeConsumerManagementService consumer_management_service_;
   scoped_ptr<DeviceCloudPolicyInitializer> initializer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeviceCloudPolicyManagerChromeOSTest);
 };
 
 TEST_F(DeviceCloudPolicyManagerChromeOSTest, FreshDevice) {
   owner_key_util_->Clear();
   FlushDeviceSettings();
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
@@ skipping 57 matching lines @@
       device_policy_.policy());
   policy_fetch_job->SendResponse(DM_STATUS_SUCCESS, policy_fetch_response);
   FlushDeviceSettings();
 
   // Policy state should now be active and the policy map should be populated.
   EXPECT_TRUE(store_->is_managed());
   VerifyPolicyPopulated();
 }
 
 TEST_F(DeviceCloudPolicyManagerChromeOSTest, ConsumerDevice) {
+  consumer_management_service_.SetStatusAndStage(
+      ConsumerManagementService::STATUS_ENROLLED,

[bartfab (slow), 2014/11/28 13:25:18]

Nit: #include "chrome/browser/chromeos/policy/consumer_management_service.h"

[davidyu, 2014/12/01 17:05:22]

Done.

+      ConsumerManagementStage(ConsumerManagementStage::NONE));

[bartfab (slow), 2014/11/28 13:25:18]

Nit: #include "chrome/browser/chromeos/policy/consumer_management_stage.h"

[davidyu, 2014/12/01 17:05:22]

Done.

   FlushDeviceSettings();
   EXPECT_EQ(CloudPolicyStore::STATUS_BAD_STATE, store_->status());
   EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
 
   PolicyBundle bundle;
   EXPECT_TRUE(manager_->policies().Equals(bundle));
+  EXPECT_FALSE(manager_->core()->service());  // Not connected.

[bartfab (slow), 2014/11/28 13:25:18]

Nit: #include "components/policy/core/common/cloud/cloud_policy_core.h"

[davidyu, 2014/12/01 17:05:22]

Done.

 
   ConnectManager();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(manager_->policies().Equals(bundle));
+  EXPECT_TRUE(manager_->core()->service());  // Connected.
+
+  manager_->Disconnect();
+  EXPECT_FALSE(manager_->core()->service());  // Not connected.
 
   manager_->Shutdown();
   EXPECT_TRUE(manager_->policies().Equals(bundle));
 }
 
-TEST_F(DeviceCloudPolicyManagerChromeOSTest, ObserverIsNotifiedWhenConnected) {
+TEST_F(DeviceCloudPolicyManagerChromeOSTest,
+       ObserverIsNotifiedWhenConnectedAndDisconnected) {
   LockDevice();
   FlushDeviceSettings();
 
   MockDeviceManagementJob* policy_fetch_job = NULL;
   EXPECT_CALL(device_management_service_,
               CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH, _))
       .WillOnce(device_management_service_.CreateAsyncJob(&policy_fetch_job));
   EXPECT_CALL(device_management_service_, StartJob(_, _, _, _, _, _, _));
   EXPECT_CALL(*this, OnDeviceCloudPolicyManagerConnected());
 
   ConnectManager();
   base::RunLoop().RunUntilIdle();
+  Mock::VerifyAndClearExpectations(&device_management_service_);
+  Mock::VerifyAndClearExpectations(this);
+
+  EXPECT_CALL(*this, OnDeviceCloudPolicyManagerDisconnected());
+  manager_->Disconnect();
 }
 
 class DeviceCloudPolicyManagerChromeOSEnrollmentTest
     : public DeviceCloudPolicyManagerChromeOSTest {
  public:
   void Done(EnrollmentStatus status) {
     status_ = status;
     done_ = true;
   }
 
+  MOCK_METHOD1(OnUnregistered, void(bool));
+
  protected:
   DeviceCloudPolicyManagerChromeOSEnrollmentTest()
       : is_auto_enrollment_(false),
         management_mode_(em::PolicyData::ENTERPRISE_MANAGED),
         register_status_(DM_STATUS_SUCCESS),
         policy_fetch_status_(DM_STATUS_SUCCESS),
         robot_auth_fetch_status_(DM_STATUS_SUCCESS),
         store_result_(true),
         status_(EnrollmentStatus::ForStatus(EnrollmentStatus::STATUS_SUCCESS)),
         done_(false) {}
@@ skipping 290 matching lines @@
        SuccessfulConsumerManagementEnrollment) {
   management_mode_ = em::PolicyData::CONSUMER_MANAGED;
   owner_key_util_->SetPrivateKey(device_policy_.GetSigningKey());
   InitOwner(device_policy_.policy_data().username(), true);
   FlushDeviceSettings();
 
   RunTest();
   ExpectSuccessfulEnrollment();
 }
 
+TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentTest, UnregisterSucceeds) {
+  // Enroll first.
+  RunTest();
+  ExpectSuccessfulEnrollment();
+
+  // Set up mock objects for the upcoming unregistration job.
+  em::DeviceManagementResponse response;
+  response.mutable_unregister_response();
+  EXPECT_CALL(device_management_service_,
+              CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION, _))
+      .WillOnce(device_management_service_.SucceedJob(response));
+  EXPECT_CALL(device_management_service_, StartJob(_, _, _, _, _, _, _));
+  EXPECT_CALL(*this, OnUnregistered(true));
+
+  // Start unregistering.
+  manager_->Unregister(base::Bind(
+      &DeviceCloudPolicyManagerChromeOSEnrollmentTest::OnUnregistered,
+      base::Unretained(this)));
+}
+
+TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentTest, UnregisterFails) {
+  // Enroll first.
+  RunTest();
+  ExpectSuccessfulEnrollment();
+
+  // Set up mock objects for the upcoming unregistration job.
+  EXPECT_CALL(device_management_service_,
+              CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION, _))
+      .WillOnce(device_management_service_.FailJob(DM_STATUS_REQUEST_FAILED));
+  EXPECT_CALL(device_management_service_, StartJob(_, _, _, _, _, _, _));
+  EXPECT_CALL(*this, OnUnregistered(false));
+
+  // Start unregistering.
+  manager_->Unregister(base::Bind(
+      &DeviceCloudPolicyManagerChromeOSEnrollmentTest::OnUnregistered,
+      base::Unretained(this)));
+}
+
 // A subclass that runs with a blank system salt.
 class DeviceCloudPolicyManagerChromeOSEnrollmentBlankSystemSaltTest
     : public DeviceCloudPolicyManagerChromeOSEnrollmentTest {
  protected:
   DeviceCloudPolicyManagerChromeOSEnrollmentBlankSystemSaltTest() {
     // Set up a FakeCryptohomeClient with a blank system salt.
     fake_cryptohome_client_->set_system_salt(std::vector<uint8>());
   }
 };
 
 TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentBlankSystemSaltTest,
        RobotRefreshSaveFailed) {
   // Without the system salt, the robot token can't be stored.
   RunTest();
   ExpectFailedEnrollment(EnrollmentStatus::STATUS_ROBOT_REFRESH_STORE_FAILED);
 }
 
 }  // namespace
 }  // namespace policy