Add device disabling to OOBE flow

chrome/browser/chromeos/login/screens/device_disabled_screen_unittest.cc

+// Copyright 2014 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/login/screens/device_disabled_screen.h"
+
+#include "base/command_line.h"
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/prefs/scoped_user_pref_update.h"
+#include "base/prefs/testing_pref_service.h"
+#include "chrome/browser/browser_process_platform_part.h"
+#include "chrome/browser/chromeos/login/screens/mock_device_disabled_screen_actor.h"
+#include "chrome/browser/chromeos/login/screens/screen_observer.h"
+#include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
+#include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
+#include "chrome/browser/chromeos/policy/server_backed_device_state.h"
+#include "chrome/browser/chromeos/policy/stub_enterprise_install_attributes.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chromeos/chromeos_switches.h"
+#include "components/policy/core/common/cloud/cloud_policy_constants.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+
+namespace chromeos {
+
+namespace {
+
+const char kDisabledMessage[] = "Device disabled.";
+
+}
+
+class DeviceDisabledScreenTest : public testing::Test, public ScreenObserver {
+ public:
+  DeviceDisabledScreenTest();
+  ~DeviceDisabledScreenTest() override;
+
+  // testing::Test:
+  void SetUp() override;
+  void TearDown() override;
+
+  // ScreenObserver:
+  MOCK_METHOD1(OnExit, void(ExitCodes));
+  void ShowCurrentScreen() override;
+  void OnSetUserNamePassword(const std::string& username,
+                             const std::string& password) override;
+  void SetUsageStatisticsReporting(bool val) override;
+  bool GetUsageStatisticsReporting() const override;
+  void SetHostConfiguration() override;
+  void ConfigureHost(bool accepted_eula,
+                     const std::string& lang,
+                     const std::string& timezone,
+                     bool send_reports,
+                     const std::string& keyboard_layout) override;
+  ErrorScreen* GetErrorScreen() override;
+  void ShowErrorScreen() override;
+  void HideErrorScreen(BaseScreen* parent_screen) override;
+
+  void SetDeviceDisabled(bool disabled);
+  void SetDeviceMode(policy::DeviceMode device_mode);
+
+  void ExpectScreenToNotShow();
+  void ExpectScreenToShow();
+
+  void TryToShowScreen();
+
+ private:
+  scoped_ptr<DeviceDisabledScreen> screen_;
+  scoped_ptr<MockDeviceDisabledScreenActor> actor_;
+  TestingPrefServiceSimple local_state_;
+  policy::ScopedStubEnterpriseInstallAttributes install_attributes_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceDisabledScreenTest);
+};
+
+DeviceDisabledScreenTest::DeviceDisabledScreenTest()
+    : install_attributes_("", "", "", policy::DEVICE_MODE_NOT_SET) {
+}
+
+DeviceDisabledScreenTest::~DeviceDisabledScreenTest() {
+}
+
+void DeviceDisabledScreenTest::SetUp() {
+  TestingBrowserProcess::GetGlobal()->SetLocalState(&local_state_);
+  policy::DeviceCloudPolicyManagerChromeOS::RegisterPrefs(
+      local_state_.registry());
+
+  actor_.reset(new MockDeviceDisabledScreenActor);
+  screen_.reset(new DeviceDisabledScreen(this, actor_.get()));
+}
+
+void DeviceDisabledScreenTest::TearDown() {
+  TestingBrowserProcess::GetGlobal()->SetLocalState(nullptr);
+}
+
+void DeviceDisabledScreenTest::ShowCurrentScreen() {
+}
+
+void DeviceDisabledScreenTest::OnSetUserNamePassword(
+    const std::string& username,
+    const std::string& password) {
+}
+
+void DeviceDisabledScreenTest::SetUsageStatisticsReporting(bool val) {
+}
+
+bool DeviceDisabledScreenTest::GetUsageStatisticsReporting() const {
+  return false;
+}
+
+void DeviceDisabledScreenTest::SetHostConfiguration() {
+}
+
+void DeviceDisabledScreenTest::ConfigureHost(
+    bool accepted_eula,
+    const std::string& lang,
+    const std::string& timezone,
+    bool send_reports,
+    const std::string& keyboard_layout) {
+}
+
+ErrorScreen* DeviceDisabledScreenTest::GetErrorScreen() {
+  return nullptr;
+}
+
+void DeviceDisabledScreenTest::ShowErrorScreen() {
+}
+
+void DeviceDisabledScreenTest::HideErrorScreen(BaseScreen* parent_screen) {
+}
+
+void DeviceDisabledScreenTest::SetDeviceDisabled(bool disabled) {
+  DictionaryPrefUpdate dict(&local_state_, prefs::kServerBackedDeviceState);
+  dict->SetBoolean(policy::kDeviceStateDisabled, disabled);
+  if (disabled)
+    dict->SetString(policy::kDeviceStateDisabledMessage, kDisabledMessage);
+}
+
+void DeviceDisabledScreenTest::SetDeviceMode(policy::DeviceMode device_mode) {
+  reinterpret_cast<policy::StubEnterpriseInstallAttributes*>(
+      TestingBrowserProcess::GetGlobal()->platform_part()->
+          browser_policy_connector_chromeos()->GetInstallAttributes())->
+              SetMode(device_mode);
+}
+
+void DeviceDisabledScreenTest::ExpectScreenToNotShow() {
+  EXPECT_CALL(*actor_, Show(_)).Times(0);
+  EXPECT_CALL(*this, OnExit(ScreenObserver::DEVICE_NOT_DISABLED)).Times(1);
+}
+
+void DeviceDisabledScreenTest::ExpectScreenToShow() {
+  EXPECT_CALL(*actor_, Show(kDisabledMessage)).Times(1);
+  EXPECT_CALL(*this, OnExit(ScreenObserver::DEVICE_NOT_DISABLED)).Times(0);
+}
+
+void DeviceDisabledScreenTest::TryToShowScreen() {
+  screen_->Show();
+}
+
+// Verifies that the device disabled screen is not shown by default.
+TEST_F(DeviceDisabledScreenTest, DoNotShowByDefault) {
+  ExpectScreenToNotShow();
+  TryToShowScreen();
+}
+
+// Verifies that the device disabled screen is not shown when the device is
+// explicitly marked as not disabled.
+TEST_F(DeviceDisabledScreenTest, DoNotShowWhenNotDisabled) {
+  SetDeviceDisabled(false);
+  ExpectScreenToNotShow();
+  TryToShowScreen();
+}
+
+// Verifies that the device disabled screen is not shown when device disabling
+// is turned off by flag, even if the device is marked as disabled.
+TEST_F(DeviceDisabledScreenTest, DoNotShowWhenTurnedOffByFlag) {
+  CommandLine::ForCurrentProcess()->AppendSwitch(
+      switches::kDisableDeviceDisabling);
+  SetDeviceDisabled(true);
+  ExpectScreenToNotShow();
+  TryToShowScreen();
+}
+
+// Verifies that the device disabled screen is not shown when the device is
+// already enrolled, even if the device is marked as disabled.
+TEST_F(DeviceDisabledScreenTest, DoNotShowWhenEnterpriseOwned) {
+  SetDeviceMode(policy::DEVICE_MODE_ENTERPRISE);
+  SetDeviceDisabled(true);
+  ExpectScreenToNotShow();
+  TryToShowScreen();
+}
+
+// Verifies that the device disabled screen is not shown when the device is
+// already owned by a consumer, even if the device is marked as disabled.
+TEST_F(DeviceDisabledScreenTest, DoNotShowWhenConsumerOwned) {
+  SetDeviceMode(policy::DEVICE_MODE_CONSUMER);
+  SetDeviceDisabled(true);
+  ExpectScreenToNotShow();
+  TryToShowScreen();
+}
+
+// Verifies that the device disabled screen is shown when the device is marked
+// as disabled, device disabling is not turned off by flag and the device is not
+// owned yet.
+TEST_F(DeviceDisabledScreenTest, ShowWhenDisabledAndNotOwned) {
+  SetDeviceDisabled(true);
+  ExpectScreenToShow();
+  TryToShowScreen();
+}
+
+}  // namespace chromeos