chrome/browser/chromeos/login/network_screen_browsertest.cc

   1 // Copyright (c) 2011 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/memory/scoped_ptr.h"
   8 #include "base/message_loop.h"
   9 #include "base/string16.h"
  10 #include "base/string_number_conversions.h"
  11 #include "base/utf_string_conversions.h"
  12 #include "chrome/browser/chromeos/cros/cros_library.h"
  13 #include "chrome/browser/chromeos/cros/mock_login_library.h"
  14 #include "chrome/browser/chromeos/cros/mock_network_library.h"
  15 #include "chrome/browser/chromeos/cros/network_library.h"
  16 #include "chrome/browser/chromeos/login/mock_screen_observer.h"
  17 #include "chrome/browser/chromeos/login/network_screen.h"
  18 #include "chrome/browser/chromeos/login/network_selection_view.h"
  19 #include "chrome/browser/chromeos/login/view_screen.h"
  20 #include "chrome/browser/chromeos/login/wizard_controller.h"
  21 #include "chrome/browser/chromeos/login/wizard_in_process_browser_test.h"
  22 #include "chrome/browser/chromeos/login/wizard_screen.h"
  23 #include "chrome/test/ui_test_utils.h"
  24 #include "grit/generated_resources.h"
  25 #include "testing/gmock/include/gmock/gmock.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27 #include "ui/base/l10n/l10n_util.h"
  28 #include "views/controls/button/text_button.h"
  29
  30 namespace chromeos {
  31 using ::testing::AnyNumber;
  32 using ::testing::InvokeWithoutArgs;
  33 using ::testing::Return;
  34 using ::testing::ReturnRef;
  35 using ::testing::_;
  36 using ::testing::A;
  37 using views::Button;
  38
  39 class DummyButtonListener : public views::ButtonListener {
  40  public:
  41   virtual void ButtonPressed(views::Button* sender,
  42                              const views::Event& event) {}
  43 };
  44
  45 class NetworkScreenTest : public WizardInProcessBrowserTest {
  46  public:
  47   NetworkScreenTest(): WizardInProcessBrowserTest("network"),
  48                        mock_login_library_(NULL),
  49                        mock_network_library_(NULL) {
  50   }
  51
  52  protected:
  53   virtual void SetUpInProcessBrowserTestFixture() {
  54     cros_mock_->InitStatusAreaMocks();
  55     mock_network_library_ = cros_mock_->mock_network_library();
  56     mock_login_library_ = new MockLoginLibrary();
  57     cellular_.reset(new NetworkDevice("cellular"));
  58     cros_mock_->test_api()->SetLoginLibrary(mock_login_library_, true);
  59     EXPECT_CALL(*mock_login_library_, EmitLoginPromptReady())
  60         .Times(1);
  61     EXPECT_CALL(*mock_login_library_,RequestRetrievePolicy(_,_))
  62         .Times(AnyNumber());
  63
  64     // Minimal set of expectations needed on NetworkScreen initialization.
  65     // Status bar expectations are defined with RetiresOnSaturation() so
  66     // these mocks will be active once status bar is initialized.
  67     EXPECT_CALL(*mock_network_library_, ethernet_connected())
  68         .Times(2)
  69         .WillRepeatedly(Return(false));
  70     EXPECT_CALL(*mock_network_library_, ethernet_connecting())
  71         .Times(2)
  72         .WillRepeatedly(Return(false));
  73     EXPECT_CALL(*mock_network_library_, wifi_connected())
  74         .Times(1)
  75         .WillRepeatedly(Return(false));
  76     EXPECT_CALL(*mock_network_library_, cellular_connected())
  77         .Times(1)
  78         .WillRepeatedly(Return(false));
  79
  80     cros_mock_->SetStatusAreaMocksExpectations();
  81
  82     // Override these return values, but do not set specific expectation:
  83     EXPECT_CALL(*mock_network_library_, wifi_available())
  84         .Times(AnyNumber())
  85         .WillRepeatedly((Return(true)));
  86     EXPECT_CALL(*mock_network_library_, wifi_enabled())
  87         .Times(AnyNumber())
  88         .WillRepeatedly((Return(true)));
  89     EXPECT_CALL(*mock_network_library_, wifi_connecting())
  90         .Times(AnyNumber())
  91         .WillRepeatedly((Return(false)));
  92     EXPECT_CALL(*mock_network_library_, wifi_scanning())
  93         .Times(AnyNumber())
  94         .WillRepeatedly((Return(false)));
  95     EXPECT_CALL(*mock_network_library_, cellular_available())
  96         .Times(AnyNumber())
  97         .WillRepeatedly((Return(true)));
  98     EXPECT_CALL(*mock_network_library_, cellular_enabled())
  99         .Times(AnyNumber())
 100         .WillRepeatedly((Return(true)));
 101     EXPECT_CALL(*mock_network_library_, cellular_connecting())
 102         .Times(AnyNumber())
 103         .WillRepeatedly((Return(false)));
 104
 105     EXPECT_CALL(*mock_network_library_, FindCellularDevice())
 106         .Times(AnyNumber())
 107         .WillRepeatedly((Return(cellular_.get())));
 108   }
 109
 110   virtual void TearDownInProcessBrowserTestFixture() {
 111     CrosInProcessBrowserTest::TearDownInProcessBrowserTestFixture();
 112     cros_mock_->test_api()->SetLoginLibrary(NULL, false);
 113   }
 114
 115   void EmulateContinueButtonExit(NetworkScreen* network_screen) {
 116     scoped_ptr<MockScreenObserver>
 117         mock_screen_observer(new MockScreenObserver());
 118     EXPECT_CALL(*mock_screen_observer,
 119                 OnExit(ScreenObserver::NETWORK_CONNECTED))
 120         .Times(1);
 121     EXPECT_CALL(*mock_network_library_, Connected())
 122         .WillOnce(Return(true));
 123     controller()->set_observer(mock_screen_observer.get());
 124     DummyButtonListener button_listener;
 125     views::TextButton button(&button_listener, L"Button");
 126     views::MouseEvent event(ui::ET_MOUSE_RELEASED,
 127                             0, 0,
 128                             ui::EF_LEFT_BUTTON_DOWN);
 129     network_screen->ButtonPressed(&button, event);
 130     ui_test_utils::RunAllPendingInMessageLoop();
 131     controller()->set_observer(NULL);
 132   }
 133
 134   MockLoginLibrary* mock_login_library_;
 135   MockNetworkLibrary* mock_network_library_;
 136   scoped_ptr<NetworkDevice> cellular_;
 137
 138  private:
 139   DISALLOW_COPY_AND_ASSIGN(NetworkScreenTest);
 140 };
 141
 142 IN_PROC_BROWSER_TEST_F(NetworkScreenTest, Ethernet) {
 143   ASSERT_TRUE(controller());
 144   NetworkScreen* network_screen = controller()->GetNetworkScreen();
 145   ASSERT_TRUE(network_screen != NULL);
 146   ASSERT_EQ(network_screen, controller()->current_screen());
 147
 148   NetworkSelectionView* network_view = network_screen->view();
 149   ASSERT_TRUE(network_view != NULL);
 150
 151   EXPECT_CALL(*mock_network_library_, ethernet_connected())
 152       .WillOnce((Return(false)));
 153   EXPECT_CALL(*mock_network_library_, wifi_connected())
 154       .WillOnce((Return(false)));
 155   EXPECT_CALL(*mock_network_library_, cellular_connected())
 156       .WillOnce((Return(false)));
 157   EXPECT_CALL(*mock_network_library_, ethernet_connecting())
 158       .WillOnce((Return(true)));
 159   EXPECT_FALSE(network_view->IsContinueEnabled());
 160   network_screen->OnNetworkManagerChanged(mock_network_library_);
 161
 162   EXPECT_CALL(*mock_network_library_, ethernet_connected())
 163       .WillOnce(Return(true));
 164   EXPECT_CALL(*mock_network_library_, Connected())
 165       .Times(3)
 166       .WillRepeatedly(Return(true));
 167   EXPECT_FALSE(network_view->IsContinueEnabled());
 168   EXPECT_FALSE(network_view->IsConnecting());
 169   network_screen->OnNetworkManagerChanged(mock_network_library_);
 170
 171   EXPECT_TRUE(network_view->IsContinueEnabled());
 172   EmulateContinueButtonExit(network_screen);
 173 }
 174
 175 IN_PROC_BROWSER_TEST_F(NetworkScreenTest, Wifi) {
 176   ASSERT_TRUE(controller());
 177   NetworkScreen* network_screen = controller()->GetNetworkScreen();
 178   ASSERT_TRUE(network_screen != NULL);
 179   ASSERT_EQ(network_screen, controller()->current_screen());
 180
 181   NetworkSelectionView* network_view = network_screen->view();
 182   ASSERT_TRUE(network_view != NULL);
 183
 184   EXPECT_CALL(*mock_network_library_, ethernet_connected())
 185       .WillOnce((Return(false)));
 186   EXPECT_CALL(*mock_network_library_, wifi_connected())
 187       .WillOnce((Return(false)));
 188   EXPECT_CALL(*mock_network_library_, cellular_connected())
 189       .WillOnce((Return(false)));
 190   EXPECT_CALL(*mock_network_library_, ethernet_connecting())
 191       .WillOnce((Return(false)));
 192   EXPECT_CALL(*mock_network_library_, wifi_connecting())
 193       .WillOnce((Return(true)));
 194   scoped_ptr<WifiNetwork> wifi(new WifiNetwork("wifi"));
 195   WifiNetworkVector wifi_networks;
 196   wifi_networks.push_back(wifi.get());
 197   EXPECT_CALL(*mock_network_library_, wifi_network())
 198       .WillRepeatedly(Return(wifi.get()));
 199   EXPECT_CALL(*mock_network_library_, wifi_networks())
 200       .WillRepeatedly(ReturnRef(wifi_networks));
 201   EXPECT_FALSE(network_view->IsContinueEnabled());
 202   network_screen->OnNetworkManagerChanged(mock_network_library_);
 203
 204   EXPECT_CALL(*mock_network_library_, ethernet_connected())
 205       .WillOnce(Return(true));
 206   EXPECT_CALL(*mock_network_library_, Connected())
 207         .Times(3)
 208         .WillRepeatedly(Return(true));
 209   EXPECT_FALSE(network_view->IsContinueEnabled());
 210   EXPECT_FALSE(network_view->IsConnecting());
 211   network_screen->OnNetworkManagerChanged(mock_network_library_);
 212
 213   EXPECT_TRUE(network_view->IsContinueEnabled());
 214   EmulateContinueButtonExit(network_screen);
 215 }
 216
 217 IN_PROC_BROWSER_TEST_F(NetworkScreenTest, Cellular) {
 218   ASSERT_TRUE(controller());
 219   NetworkScreen* network_screen = controller()->GetNetworkScreen();
 220   ASSERT_TRUE(network_screen != NULL);
 221   ASSERT_EQ(network_screen, controller()->current_screen());
 222
 223   NetworkSelectionView* network_view = network_screen->view();
 224   ASSERT_TRUE(network_view != NULL);
 225
 226   EXPECT_CALL(*mock_network_library_, ethernet_connected())
 227       .WillOnce((Return(false)));
 228   EXPECT_CALL(*mock_network_library_, wifi_connected())
 229       .WillOnce((Return(false)));
 230   EXPECT_CALL(*mock_network_library_, cellular_connected())
 231       .WillOnce((Return(false)));
 232   EXPECT_CALL(*mock_network_library_, ethernet_connecting())
 233       .WillOnce((Return(false)));
 234   EXPECT_CALL(*mock_network_library_, wifi_connecting())
 235       .WillOnce((Return(false)));
 236   EXPECT_CALL(*mock_network_library_, cellular_connecting())
 237       .WillOnce((Return(true)));
 238   scoped_ptr<CellularNetwork> cellular(new CellularNetwork("cellular"));
 239   EXPECT_CALL(*mock_network_library_, cellular_network())
 240       .WillOnce(Return(cellular.get()));
 241   EXPECT_FALSE(network_view->IsContinueEnabled());
 242   network_screen->OnNetworkManagerChanged(mock_network_library_);
 243
 244   EXPECT_CALL(*mock_network_library_, ethernet_connected())
 245       .WillOnce(Return(true));
 246   EXPECT_CALL(*mock_network_library_, Connected())
 247       .Times(3)
 248       .WillRepeatedly(Return(true));
 249   EXPECT_FALSE(network_view->IsContinueEnabled());
 250   EXPECT_FALSE(network_view->IsConnecting());
 251   network_screen->OnNetworkManagerChanged(mock_network_library_);
 252
 253   EXPECT_TRUE(network_view->IsContinueEnabled());
 254   EmulateContinueButtonExit(network_screen);
 255 }
 256
 257 IN_PROC_BROWSER_TEST_F(NetworkScreenTest, Timeout) {
 258   ASSERT_TRUE(controller());
 259   NetworkScreen* network_screen = controller()->GetNetworkScreen();
 260   ASSERT_TRUE(network_screen != NULL);
 261   ASSERT_EQ(network_screen, controller()->current_screen());
 262
 263   NetworkSelectionView* network_view = network_screen->view();
 264   ASSERT_TRUE(network_view != NULL);
 265
 266   EXPECT_CALL(*mock_network_library_, ethernet_connected())
 267       .WillOnce((Return(false)));
 268   EXPECT_CALL(*mock_network_library_, wifi_connected())
 269       .WillOnce((Return(false)));
 270   EXPECT_CALL(*mock_network_library_, cellular_connected())
 271       .WillOnce((Return(false)));
 272   EXPECT_CALL(*mock_network_library_, ethernet_connecting())
 273       .WillOnce((Return(false)));
 274   EXPECT_CALL(*mock_network_library_, wifi_connecting())
 275       .WillOnce((Return(true)));
 276   scoped_ptr<WifiNetwork> wifi(new WifiNetwork("wifi"));
 277   EXPECT_CALL(*mock_network_library_, wifi_network())
 278       .WillOnce(Return(wifi.get()));
 279   EXPECT_FALSE(network_view->IsContinueEnabled());
 280   network_screen->OnNetworkManagerChanged(mock_network_library_);
 281
 282   EXPECT_CALL(*mock_network_library_, Connected())
 283       .Times(2)
 284       .WillRepeatedly(Return(false));
 285   EXPECT_FALSE(network_view->IsContinueEnabled());
 286   EXPECT_FALSE(network_view->IsConnecting());
 287   network_screen->OnConnectionTimeout();
 288
 289   // Close infobubble with error message - it makes the test stable.
 290   EXPECT_FALSE(network_view->IsContinueEnabled());
 291   EXPECT_FALSE(network_view->IsConnecting());
 292   network_screen->ClearErrors();
 293 }
 294
 295 }  // namespace chromeos