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