src/chrome/browser/chromeos/login/reset_browsertest.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 <string>
   6
   7 #include "base/prefs/pref_service.h"
   8 #include "chrome/browser/browser_process.h"
   9 #include "chrome/browser/chromeos/login/login_manager_test.h"
  10 #include "chrome/browser/chromeos/login/startup_utils.h"
  11 #include "chrome/browser/chromeos/login/test/oobe_screen_waiter.h"
  12 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
  13 #include "chrome/browser/chromeos/login/ui/oobe_display.h"
  14 #include "chrome/browser/chromeos/login/ui/webui_login_view.h"
  15 #include "chrome/common/chrome_switches.h"
  16 #include "chrome/common/pref_names.h"
  17 #include "chromeos/chromeos_switches.h"
  18 #include "chromeos/dbus/dbus_thread_manager.h"
  19 #include "chromeos/dbus/fake_dbus_thread_manager.h"
  20 #include "chromeos/dbus/fake_power_manager_client.h"
  21 #include "chromeos/dbus/fake_session_manager_client.h"
  22 #include "chromeos/dbus/fake_update_engine_client.h"
  23 #include "content/public/test/browser_test_utils.h"
  24
  25 namespace chromeos {
  26
  27 namespace {
  28
  29 const char kTestUser1[] = "test-user1@gmail.com";
  30
  31 }  // namespace
  32
  33 class ResetTest : public LoginManagerTest {
  34  public:
  35   ResetTest() : LoginManagerTest(false),
  36       update_engine_client_(NULL),
  37       session_manager_client_(NULL),
  38       power_manager_client_(NULL) {
  39   }
  40   virtual ~ResetTest() {}
  41
  42   // LoginManagerTest overrides:
  43   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
  44     FakeDBusThreadManager* dbus_manager = new FakeDBusThreadManager;
  45     dbus_manager->SetFakeClients();
  46     session_manager_client_ = new FakeSessionManagerClient;
  47     dbus_manager->SetSessionManagerClient(
  48         scoped_ptr<SessionManagerClient>(session_manager_client_));
  49     power_manager_client_ = new FakePowerManagerClient;
  50     dbus_manager->SetPowerManagerClient(
  51         scoped_ptr<PowerManagerClient>(power_manager_client_));
  52     update_engine_client_ = new FakeUpdateEngineClient;
  53     dbus_manager->SetUpdateEngineClient(
  54         scoped_ptr<UpdateEngineClient>(update_engine_client_));
  55     DBusThreadManager::SetInstanceForTesting(dbus_manager);
  56
  57     LoginManagerTest::SetUpInProcessBrowserTestFixture();
  58   }
  59
  60   void RegisterSomeUser() {
  61     RegisterUser(kTestUser1);
  62     StartupUtils::MarkOobeCompleted();
  63   }
  64
  65   bool JSExecuted(const std::string& script) {
  66     return content::ExecuteScript(web_contents(), script);
  67   }
  68
  69   void InvokeResetScreen() {
  70     ASSERT_TRUE(JSExecuted("cr.ui.Oobe.handleAccelerator('reset');"));
  71     OobeScreenWaiter(OobeDisplay::SCREEN_OOBE_RESET).Wait();
  72   }
  73
  74   void CloseResetScreen() {
  75     ASSERT_TRUE(JSExecuted("$('reset-cancel-button').click();"));
  76   }
  77
  78   void ClickResetButton() {
  79     ASSERT_TRUE(JSExecuted("$('reset-button').click();"));
  80   }
  81
  82   FakeUpdateEngineClient* update_engine_client_;
  83   FakeSessionManagerClient* session_manager_client_;
  84   FakePowerManagerClient* power_manager_client_;
  85 };
  86
  87 class ResetFirstAfterBootTest : public ResetTest {
  88  public:
  89   virtual ~ResetFirstAfterBootTest() {}
  90
  91   virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE {
  92     LoginManagerTest::SetUpCommandLine(command_line);
  93     command_line->AppendSwitch(switches::kFirstExecAfterBoot);
  94   }
  95 };
  96
  97 IN_PROC_BROWSER_TEST_F(ResetTest, PRE_ShowAndCancel) {
  98   RegisterSomeUser();
  99 }
 100
 101 IN_PROC_BROWSER_TEST_F(ResetTest, ShowAndCancel) {
 102   JSExpect("!!document.querySelector('#reset.hidden')");
 103   EXPECT_EQ(0, update_engine_client_->can_rollback_call_count());
 104   InvokeResetScreen();
 105   JSExpect("!document.querySelector('#reset.hidden')");
 106   CloseResetScreen();
 107   JSExpect("!!document.querySelector('#reset.hidden')");
 108   if (CommandLine::ForCurrentProcess()->HasSwitch(
 109           switches::kEnableRollbackOption)) {
 110     EXPECT_EQ(1, update_engine_client_->can_rollback_call_count());
 111   }
 112 }
 113
 114 IN_PROC_BROWSER_TEST_F(ResetTest, PRE_RestartBeforePowerwash) {
 115   RegisterSomeUser();
 116 }
 117
 118 IN_PROC_BROWSER_TEST_F(ResetTest, RestartBeforePowerwash) {
 119   PrefService* prefs = g_browser_process->local_state();
 120
 121   InvokeResetScreen();
 122   EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 123   EXPECT_EQ(0, session_manager_client_->start_device_wipe_call_count());
 124   ClickResetButton();
 125   ASSERT_EQ(1, power_manager_client_->num_request_restart_calls());
 126   ASSERT_EQ(0, session_manager_client_->start_device_wipe_call_count());
 127
 128   EXPECT_FALSE(prefs->GetBoolean(prefs::kRollbackRequested));
 129   EXPECT_TRUE(prefs->GetBoolean(prefs::kFactoryResetRequested));
 130 }
 131
 132 IN_PROC_BROWSER_TEST_F(ResetTest, PRE_RestartBeforeRollback) {
 133   RegisterSomeUser();
 134   update_engine_client_->set_can_rollback_check_result(true);
 135 }
 136
 137 IN_PROC_BROWSER_TEST_F(ResetTest, RestartBeforeRollback) {
 138   PrefService* prefs = g_browser_process->local_state();
 139
 140   InvokeResetScreen();
 141   EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 142   EXPECT_EQ(0, session_manager_client_->start_device_wipe_call_count());
 143   ASSERT_TRUE(content::ExecuteScript(
 144       web_contents(),
 145       "$('reset-rollback-checkbox').checked = true;"));
 146   ClickResetButton();
 147   ASSERT_EQ(1, power_manager_client_->num_request_restart_calls());
 148   ASSERT_EQ(0, session_manager_client_->start_device_wipe_call_count());
 149   EXPECT_EQ(0, update_engine_client_->rollback_call_count());
 150
 151   EXPECT_TRUE(prefs->GetBoolean(prefs::kRollbackRequested));
 152   EXPECT_TRUE(prefs->GetBoolean(prefs::kFactoryResetRequested));
 153 }
 154
 155 IN_PROC_BROWSER_TEST_F(ResetFirstAfterBootTest, PRE_ShortcutInvokedCases) {
 156   RegisterSomeUser();
 157 }
 158
 159 IN_PROC_BROWSER_TEST_F(ResetFirstAfterBootTest, ShortcutInvokedCases) {
 160   // rollback unavailable
 161   update_engine_client_->set_can_rollback_check_result(false);
 162   InvokeResetScreen();
 163   EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 164   EXPECT_EQ(0, session_manager_client_->start_device_wipe_call_count());
 165   EXPECT_EQ(0, update_engine_client_->rollback_call_count());
 166   ClickResetButton();
 167   EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 168   EXPECT_EQ(1, session_manager_client_->start_device_wipe_call_count());
 169   EXPECT_EQ(0, update_engine_client_->rollback_call_count());
 170   CloseResetScreen();
 171   OobeScreenWaiter(OobeDisplay::SCREEN_ACCOUNT_PICKER).Wait();
 172
 173   update_engine_client_->set_can_rollback_check_result(true);
 174   // rollback available and unchecked
 175   InvokeResetScreen();
 176   ClickResetButton();
 177   EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 178   EXPECT_EQ(2, session_manager_client_->start_device_wipe_call_count());
 179   EXPECT_EQ(0, update_engine_client_->rollback_call_count());
 180   CloseResetScreen();
 181   OobeScreenWaiter(OobeDisplay::SCREEN_ACCOUNT_PICKER).Wait();
 182
 183   if (CommandLine::ForCurrentProcess()->HasSwitch(
 184           switches::kEnableRollbackOption)) {
 185     // rollback available and checked
 186     InvokeResetScreen();
 187     ASSERT_TRUE(content::ExecuteScript(
 188         web_contents(),
 189         "$('reset-rollback-checkbox').checked = true;"));
 190     ClickResetButton();
 191     EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 192     EXPECT_EQ(2, session_manager_client_->start_device_wipe_call_count());
 193     EXPECT_EQ(1, update_engine_client_->rollback_call_count());
 194   }
 195 }
 196
 197 IN_PROC_BROWSER_TEST_F(ResetFirstAfterBootTest, PRE_PowerwashRequested) {
 198   PrefService* prefs = g_browser_process->local_state();
 199   prefs->SetBoolean(prefs::kRollbackRequested, false);
 200   prefs->SetBoolean(prefs::kFactoryResetRequested, true);
 201   RegisterSomeUser();
 202 }
 203
 204 IN_PROC_BROWSER_TEST_F(ResetFirstAfterBootTest, PowerwashRequested) {
 205   OobeScreenWaiter(OobeDisplay::SCREEN_OOBE_RESET).Wait();
 206   EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 207   EXPECT_EQ(0, session_manager_client_->start_device_wipe_call_count());
 208   EXPECT_EQ(0, update_engine_client_->rollback_call_count());
 209   ClickResetButton();
 210   EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 211   EXPECT_EQ(1, session_manager_client_->start_device_wipe_call_count());
 212   EXPECT_EQ(0, update_engine_client_->rollback_call_count());
 213 }
 214
 215 IN_PROC_BROWSER_TEST_F(ResetFirstAfterBootTest, PRE_ErrorOnRollbackRequested) {
 216   PrefService* prefs = g_browser_process->local_state();
 217   prefs->SetBoolean(prefs::kRollbackRequested, true);
 218   prefs->SetBoolean(prefs::kFactoryResetRequested, true);
 219   RegisterSomeUser();
 220 }
 221
 222 IN_PROC_BROWSER_TEST_F(ResetFirstAfterBootTest, ErrorOnRollbackRequested) {
 223   OobeScreenWaiter(OobeDisplay::SCREEN_OOBE_RESET).Wait();
 224   EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 225   EXPECT_EQ(0, session_manager_client_->start_device_wipe_call_count());
 226   EXPECT_EQ(0, update_engine_client_->rollback_call_count());
 227   JSExpect("!$('reset').classList.contains('revert-promise')");
 228   ClickResetButton();
 229   if (CommandLine::ForCurrentProcess()->HasSwitch(
 230           switches::kEnableRollbackOption)) {
 231     EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 232     EXPECT_EQ(0, session_manager_client_->start_device_wipe_call_count());
 233     EXPECT_EQ(1, update_engine_client_->rollback_call_count());
 234     JSExpect("$('reset').classList.contains('revert-promise')");
 235     UpdateEngineClient::Status error_update_status;
 236     error_update_status.status = UpdateEngineClient::UPDATE_STATUS_ERROR;
 237     update_engine_client_->NotifyObserversThatStatusChanged(
 238         error_update_status);
 239     OobeScreenWaiter(OobeDisplay::SCREEN_ERROR_MESSAGE).Wait();
 240   }
 241 }
 242
 243 IN_PROC_BROWSER_TEST_F(ResetFirstAfterBootTest,
 244                        PRE_SuccessOnRollbackRequested) {
 245   PrefService* prefs = g_browser_process->local_state();
 246   prefs->SetBoolean(prefs::kRollbackRequested, true);
 247   prefs->SetBoolean(prefs::kFactoryResetRequested, true);
 248   RegisterSomeUser();
 249 }
 250
 251 IN_PROC_BROWSER_TEST_F(ResetFirstAfterBootTest, SuccessOnRollbackRequested) {
 252   if (CommandLine::ForCurrentProcess()->HasSwitch(
 253           switches::kEnableRollbackOption)) {
 254     OobeScreenWaiter(OobeDisplay::SCREEN_OOBE_RESET).Wait();
 255     ClickResetButton();
 256     EXPECT_EQ(0, power_manager_client_->num_request_restart_calls());
 257     EXPECT_EQ(0, session_manager_client_->start_device_wipe_call_count());
 258     EXPECT_EQ(1, update_engine_client_->rollback_call_count());
 259     UpdateEngineClient::Status ready_for_reboot_status;
 260     ready_for_reboot_status.status =
 261         UpdateEngineClient::UPDATE_STATUS_UPDATED_NEED_REBOOT;
 262     update_engine_client_->NotifyObserversThatStatusChanged(
 263         ready_for_reboot_status);
 264     EXPECT_EQ(1, power_manager_client_->num_request_restart_calls());
 265   }
 266 }
 267
 268
 269 }  // namespace chromeos