network_screen_browsertest.cc revision 731df977c0511bca2206b5f333555b1205ff1f43 
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_, ethernet_connected())
67        .Times(3)
68        .WillRepeatedly(Return(false));
69    EXPECT_CALL(*mock_network_library_, ethernet_connecting())
70        .Times(1)
71        .WillRepeatedly(Return(false));
72    EXPECT_CALL(*mock_network_library_, wifi_connected())
73        .Times(3)
74        .WillRepeatedly(Return(false));
75    EXPECT_CALL(*mock_network_library_, wifi_connecting())
76        .Times(3)
77        .WillRepeatedly(Return(false));
78    EXPECT_CALL(*mock_network_library_, cellular_connected())
79        .Times(3)
80        .WillRepeatedly(Return(false));
81    EXPECT_CALL(*mock_network_library_, cellular_connecting())
82        .Times(3)
83        .WillRepeatedly(Return(false));
84    EXPECT_CALL(*mock_network_library_, Connected())
85        .Times(3)
86        .WillRepeatedly(Return(false));
87    EXPECT_CALL(*mock_network_library_, Connecting())
88        .Times(2)
89        .WillRepeatedly(Return(false));
90    EXPECT_CALL(*mock_network_library_, AddObserver(_))
91        .Times(2);
92    EXPECT_CALL(*mock_network_library_, RemoveObserver(_))
93        .Times(2);
94
95    cros_mock_->SetStatusAreaMocksExpectations();
96  }
97
98  virtual void TearDownInProcessBrowserTestFixture() {
99    CrosInProcessBrowserTest::TearDownInProcessBrowserTestFixture();
100    cros_mock_->test_api()->SetLoginLibrary(NULL, false);
101  }
102
103  void EmulateContinueButtonExit(NetworkScreen* network_screen) {
104    scoped_ptr<MockScreenObserver>
105        mock_screen_observer(new MockScreenObserver());
106    EXPECT_CALL(*mock_screen_observer,
107                OnExit(ScreenObserver::NETWORK_CONNECTED))
108        .Times(1);
109    EXPECT_CALL(*mock_network_library_, Connected())
110        .WillOnce(Return(true));
111    controller()->set_observer(mock_screen_observer.get());
112    DummyButtonListener button_listener;
113    views::TextButton button(&button_listener, L"Button");
114    views::MouseEvent event(views::Event::ET_MOUSE_RELEASED,
115                            0, 0,
116                            views::Event::EF_LEFT_BUTTON_DOWN);
117    network_screen->ButtonPressed(&button, event);
118    ui_test_utils::RunAllPendingInMessageLoop();
119    controller()->set_observer(NULL);
120  }
121
122  MockLoginLibrary* mock_login_library_;
123  MockNetworkLibrary* mock_network_library_;
124
125 private:
126  DISALLOW_COPY_AND_ASSIGN(NetworkScreenTest);
127};
128
129IN_PROC_BROWSER_TEST_F(NetworkScreenTest, Ethernet) {
130  ASSERT_TRUE(controller());
131  NetworkScreen* network_screen = controller()->GetNetworkScreen();
132  ASSERT_TRUE(network_screen != NULL);
133  ASSERT_EQ(network_screen, controller()->current_screen());
134
135  NetworkSelectionView* network_view = network_screen->view();
136  ASSERT_TRUE(network_view != NULL);
137  EXPECT_FALSE(network_view->IsContinueEnabled());
138
139  EXPECT_CALL(*mock_network_library_, ethernet_connected())
140      .WillOnce((Return(false)));
141  EXPECT_CALL(*mock_network_library_, wifi_connected())
142      .WillOnce((Return(false)));
143  EXPECT_CALL(*mock_network_library_, cellular_connected())
144      .WillOnce((Return(false)));
145  EXPECT_CALL(*mock_network_library_, ethernet_connecting())
146      .WillOnce((Return(true)));
147
148  network_screen->NetworkChanged(mock_network_library_);
149  EXPECT_FALSE(network_view->IsContinueEnabled());
150  EXPECT_FALSE(network_view->IsConnecting());
151
152  EXPECT_CALL(*mock_network_library_, ethernet_connected())
153      .WillOnce(Return(true));
154  EXPECT_CALL(*mock_network_library_, Connected())
155      .WillOnce(Return(true));
156
157  network_screen->NetworkChanged(mock_network_library_);
158  EXPECT_TRUE(network_view->IsContinueEnabled());
159
160  EmulateContinueButtonExit(network_screen);
161}
162
163IN_PROC_BROWSER_TEST_F(NetworkScreenTest, Wifi) {
164  ASSERT_TRUE(controller());
165  NetworkScreen* network_screen = controller()->GetNetworkScreen();
166  ASSERT_TRUE(network_screen != NULL);
167  ASSERT_EQ(network_screen, controller()->current_screen());
168
169  NetworkSelectionView* network_view = network_screen->view();
170  ASSERT_TRUE(network_view != NULL);
171  EXPECT_FALSE(network_view->IsContinueEnabled());
172
173  EXPECT_CALL(*mock_network_library_, ethernet_connected())
174      .WillOnce((Return(false)));
175  EXPECT_CALL(*mock_network_library_, wifi_connected())
176      .WillOnce((Return(false)));
177  EXPECT_CALL(*mock_network_library_, cellular_connected())
178      .WillOnce((Return(false)));
179  EXPECT_CALL(*mock_network_library_, ethernet_connecting())
180      .WillOnce((Return(false)));
181  EXPECT_CALL(*mock_network_library_, wifi_connecting())
182      .WillOnce((Return(true)));
183  WifiNetwork wifi;
184  EXPECT_CALL(*mock_network_library_, wifi_network())
185      .WillOnce(ReturnRef(wifi));
186
187  network_screen->NetworkChanged(mock_network_library_);
188  EXPECT_FALSE(network_view->IsContinueEnabled());
189  EXPECT_FALSE(network_view->IsConnecting());
190
191  EXPECT_CALL(*mock_network_library_, ethernet_connected())
192      .WillOnce(Return(true));
193  EXPECT_CALL(*mock_network_library_, Connected())
194      .WillOnce(Return(true));
195
196  network_screen->NetworkChanged(mock_network_library_);
197  EXPECT_TRUE(network_view->IsContinueEnabled());
198
199  EmulateContinueButtonExit(network_screen);
200}
201
202IN_PROC_BROWSER_TEST_F(NetworkScreenTest, Cellular) {
203  ASSERT_TRUE(controller());
204  NetworkScreen* network_screen = controller()->GetNetworkScreen();
205  ASSERT_TRUE(network_screen != NULL);
206  ASSERT_EQ(network_screen, controller()->current_screen());
207
208  NetworkSelectionView* network_view = network_screen->view();
209  ASSERT_TRUE(network_view != NULL);
210  EXPECT_FALSE(network_view->IsContinueEnabled());
211
212  EXPECT_CALL(*mock_network_library_, ethernet_connected())
213      .WillOnce((Return(false)));
214  EXPECT_CALL(*mock_network_library_, wifi_connected())
215      .WillOnce((Return(false)));
216  EXPECT_CALL(*mock_network_library_, cellular_connected())
217      .WillOnce((Return(false)));
218  EXPECT_CALL(*mock_network_library_, ethernet_connecting())
219      .WillOnce((Return(false)));
220  EXPECT_CALL(*mock_network_library_, wifi_connecting())
221      .WillOnce((Return(false)));
222  EXPECT_CALL(*mock_network_library_, cellular_connecting())
223      .WillOnce((Return(true)));
224  CellularNetwork cellular;
225  EXPECT_CALL(*mock_network_library_, cellular_network())
226      .WillOnce(ReturnRef(cellular));
227
228  network_screen->NetworkChanged(mock_network_library_);
229  EXPECT_FALSE(network_view->IsContinueEnabled());
230  EXPECT_FALSE(network_view->IsConnecting());
231
232  EXPECT_CALL(*mock_network_library_, ethernet_connected())
233      .WillOnce(Return(true));
234  EXPECT_CALL(*mock_network_library_, Connected())
235      .WillOnce(Return(true));
236
237  network_screen->NetworkChanged(mock_network_library_);
238  EXPECT_TRUE(network_view->IsContinueEnabled());
239
240  EmulateContinueButtonExit(network_screen);
241}
242
243IN_PROC_BROWSER_TEST_F(NetworkScreenTest, Timeout) {
244  ASSERT_TRUE(controller());
245  NetworkScreen* network_screen = controller()->GetNetworkScreen();
246  ASSERT_TRUE(network_screen != NULL);
247  ASSERT_EQ(network_screen, controller()->current_screen());
248
249  NetworkSelectionView* network_view = network_screen->view();
250  ASSERT_TRUE(network_view != NULL);
251  EXPECT_FALSE(network_view->IsContinueEnabled());
252
253  EXPECT_CALL(*mock_network_library_, ethernet_connected())
254      .WillOnce((Return(false)));
255  EXPECT_CALL(*mock_network_library_, wifi_connected())
256      .WillOnce((Return(false)));
257  EXPECT_CALL(*mock_network_library_, cellular_connected())
258      .WillOnce((Return(false)));
259  EXPECT_CALL(*mock_network_library_, ethernet_connecting())
260      .WillOnce((Return(false)));
261  EXPECT_CALL(*mock_network_library_, wifi_connecting())
262      .WillOnce((Return(true)));
263  WifiNetwork wifi;
264  EXPECT_CALL(*mock_network_library_, wifi_network())
265      .WillOnce(ReturnRef(wifi));
266  EXPECT_CALL(*mock_network_library_, Connected())
267      .WillOnce(Return(false));
268
269  network_screen->NetworkChanged(mock_network_library_);
270  EXPECT_FALSE(network_view->IsContinueEnabled());
271  EXPECT_FALSE(network_view->IsConnecting());
272
273  network_screen->OnConnectionTimeout();
274  EXPECT_FALSE(network_view->IsContinueEnabled());
275  EXPECT_FALSE(network_view->IsConnecting());
276
277  // Close infobubble with error message - it makes test stable.
278  network_screen->ClearErrors();
279}
280
281}  // namespace chromeos
282