src/chrome/browser/chromeos/login/wizard_controller_browsertest.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 "base/basictypes.h"
   6 #include "base/command_line.h"
   7 #include "base/compiler_specific.h"
   8 #include "base/path_service.h"
   9 #include "base/prefs/pref_registry_simple.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/prefs/pref_service_factory.h"
  12 #include "base/prefs/testing_pref_store.h"
  13 #include "base/run_loop.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "chrome/browser/browser_process.h"
  16 #include "chrome/browser/browser_shutdown.h"
  17 #include "chrome/browser/chrome_notification_types.h"
  18 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
  19 #include "chrome/browser/chromeos/base/locale_util.h"
  20 #include "chrome/browser/chromeos/login/enrollment/enrollment_screen.h"
  21 #include "chrome/browser/chromeos/login/enrollment/mock_enrollment_screen.h"
  22 #include "chrome/browser/chromeos/login/existing_user_controller.h"
  23 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
  24 #include "chrome/browser/chromeos/login/mock_authenticator.h"
  25 #include "chrome/browser/chromeos/login/mock_login_status_consumer.h"
  26 #include "chrome/browser/chromeos/login/screens/error_screen.h"
  27 #include "chrome/browser/chromeos/login/screens/hid_detection_screen.h"
  28 #include "chrome/browser/chromeos/login/screens/mock_eula_screen.h"
  29 #include "chrome/browser/chromeos/login/screens/mock_network_screen.h"
  30 #include "chrome/browser/chromeos/login/screens/mock_update_screen.h"
  31 #include "chrome/browser/chromeos/login/screens/network_screen.h"
  32 #include "chrome/browser/chromeos/login/screens/reset_screen.h"
  33 #include "chrome/browser/chromeos/login/screens/user_image_screen.h"
  34 #include "chrome/browser/chromeos/login/screens/wrong_hwid_screen.h"
  35 #include "chrome/browser/chromeos/login/startup_utils.h"
  36 #include "chrome/browser/chromeos/login/test_login_utils.h"
  37 #include "chrome/browser/chromeos/login/webui_login_view.h"
  38 #include "chrome/browser/chromeos/login/wizard_controller.h"
  39 #include "chrome/browser/chromeos/login/wizard_in_process_browser_test.h"
  40 #include "chrome/browser/chromeos/policy/server_backed_device_state.h"
  41 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  42 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
  43 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
  44 #include "chrome/common/chrome_paths.h"
  45 #include "chrome/common/chrome_switches.h"
  46 #include "chrome/common/pref_names.h"
  47 #include "chrome/test/base/ui_test_utils.h"
  48 #include "chromeos/audio/cras_audio_handler.h"
  49 #include "chromeos/chromeos_switches.h"
  50 #include "chromeos/chromeos_test_utils.h"
  51 #include "chromeos/dbus/dbus_thread_manager.h"
  52 #include "chromeos/dbus/fake_dbus_thread_manager.h"
  53 #include "chromeos/dbus/fake_session_manager_client.h"
  54 #include "chromeos/network/network_state_handler.h"
  55 #include "chromeos/system/mock_statistics_provider.h"
  56 #include "chromeos/system/statistics_provider.h"
  57 #include "content/public/test/browser_test_utils.h"
  58 #include "content/public/test/test_utils.h"
  59 #include "grit/generated_resources.h"
  60 #include "net/test/spawned_test_server/spawned_test_server.h"
  61 #include "testing/gmock/include/gmock/gmock.h"
  62 #include "testing/gtest/include/gtest/gtest.h"
  63 #include "third_party/icu/source/common/unicode/locid.h"
  64 #include "ui/base/accelerators/accelerator.h"
  65 #include "ui/base/l10n/l10n_util.h"
  66
  67 using ::testing::Exactly;
  68 using ::testing::Invoke;
  69 using ::testing::Return;
  70
  71 namespace chromeos {
  72
  73 namespace {
  74 const char kUsername[] = "test_user@managedchrome.com";
  75 const char kPassword[] = "test_password";
  76
  77 class PrefStoreStub : public TestingPrefStore {
  78  public:
  79   // TestingPrefStore overrides:
  80   virtual PrefReadError GetReadError() const OVERRIDE {
  81     return PersistentPrefStore::PREF_READ_ERROR_JSON_PARSE;
  82   }
  83
  84   virtual bool IsInitializationComplete() const OVERRIDE {
  85     return true;
  86   }
  87
  88  private:
  89   virtual ~PrefStoreStub() {}
  90 };
  91
  92 struct SwitchLanguageTestData {
  93   SwitchLanguageTestData() : success(false), done(false) {}
  94
  95   std::string requested_locale;
  96   std::string loaded_locale;
  97   bool success;
  98   bool done;
  99 };
 100
 101 void OnLocaleSwitched(SwitchLanguageTestData* self,
 102                       const std::string& locale,
 103                       const std::string& loaded_locale,
 104                       const bool success) {
 105   self->requested_locale = locale;
 106   self->loaded_locale = loaded_locale;
 107   self->success = success;
 108   self->done = true;
 109 }
 110
 111 void RunSwitchLanguageTest(const std::string& locale,
 112                                   const std::string& expected_locale,
 113                                   const bool expect_success) {
 114   SwitchLanguageTestData data;
 115   scoped_ptr<locale_util::SwitchLanguageCallback> callback(
 116       new locale_util::SwitchLanguageCallback(
 117           base::Bind(&OnLocaleSwitched, base::Unretained(&data))));
 118   locale_util::SwitchLanguage(locale, true, false, callback.Pass());
 119
 120   // Token writing moves control to BlockingPool and back.
 121   base::RunLoop().RunUntilIdle();
 122   content::BrowserThread::GetBlockingPool()->FlushForTesting();
 123   base::RunLoop().RunUntilIdle();
 124
 125   EXPECT_EQ(data.done, true);
 126   EXPECT_EQ(data.requested_locale, locale);
 127   EXPECT_EQ(data.loaded_locale, expected_locale);
 128   EXPECT_EQ(data.success, expect_success);
 129 }
 130
 131 void SetUpCrasAndEnableChromeVox(int volume_percent, bool mute_on) {
 132   AccessibilityManager* a11y = AccessibilityManager::Get();
 133   CrasAudioHandler* cras = CrasAudioHandler::Get();
 134
 135   // Audio output is at |volume_percent| and |mute_on|. Spoken feedback
 136   // is disabled.
 137   cras->SetOutputVolumePercent(volume_percent);
 138   cras->SetOutputMute(mute_on);
 139   a11y->EnableSpokenFeedback(false, ash::A11Y_NOTIFICATION_NONE);
 140
 141   // Spoken feedback is enabled.
 142   a11y->EnableSpokenFeedback(true, ash::A11Y_NOTIFICATION_NONE);
 143   base::RunLoop().RunUntilIdle();
 144 }
 145
 146 void QuitLoopOnAutoEnrollmentProgress(
 147     policy::AutoEnrollmentState expected_state,
 148     base::RunLoop* loop,
 149     policy::AutoEnrollmentState actual_state) {
 150   if (expected_state == actual_state)
 151     loop->Quit();
 152 }
 153
 154 void WaitForAutoEnrollmentState(policy::AutoEnrollmentState state) {
 155   base::RunLoop loop;
 156   AutoEnrollmentController* auto_enrollment_controller =
 157       LoginDisplayHostImpl::default_host()->GetAutoEnrollmentController();
 158   scoped_ptr<AutoEnrollmentController::ProgressCallbackList::Subscription>
 159       progress_subscription(
 160           auto_enrollment_controller->RegisterProgressCallback(
 161               base::Bind(&QuitLoopOnAutoEnrollmentProgress, state, &loop)));
 162   loop.Run();
 163 }
 164
 165 }  // namespace
 166
 167 using ::testing::_;
 168
 169 template <class T, class H>
 170 class MockOutShowHide : public T {
 171  public:
 172   template <class P> explicit  MockOutShowHide(P p) : T(p) {}
 173   template <class P> MockOutShowHide(P p, H* actor)
 174       : T(p, actor), actor_(actor) {}
 175
 176   H* actor() const { return actor_.get(); }
 177
 178   MOCK_METHOD0(Show, void());
 179   MOCK_METHOD0(Hide, void());
 180
 181  private:
 182   scoped_ptr<H> actor_;
 183 };
 184
 185 #define MOCK(mock_var, screen_name, mocked_class, actor_class)                 \
 186   mock_var = new MockOutShowHide<mocked_class, actor_class>(                   \
 187       WizardController::default_controller(), new actor_class);                \
 188   WizardController::default_controller()->screen_name.reset(mock_var);         \
 189   EXPECT_CALL(*mock_var, Show()).Times(0);                                     \
 190   EXPECT_CALL(*mock_var, Hide()).Times(0);
 191
 192 class WizardControllerTest : public WizardInProcessBrowserTest {
 193  protected:
 194   WizardControllerTest() : WizardInProcessBrowserTest(
 195       WizardController::kTestNoScreenName) {}
 196   virtual ~WizardControllerTest() {}
 197
 198   virtual void SetUpOnMainThread() OVERRIDE {
 199     AccessibilityManager::Get()->
 200         SetProfileForTest(ProfileHelper::GetSigninProfile());
 201     WizardInProcessBrowserTest::SetUpOnMainThread();
 202   }
 203
 204   ErrorScreen* GetErrorScreen() {
 205     return static_cast<ScreenObserver*>(WizardController::default_controller())
 206         ->GetErrorScreen();
 207   }
 208
 209   content::WebContents* GetWebContents() {
 210     LoginDisplayHostImpl* host = static_cast<LoginDisplayHostImpl*>(
 211         LoginDisplayHostImpl::default_host());
 212     if (!host)
 213       return NULL;
 214     WebUILoginView* webui_login_view = host->GetWebUILoginView();
 215     if (!webui_login_view)
 216       return NULL;
 217     return webui_login_view->GetWebContents();
 218   }
 219
 220   void WaitUntilJSIsReady() {
 221     LoginDisplayHostImpl* host = static_cast<LoginDisplayHostImpl*>(
 222         LoginDisplayHostImpl::default_host());
 223     if (!host)
 224       return;
 225     chromeos::OobeUI* oobe_ui = host->GetOobeUI();
 226     if (!oobe_ui)
 227       return;
 228     base::RunLoop run_loop;
 229     const bool oobe_ui_ready = oobe_ui->IsJSReady(run_loop.QuitClosure());
 230     if (!oobe_ui_ready)
 231       run_loop.Run();
 232   }
 233
 234   bool JSExecuteBooleanExpression(const std::string& expression) {
 235     bool result;
 236     EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
 237         GetWebContents(),
 238         "window.domAutomationController.send(!!(" + expression + "));",
 239         &result));
 240     return result;
 241   }
 242
 243  private:
 244   DISALLOW_COPY_AND_ASSIGN(WizardControllerTest);
 245 };
 246
 247 IN_PROC_BROWSER_TEST_F(WizardControllerTest, SwitchLanguage) {
 248   ASSERT_TRUE(WizardController::default_controller() != NULL);
 249   WizardController::default_controller()->AdvanceToScreen(
 250       WizardController::kNetworkScreenName);
 251
 252   // Checking the default locale. Provided that the profile is cleared in SetUp.
 253   EXPECT_EQ("en-US", g_browser_process->GetApplicationLocale());
 254   EXPECT_STREQ("en", icu::Locale::getDefault().getLanguage());
 255   EXPECT_FALSE(base::i18n::IsRTL());
 256   const std::wstring en_str =
 257       base::UTF16ToWide(l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE));
 258
 259   RunSwitchLanguageTest("fr", "fr", true);
 260   EXPECT_EQ("fr", g_browser_process->GetApplicationLocale());
 261   EXPECT_STREQ("fr", icu::Locale::getDefault().getLanguage());
 262   EXPECT_FALSE(base::i18n::IsRTL());
 263   const std::wstring fr_str =
 264       base::UTF16ToWide(l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE));
 265
 266   EXPECT_NE(en_str, fr_str);
 267
 268   RunSwitchLanguageTest("ar", "ar", true);
 269   EXPECT_EQ("ar", g_browser_process->GetApplicationLocale());
 270   EXPECT_STREQ("ar", icu::Locale::getDefault().getLanguage());
 271   EXPECT_TRUE(base::i18n::IsRTL());
 272   const std::wstring ar_str =
 273       base::UTF16ToWide(l10n_util::GetStringUTF16(IDS_NETWORK_SELECTION_TITLE));
 274
 275   EXPECT_NE(fr_str, ar_str);
 276 }
 277
 278 IN_PROC_BROWSER_TEST_F(WizardControllerTest, VolumeIsChangedForChromeVox) {
 279   SetUpCrasAndEnableChromeVox(75 /* volume_percent */, true /* mute_on */);
 280
 281   // Check that output is unmuted now and at some level.
 282   CrasAudioHandler* cras = CrasAudioHandler::Get();
 283   ASSERT_FALSE(cras->IsOutputMuted());
 284   ASSERT_EQ(WizardController::kMinAudibleOutputVolumePercent,
 285             cras->GetOutputVolumePercent());
 286 }
 287
 288 IN_PROC_BROWSER_TEST_F(WizardControllerTest, VolumeIsUnchangedForChromeVox) {
 289   SetUpCrasAndEnableChromeVox(75 /* volume_percent */, false /* mute_on */);
 290
 291   // Check that output is unmuted now and at some level.
 292   CrasAudioHandler* cras = CrasAudioHandler::Get();
 293   ASSERT_FALSE(cras->IsOutputMuted());
 294   ASSERT_EQ(75, cras->GetOutputVolumePercent());
 295 }
 296
 297 IN_PROC_BROWSER_TEST_F(WizardControllerTest, VolumeIsAdjustedForChromeVox) {
 298   SetUpCrasAndEnableChromeVox(5 /* volume_percent */, false /* mute_on */);
 299
 300   // Check that output is unmuted now and at some level.
 301   CrasAudioHandler* cras = CrasAudioHandler::Get();
 302   ASSERT_FALSE(cras->IsOutputMuted());
 303   ASSERT_EQ(WizardController::kMinAudibleOutputVolumePercent,
 304             cras->GetOutputVolumePercent());
 305 }
 306
 307 class WizardControllerFlowTest : public WizardControllerTest {
 308  protected:
 309   WizardControllerFlowTest() {}
 310   // Overriden from InProcessBrowserTest:
 311   virtual void SetUpOnMainThread() OVERRIDE {
 312     WizardControllerTest::SetUpOnMainThread();
 313
 314     // Make sure that OOBE is run as an "official" build.
 315     WizardController::default_controller()->is_official_build_ = true;
 316
 317     // Clear portal list (as it is by default in OOBE).
 318     NetworkHandler::Get()->network_state_handler()->SetCheckPortalList("");
 319
 320     // Set up the mocks for all screens.
 321     MOCK(mock_network_screen_, network_screen_,
 322          MockNetworkScreen, MockNetworkScreenActor);
 323     MOCK(mock_update_screen_, update_screen_,
 324          MockUpdateScreen, MockUpdateScreenActor);
 325     MOCK(mock_eula_screen_, eula_screen_, MockEulaScreen, MockEulaScreenActor);
 326     MOCK(mock_enrollment_screen_, enrollment_screen_,
 327          MockEnrollmentScreen, MockEnrollmentScreenActor);
 328
 329     // Switch to the initial screen.
 330     EXPECT_EQ(NULL, WizardController::default_controller()->current_screen());
 331     EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 332     WizardController::default_controller()->AdvanceToScreen(
 333         WizardController::kNetworkScreenName);
 334   }
 335
 336   void OnExit(ScreenObserver::ExitCodes exit_code) {
 337     WizardController::default_controller()->OnExit(exit_code);
 338   }
 339
 340   MockOutShowHide<MockNetworkScreen, MockNetworkScreenActor>*
 341       mock_network_screen_;
 342   MockOutShowHide<MockUpdateScreen, MockUpdateScreenActor>* mock_update_screen_;
 343   MockOutShowHide<MockEulaScreen, MockEulaScreenActor>* mock_eula_screen_;
 344   MockOutShowHide<MockEnrollmentScreen,
 345       MockEnrollmentScreenActor>* mock_enrollment_screen_;
 346
 347  private:
 348   DISALLOW_COPY_AND_ASSIGN(WizardControllerFlowTest);
 349 };
 350
 351 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowMain) {
 352   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 353   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 354             WizardController::default_controller()->current_screen());
 355
 356   WaitUntilJSIsReady();
 357
 358   // Check visibility of the header bar.
 359   ASSERT_FALSE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 360
 361   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 362   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 363   OnExit(ScreenObserver::NETWORK_CONNECTED);
 364
 365   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 366             WizardController::default_controller()->current_screen());
 367
 368   // Header bar should still be visible.
 369   ASSERT_FALSE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 370
 371   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 372   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 373   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 374   OnExit(ScreenObserver::EULA_ACCEPTED);
 375   // Let update screen smooth time process (time = 0ms).
 376   content::RunAllPendingInMessageLoop();
 377
 378   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 379             WizardController::default_controller()->current_screen());
 380   EXPECT_CALL(*mock_update_screen_, Hide()).Times(0);
 381   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
 382   OnExit(ScreenObserver::UPDATE_INSTALLED);
 383
 384   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 385   EXPECT_EQ("ethernet,wifi,cellular",
 386             NetworkHandler::Get()->network_state_handler()
 387             ->GetCheckPortalListForTest());
 388 }
 389
 390 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowErrorUpdate) {
 391   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 392             WizardController::default_controller()->current_screen());
 393   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 394   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 395   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
 396   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 397   OnExit(ScreenObserver::NETWORK_CONNECTED);
 398
 399   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 400             WizardController::default_controller()->current_screen());
 401   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 402   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 403   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 404   OnExit(ScreenObserver::EULA_ACCEPTED);
 405   // Let update screen smooth time process (time = 0ms).
 406   content::RunAllPendingInMessageLoop();
 407
 408   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 409             WizardController::default_controller()->current_screen());
 410   EXPECT_CALL(*mock_update_screen_, Hide()).Times(0);
 411   EXPECT_CALL(*mock_eula_screen_, Show()).Times(0);
 412   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(0);  // last transition
 413   OnExit(ScreenObserver::UPDATE_ERROR_UPDATING);
 414
 415   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 416 }
 417
 418 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowSkipUpdateEnroll) {
 419   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 420             WizardController::default_controller()->current_screen());
 421   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 422   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 423   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
 424   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 425   OnExit(ScreenObserver::NETWORK_CONNECTED);
 426
 427   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 428             WizardController::default_controller()->current_screen());
 429   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 430   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 431   EXPECT_CALL(*mock_update_screen_, Show()).Times(0);
 432   WizardController::default_controller()->SkipUpdateEnrollAfterEula();
 433   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 434               SetParameters(mock_enrollment_screen_,
 435                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
 436                             ""))
 437       .Times(1);
 438   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 439   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(0);
 440   OnExit(ScreenObserver::EULA_ACCEPTED);
 441   content::RunAllPendingInMessageLoop();
 442
 443   EXPECT_EQ(WizardController::default_controller()->GetEnrollmentScreen(),
 444             WizardController::default_controller()->current_screen());
 445   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 446   EXPECT_EQ("ethernet,wifi,cellular",
 447             NetworkHandler::Get()->network_state_handler()
 448             ->GetCheckPortalListForTest());
 449 }
 450
 451 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest, ControlFlowEulaDeclined) {
 452   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 453             WizardController::default_controller()->current_screen());
 454   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 455   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 456   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 457   OnExit(ScreenObserver::NETWORK_CONNECTED);
 458
 459   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 460             WizardController::default_controller()->current_screen());
 461   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 462   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 463   EXPECT_CALL(*mock_network_screen_, Hide()).Times(0);  // last transition
 464   OnExit(ScreenObserver::EULA_BACK);
 465
 466   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 467             WizardController::default_controller()->current_screen());
 468 }
 469
 470 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
 471                        ControlFlowEnrollmentCompleted) {
 472   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 473             WizardController::default_controller()->current_screen());
 474   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 475   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 476               SetParameters(mock_enrollment_screen_,
 477                             EnrollmentScreenActor::ENROLLMENT_MODE_MANUAL,
 478                             ""))
 479       .Times(1);
 480   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 481   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 482
 483   WizardController::default_controller()->AdvanceToScreen(
 484       WizardController::kEnrollmentScreenName);
 485   EnrollmentScreen* screen =
 486       WizardController::default_controller()->GetEnrollmentScreen();
 487   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 488   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 489
 490   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 491 }
 492
 493 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
 494                        ControlFlowAutoEnrollmentCompleted) {
 495   WizardController::default_controller()->SkipPostLoginScreensForTesting();
 496   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 497             WizardController::default_controller()->current_screen());
 498   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(0);
 499
 500   LoginUtils::Set(new TestLoginUtils(kUsername, kPassword));
 501   MockConsumer mock_consumer;
 502
 503   // Must have a pending signin to resume after auto-enrollment:
 504   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 505   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 506   ExistingUserController::current_controller()->DoAutoEnrollment();
 507   ExistingUserController::current_controller()->set_login_status_consumer(
 508       &mock_consumer);
 509   // This calls StartWizard, destroying the current controller() and its mocks;
 510   // don't set expectations on those objects.
 511   ExistingUserController::current_controller()->CompleteLogin(
 512       UserContext(kUsername, kPassword, ""));
 513   // Run the tasks posted to complete the login:
 514   base::MessageLoop::current()->RunUntilIdle();
 515
 516   EnrollmentScreen* screen =
 517       WizardController::default_controller()->GetEnrollmentScreen();
 518   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 519   // This is the main expectation: after auto-enrollment, login is resumed.
 520   EXPECT_CALL(mock_consumer, OnLoginSuccess(_)).Times(1);
 521   OnExit(ScreenObserver::ENTERPRISE_AUTO_MAGIC_ENROLLMENT_COMPLETED);
 522   // Prevent browser launch when the profile is prepared:
 523   browser_shutdown::SetTryingToQuit(true);
 524   // Run the tasks posted to complete the login:
 525   base::MessageLoop::current()->RunUntilIdle();
 526 }
 527
 528 IN_PROC_BROWSER_TEST_F(WizardControllerFlowTest,
 529                        ControlFlowWrongHWIDScreenFromLogin) {
 530   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 531             WizardController::default_controller()->current_screen());
 532
 533   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 534   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 535   ExistingUserController::current_controller()->ShowWrongHWIDScreen();
 536
 537   WrongHWIDScreen* screen =
 538       WizardController::default_controller()->GetWrongHWIDScreen();
 539   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 540
 541   // After warning is skipped, user returns to sign-in screen.
 542   // And this destroys WizardController.
 543   OnExit(ScreenObserver::WRONG_HWID_WARNING_SKIPPED);
 544   EXPECT_FALSE(ExistingUserController::current_controller() == NULL);
 545 }
 546
 547 class WizardControllerEnrollmentFlowTest : public WizardControllerFlowTest {
 548  protected:
 549   WizardControllerEnrollmentFlowTest() {}
 550
 551   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 552     WizardControllerFlowTest::SetUpCommandLine(command_line);
 553
 554     command_line->AppendSwitchASCII(
 555         switches::kEnterpriseEnableForcedReEnrollment,
 556         chromeos::AutoEnrollmentController::kForcedReEnrollmentAlways);
 557     command_line->AppendSwitchASCII(
 558         switches::kEnterpriseEnrollmentInitialModulus, "1");
 559     command_line->AppendSwitchASCII(
 560         switches::kEnterpriseEnrollmentModulusLimit, "2");
 561   }
 562
 563   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 564     WizardControllerFlowTest::SetUpInProcessBrowserTestFixture();
 565     system::StatisticsProvider::SetTestProvider(&statistics_provider_);
 566     EXPECT_CALL(statistics_provider_, StartLoadingMachineStatistics(_, _));
 567     EXPECT_CALL(statistics_provider_, GetMachineStatistic(_, _)).WillRepeatedly(
 568         Invoke(this, &WizardControllerEnrollmentFlowTest::GetMachineStatistic));
 569     EXPECT_CALL(statistics_provider_, GetMachineFlag(_, _)).WillRepeatedly(
 570         Return(false));
 571     EXPECT_CALL(statistics_provider_, Shutdown());
 572   }
 573
 574   virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
 575     system::StatisticsProvider::SetTestProvider(NULL);
 576     WizardControllerFlowTest::TearDownInProcessBrowserTestFixture();
 577   }
 578
 579   bool GetMachineStatistic(const std::string& name, std::string* result) {
 580     if (name == system::kDiskSerialNumber) {
 581       *result = "fake-disk-serial-number";
 582       return true;
 583     } else if (name == "serial_number") {
 584       *result = "fake-machine-serial-number";
 585       return true;
 586     }
 587
 588     return false;
 589   }
 590
 591  private:
 592   system::MockStatisticsProvider statistics_provider_;
 593
 594   DISALLOW_COPY_AND_ASSIGN(WizardControllerEnrollmentFlowTest);
 595 };
 596
 597 IN_PROC_BROWSER_TEST_F(WizardControllerEnrollmentFlowTest,
 598                        ControlFlowForcedReEnrollment) {
 599   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 600             WizardController::default_controller()->current_screen());
 601   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 602   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 603   OnExit(ScreenObserver::NETWORK_CONNECTED);
 604
 605   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 606             WizardController::default_controller()->current_screen());
 607   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 608   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 609   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 610   OnExit(ScreenObserver::EULA_ACCEPTED);
 611   // Let update screen smooth time process (time = 0ms).
 612   content::RunAllPendingInMessageLoop();
 613
 614   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 615             WizardController::default_controller()->current_screen());
 616   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 617   OnExit(ScreenObserver::UPDATE_INSTALLED);
 618
 619   // Wait for auto-enrollment controller to encounter the connection error.
 620   WaitForAutoEnrollmentState(policy::AUTO_ENROLLMENT_STATE_CONNECTION_ERROR);
 621
 622   // The error screen shows up if there's no auto-enrollment decision.
 623   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 624   EXPECT_EQ(GetErrorScreen(),
 625             WizardController::default_controller()->current_screen());
 626   base::DictionaryValue device_state;
 627   device_state.SetString(policy::kDeviceStateRestoreMode,
 628                          policy::kDeviceStateRestoreModeReEnrollmentEnforced);
 629   g_browser_process->local_state()->Set(prefs::kServerBackedDeviceState,
 630                                         device_state);
 631   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 632   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 633               SetParameters(mock_enrollment_screen_,
 634                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
 635                             "")).Times(1);
 636   OnExit(ScreenObserver::ENTERPRISE_AUTO_ENROLLMENT_CHECK_COMPLETED);
 637
 638   // Make sure enterprise enrollment page shows up.
 639   EXPECT_EQ(WizardController::default_controller()->GetEnrollmentScreen(),
 640             WizardController::default_controller()->current_screen());
 641   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 642
 643   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 644 }
 645
 646 class WizardControllerBrokenLocalStateTest : public WizardControllerTest {
 647  protected:
 648   WizardControllerBrokenLocalStateTest()
 649       : fake_session_manager_client_(NULL) {
 650   }
 651
 652   virtual ~WizardControllerBrokenLocalStateTest() {}
 653
 654   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 655     WizardControllerTest::SetUpInProcessBrowserTestFixture();
 656
 657     FakeDBusThreadManager* fake_dbus_thread_manager =
 658         new FakeDBusThreadManager();
 659     fake_dbus_thread_manager->SetFakeClients();
 660     fake_session_manager_client_ = new FakeSessionManagerClient;
 661     fake_dbus_thread_manager->SetSessionManagerClient(
 662         scoped_ptr<SessionManagerClient>(fake_session_manager_client_));
 663     DBusThreadManager::SetInstanceForTesting(fake_dbus_thread_manager);
 664   }
 665
 666   virtual void SetUpOnMainThread() OVERRIDE {
 667     base::PrefServiceFactory factory;
 668     factory.set_user_prefs(make_scoped_refptr(new PrefStoreStub()));
 669     local_state_ = factory.Create(new PrefRegistrySimple()).Pass();
 670     WizardController::set_local_state_for_testing(local_state_.get());
 671
 672     WizardControllerTest::SetUpOnMainThread();
 673
 674     // Make sure that OOBE is run as an "official" build.
 675     WizardController::default_controller()->is_official_build_ = true;
 676   }
 677
 678   virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
 679     WizardControllerTest::TearDownInProcessBrowserTestFixture();
 680   }
 681
 682
 683   FakeSessionManagerClient* fake_session_manager_client() const {
 684     return fake_session_manager_client_;
 685   }
 686
 687  private:
 688   scoped_ptr<PrefService> local_state_;
 689   FakeSessionManagerClient* fake_session_manager_client_;
 690
 691   DISALLOW_COPY_AND_ASSIGN(WizardControllerBrokenLocalStateTest);
 692 };
 693
 694 IN_PROC_BROWSER_TEST_F(WizardControllerBrokenLocalStateTest,
 695                        LocalStateCorrupted) {
 696   // Checks that after wizard controller initialization error screen
 697   // in the proper state is displayed.
 698   ASSERT_EQ(GetErrorScreen(),
 699             WizardController::default_controller()->current_screen());
 700   ASSERT_EQ(ErrorScreen::UI_STATE_LOCAL_STATE_ERROR,
 701             GetErrorScreen()->GetUIState());
 702
 703   WaitUntilJSIsReady();
 704
 705   // Checks visibility of the error message and powerwash button.
 706   ASSERT_FALSE(JSExecuteBooleanExpression("$('error-message').hidden"));
 707   ASSERT_TRUE(JSExecuteBooleanExpression(
 708       "$('error-message').classList.contains('ui-state-local-state-error')"));
 709   ASSERT_TRUE(JSExecuteBooleanExpression("$('progress-dots').hidden"));
 710   ASSERT_TRUE(JSExecuteBooleanExpression("$('login-header-bar').hidden"));
 711
 712   // Emulates user click on the "Restart and Powerwash" button.
 713   ASSERT_EQ(0, fake_session_manager_client()->start_device_wipe_call_count());
 714   ASSERT_TRUE(content::ExecuteScript(
 715       GetWebContents(),
 716       "$('error-message-restart-and-powerwash-button').click();"));
 717   ASSERT_EQ(1, fake_session_manager_client()->start_device_wipe_call_count());
 718 }
 719
 720 class WizardControllerProxyAuthOnSigninTest : public WizardControllerTest {
 721  protected:
 722   WizardControllerProxyAuthOnSigninTest()
 723       : proxy_server_(net::SpawnedTestServer::TYPE_BASIC_AUTH_PROXY,
 724                       net::SpawnedTestServer::kLocalhost,
 725                       base::FilePath()) {
 726   }
 727   virtual ~WizardControllerProxyAuthOnSigninTest() {}
 728
 729   // Overridden from WizardControllerTest:
 730   virtual void SetUp() OVERRIDE {
 731     ASSERT_TRUE(proxy_server_.Start());
 732     WizardControllerTest::SetUp();
 733   }
 734
 735   virtual void SetUpOnMainThread() OVERRIDE {
 736     WizardControllerTest::SetUpOnMainThread();
 737     WizardController::default_controller()->AdvanceToScreen(
 738         WizardController::kNetworkScreenName);
 739   }
 740
 741   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 742     command_line->AppendSwitchASCII(::switches::kProxyServer,
 743                                     proxy_server_.host_port_pair().ToString());
 744   }
 745
 746   net::SpawnedTestServer& proxy_server() { return proxy_server_; }
 747
 748  private:
 749   net::SpawnedTestServer proxy_server_;
 750
 751   DISALLOW_COPY_AND_ASSIGN(WizardControllerProxyAuthOnSigninTest);
 752 };
 753
 754 IN_PROC_BROWSER_TEST_F(WizardControllerProxyAuthOnSigninTest,
 755                        ProxyAuthDialogOnSigninScreen) {
 756   content::WindowedNotificationObserver auth_needed_waiter(
 757       chrome::NOTIFICATION_AUTH_NEEDED,
 758       content::NotificationService::AllSources());
 759
 760   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 761             WizardController::default_controller()->current_screen());
 762
 763   LoginDisplayHostImpl::default_host()->StartSignInScreen(LoginScreenContext());
 764   auth_needed_waiter.Wait();
 765 }
 766
 767 class WizardControllerKioskFlowTest : public WizardControllerFlowTest {
 768  protected:
 769   WizardControllerKioskFlowTest() {}
 770
 771   // Overridden from InProcessBrowserTest:
 772   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
 773     base::FilePath test_data_dir;
 774     ASSERT_TRUE(chromeos::test_utils::GetTestDataPath(
 775                     "app_mode", "kiosk_manifest", &test_data_dir));
 776     command_line->AppendSwitchPath(
 777         switches::kAppOemManifestFile,
 778         test_data_dir.AppendASCII("kiosk_manifest.json"));
 779   }
 780
 781  private:
 782   DISALLOW_COPY_AND_ASSIGN(WizardControllerKioskFlowTest);
 783 };
 784
 785 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
 786                        ControlFlowKioskForcedEnrollment) {
 787   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 788               SetParameters(mock_enrollment_screen_,
 789                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
 790                             ""))
 791       .Times(1);
 792
 793   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 794   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 795             WizardController::default_controller()->current_screen());
 796   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 797   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 798   OnExit(ScreenObserver::NETWORK_CONNECTED);
 799
 800   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 801             WizardController::default_controller()->current_screen());
 802   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 803   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 804   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 805   OnExit(ScreenObserver::EULA_ACCEPTED);
 806   // Let update screen smooth time process (time = 0ms).
 807   content::RunAllPendingInMessageLoop();
 808
 809   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 810             WizardController::default_controller()->current_screen());
 811   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 812   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 813   OnExit(ScreenObserver::UPDATE_INSTALLED);
 814
 815   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 816
 817   // Make sure enterprise enrollment page shows up right after update screen.
 818   EnrollmentScreen* screen =
 819       WizardController::default_controller()->GetEnrollmentScreen();
 820   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 821   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_COMPLETED);
 822
 823   EXPECT_TRUE(StartupUtils::IsOobeCompleted());
 824 }
 825
 826
 827 IN_PROC_BROWSER_TEST_F(WizardControllerKioskFlowTest,
 828                        ControlFlowEnrollmentBack) {
 829
 830   EXPECT_CALL(*mock_enrollment_screen_->actor(),
 831               SetParameters(mock_enrollment_screen_,
 832                             EnrollmentScreenActor::ENROLLMENT_MODE_FORCED,
 833                             ""))
 834       .Times(1);
 835
 836   EXPECT_TRUE(ExistingUserController::current_controller() == NULL);
 837   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 838             WizardController::default_controller()->current_screen());
 839   EXPECT_CALL(*mock_network_screen_, Show()).Times(1);
 840   EXPECT_CALL(*mock_network_screen_, Hide()).Times(1);
 841   EXPECT_CALL(*mock_eula_screen_, Show()).Times(1);
 842   OnExit(ScreenObserver::NETWORK_CONNECTED);
 843
 844   EXPECT_EQ(WizardController::default_controller()->GetEulaScreen(),
 845             WizardController::default_controller()->current_screen());
 846   EXPECT_CALL(*mock_eula_screen_, Hide()).Times(1);
 847   EXPECT_CALL(*mock_update_screen_, StartNetworkCheck()).Times(1);
 848   EXPECT_CALL(*mock_update_screen_, Show()).Times(1);
 849   OnExit(ScreenObserver::EULA_ACCEPTED);
 850   // Let update screen smooth time process (time = 0ms).
 851   content::RunAllPendingInMessageLoop();
 852
 853   EXPECT_EQ(WizardController::default_controller()->GetUpdateScreen(),
 854             WizardController::default_controller()->current_screen());
 855   EXPECT_CALL(*mock_update_screen_, Hide()).Times(1);
 856   EXPECT_CALL(*mock_enrollment_screen_, Show()).Times(1);
 857   EXPECT_CALL(*mock_enrollment_screen_, Hide()).Times(1);
 858   OnExit(ScreenObserver::UPDATE_INSTALLED);
 859
 860   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 861
 862   // Make sure enterprise enrollment page shows up right after update screen.
 863   EnrollmentScreen* screen =
 864       WizardController::default_controller()->GetEnrollmentScreen();
 865   EXPECT_EQ(screen, WizardController::default_controller()->current_screen());
 866   OnExit(ScreenObserver::ENTERPRISE_ENROLLMENT_BACK);
 867
 868   EXPECT_EQ(WizardController::default_controller()->GetNetworkScreen(),
 869             WizardController::default_controller()->current_screen());
 870   EXPECT_FALSE(StartupUtils::IsOobeCompleted());
 871 }
 872
 873 // TODO(dzhioev): Add test emaulating device with wrong HWID.
 874
 875 // TODO(nkostylev): Add test for WebUI accelerators http://crosbug.com/22571
 876
 877 // TODO(merkulova): Add tests for bluetooth HID detection screen variations when
 878 // UI and logic is ready. http://crbug.com/127016
 879
 880 COMPILE_ASSERT(ScreenObserver::EXIT_CODES_COUNT == 21,
 881                add_tests_for_new_control_flow_you_just_introduced);
 882
 883 }  // namespace chromeos