network_portal_detector_impl_unittest.cc revision 90dce4d38c5ff5333bea97d859d4e484e27edf0c 
1// Copyright (c) 2013 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/compiler_specific.h"
6#include "base/logging.h"
7#include "base/memory/scoped_ptr.h"
8#include "base/message_loop.h"
9#include "chrome/browser/captive_portal/captive_portal_detector.h"
10#include "chrome/browser/captive_portal/testing_utils.h"
11#include "chrome/browser/chromeos/cros/cros_library.h"
12#include "chrome/browser/chromeos/net/network_portal_detector_impl.h"
13#include "chrome/test/base/testing_profile.h"
14#include "chromeos/dbus/dbus_thread_manager.h"
15#include "chromeos/dbus/shill_device_client.h"
16#include "chromeos/dbus/shill_service_client.h"
17#include "chromeos/network/network_state.h"
18#include "chromeos/network/network_state_handler.h"
19#include "dbus/object_path.h"
20#include "net/base/net_errors.h"
21#include "testing/gtest/include/gtest/gtest.h"
22#include "third_party/cros_system_api/dbus/service_constants.h"
23
24namespace chromeos {
25
26namespace {
27
28void ErrorCallbackFunction(const std::string& error_name,
29                           const std::string& error_message) {
30  LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
31}
32
33}  // namespace
34
35// Service paths for stub network devices.
36const char* kStubEthernet = "stub_ethernet";
37const char* kStubWireless1 = "stub_wifi1";
38const char* kStubWireless2 = "stub_wifi2";
39const char* kStubCellular = "stub_cellular";
40
41class NetworkPortalDetectorImplTest
42    : public testing::Test,
43      public captive_portal::CaptivePortalDetectorTestBase {
44 public:
45  NetworkPortalDetectorImplTest() {}
46  virtual ~NetworkPortalDetectorImplTest() {}
47
48  virtual void SetUp() {
49    DBusThreadManager::InitializeWithStub();
50    SetupNetworkHandler();
51
52    profile_.reset(new TestingProfile());
53    network_portal_detector_.reset(
54        new NetworkPortalDetectorImpl(profile_->GetRequestContext()));
55    network_portal_detector_->Init();
56    network_portal_detector_->Enable(false);
57
58    set_detector(network_portal_detector_->captive_portal_detector_.get());
59
60    // Prevents flakiness due to message loop delays.
61    set_time_ticks(base::TimeTicks::Now());
62  }
63
64  virtual void TearDown() {
65    network_portal_detector_->Shutdown();
66    profile_.reset();
67    NetworkHandler::Shutdown();
68    DBusThreadManager::Shutdown();
69  }
70
71  void CheckPortalState(NetworkPortalDetector::CaptivePortalStatus status,
72                        int response_code,
73                        const std::string& network_service_path) {
74    const NetworkState* network =
75        NetworkHandler::Get()->network_state_handler()->GetNetworkState(
76            network_service_path);
77    NetworkPortalDetector::CaptivePortalState state =
78        network_portal_detector()->GetCaptivePortalState(network);
79    ASSERT_EQ(status, state.status);
80    ASSERT_EQ(response_code, state.response_code);
81  }
82
83  void CheckRequestTimeoutAndCompleteAttempt(
84      int expected_attempt_count,
85      int expected_request_timeout_sec,
86      int net_error,
87      int status_code) {
88    ASSERT_TRUE(is_state_checking_for_portal());
89    ASSERT_EQ(expected_attempt_count, attempt_count());
90    ASSERT_EQ(expected_request_timeout_sec, get_request_timeout_sec());
91    CompleteURLFetch(net_error, status_code, NULL);
92  }
93
94  Profile* profile() { return profile_.get(); }
95
96  NetworkPortalDetectorImpl* network_portal_detector() {
97    return network_portal_detector_.get();
98  }
99
100  NetworkPortalDetectorImpl::State state() {
101    return network_portal_detector()->state();
102  }
103
104  bool start_detection_if_idle() {
105    return network_portal_detector()->StartDetectionIfIdle();
106  }
107
108  void enable_lazy_detection() {
109    network_portal_detector()->EnableLazyDetection();
110  }
111
112  void disable_lazy_detection() {
113    network_portal_detector()->DisableLazyDetection();
114  }
115
116  void cancel_portal_detection() {
117    network_portal_detector()->CancelPortalDetection();
118  }
119
120  bool detection_timeout_is_cancelled() {
121    return
122        network_portal_detector()->DetectionTimeoutIsCancelledForTesting();
123  }
124
125  int get_request_timeout_sec() {
126    return network_portal_detector()->GetRequestTimeoutSec();
127  }
128
129  bool is_state_idle() {
130    return (NetworkPortalDetectorImpl::STATE_IDLE == state());
131  }
132
133  bool is_state_portal_detection_pending() {
134    return (NetworkPortalDetectorImpl::STATE_PORTAL_CHECK_PENDING == state());
135  }
136
137  bool is_state_checking_for_portal() {
138    return (NetworkPortalDetectorImpl::STATE_CHECKING_FOR_PORTAL == state());
139  }
140
141  void set_request_timeout(const base::TimeDelta& timeout) {
142    network_portal_detector()->set_request_timeout_for_testing(timeout);
143  }
144
145  const base::TimeDelta& next_attempt_delay() {
146    return network_portal_detector()->next_attempt_delay_for_testing();
147  }
148
149  int attempt_count() {
150    return network_portal_detector()->attempt_count_for_testing();
151  }
152
153  void set_min_time_between_attempts(const base::TimeDelta& delta) {
154    network_portal_detector()->set_min_time_between_attempts_for_testing(delta);
155  }
156
157  void set_lazy_check_interval(const base::TimeDelta& delta) {
158    network_portal_detector()->set_lazy_check_interval_for_testing(delta);
159  }
160
161  void set_time_ticks(const base::TimeTicks& time_ticks) {
162    network_portal_detector()->set_time_ticks_for_testing(time_ticks);
163  }
164
165  void SetBehindPortal(const std::string& service_path) {
166    DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
167        dbus::ObjectPath(service_path),
168        flimflam::kStateProperty, base::StringValue(flimflam::kStatePortal),
169        base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
170    base::MessageLoop::current()->RunUntilIdle();
171  }
172
173  void SetNetworkDeviceEnabled(const std::string& type, bool enabled) {
174    NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
175        type, enabled, network_handler::ErrorCallback());
176    base::MessageLoop::current()->RunUntilIdle();
177  }
178
179  void SetConnected(const std::string& service_path) {
180    DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
181        dbus::ObjectPath(service_path),
182        flimflam::kStateProperty, base::StringValue(flimflam::kStateOnline),
183        base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
184    base::MessageLoop::current()->RunUntilIdle();
185  }
186
187 private:
188  void SetupDefaultShillState() {
189    base::MessageLoop::current()->RunUntilIdle();
190    ShillServiceClient::TestInterface* service_test =
191        DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
192    service_test->ClearServices();
193    const bool add_to_watchlist = true;
194    service_test->AddService(kStubEthernet,
195                             kStubEthernet,
196                             flimflam::kTypeEthernet, flimflam::kStateIdle,
197                             add_to_watchlist);
198    service_test->AddService(kStubWireless1,
199                             kStubWireless1,
200                             flimflam::kTypeWifi, flimflam::kStateIdle,
201                             add_to_watchlist);
202    service_test->AddService(kStubWireless2,
203                             kStubWireless2,
204                             flimflam::kTypeWifi, flimflam::kStateIdle,
205                             add_to_watchlist);
206    service_test->AddService(kStubCellular,
207                             kStubCellular,
208                             flimflam::kTypeCellular, flimflam::kStateIdle,
209                             add_to_watchlist);
210  }
211
212  void SetupNetworkHandler() {
213    SetupDefaultShillState();
214    NetworkHandler::Initialize();
215  }
216
217  base::MessageLoop message_loop_;
218  scoped_ptr<TestingProfile> profile_;
219  scoped_ptr<NetworkPortalDetectorImpl> network_portal_detector_;
220};
221
222TEST_F(NetworkPortalDetectorImplTest, NoPortal) {
223  ASSERT_TRUE(is_state_idle());
224
225  SetConnected(kStubWireless1);
226
227  ASSERT_TRUE(is_state_checking_for_portal());
228  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
229                   kStubWireless1);
230
231  CompleteURLFetch(net::OK, 204, NULL);
232
233  ASSERT_TRUE(is_state_idle());
234  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
235                   kStubWireless1);
236}
237
238TEST_F(NetworkPortalDetectorImplTest, Portal) {
239  ASSERT_TRUE(is_state_idle());
240
241  // Check HTTP 200 response code.
242  SetConnected(kStubWireless1);
243  ASSERT_TRUE(is_state_checking_for_portal());
244
245  CompleteURLFetch(net::OK, 200, NULL);
246
247  ASSERT_TRUE(is_state_idle());
248  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
249                   kStubWireless1);
250
251  // Check HTTP 301 response code.
252  SetConnected(kStubWireless2);
253  ASSERT_TRUE(is_state_checking_for_portal());
254
255  CompleteURLFetch(net::OK, 301, NULL);
256
257  ASSERT_TRUE(is_state_idle());
258  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 301,
259                   kStubWireless2);
260
261  // Check HTTP 302 response code.
262  SetConnected(kStubEthernet);
263  ASSERT_TRUE(is_state_checking_for_portal());
264
265  CompleteURLFetch(net::OK, 302, NULL);
266
267  ASSERT_TRUE(is_state_idle());
268  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 302,
269                   kStubEthernet);
270}
271
272TEST_F(NetworkPortalDetectorImplTest, TwoNetworks) {
273  ASSERT_TRUE(is_state_idle());
274
275  SetConnected(kStubWireless1);
276  ASSERT_TRUE(is_state_checking_for_portal());
277
278  // wifi is in portal state.
279  CompleteURLFetch(net::OK, 200, NULL);
280  ASSERT_TRUE(is_state_idle());
281
282  SetConnected(kStubEthernet);
283  ASSERT_TRUE(is_state_checking_for_portal());
284
285  // ethernet is in online state.
286  CompleteURLFetch(net::OK, 204, NULL);
287  ASSERT_TRUE(is_state_idle());
288  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
289                   kStubEthernet);
290  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
291                   kStubWireless1);
292}
293
294TEST_F(NetworkPortalDetectorImplTest, NetworkChanged) {
295  ASSERT_TRUE(is_state_idle());
296
297  SetConnected(kStubWireless1);
298
299  // WiFi is in portal state.
300  fetcher()->set_response_code(200);
301  ASSERT_TRUE(is_state_checking_for_portal());
302
303  // Active network is changed during portal detection for wifi.
304  SetConnected(kStubEthernet);
305
306  // Portal detection for wifi is cancelled, portal detection for
307  // ethernet is initiated.
308  ASSERT_TRUE(is_state_checking_for_portal());
309
310  // ethernet is in online state.
311  CompleteURLFetch(net::OK, 204, NULL);
312  ASSERT_TRUE(is_state_idle());
313  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
314                   kStubEthernet);
315
316  // As active network was changed during portal detection for wifi
317  // network, it's state must be unknown.
318  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
319                   kStubWireless1);
320}
321
322TEST_F(NetworkPortalDetectorImplTest, NetworkStateNotChanged) {
323  ASSERT_TRUE(is_state_idle());
324
325  SetConnected(kStubWireless1);
326  ASSERT_TRUE(is_state_checking_for_portal());
327
328  CompleteURLFetch(net::OK, 204, NULL);
329
330  ASSERT_TRUE(is_state_idle());
331  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
332                   kStubWireless1);
333
334  SetConnected(kStubWireless1);
335  ASSERT_TRUE(is_state_idle());
336}
337
338TEST_F(NetworkPortalDetectorImplTest, NetworkStateChanged) {
339  // Test for Portal -> Online -> Portal network state transitions.
340  ASSERT_TRUE(is_state_idle());
341
342  SetBehindPortal(kStubWireless1);
343  ASSERT_TRUE(is_state_checking_for_portal());
344
345  CompleteURLFetch(net::OK, 200, NULL);
346
347  ASSERT_TRUE(is_state_idle());
348  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
349                   kStubWireless1);
350
351  SetConnected(kStubWireless1);
352  ASSERT_TRUE(is_state_checking_for_portal());
353
354  CompleteURLFetch(net::OK, 204, NULL);
355
356  ASSERT_TRUE(is_state_idle());
357  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
358                   kStubWireless1);
359
360  SetBehindPortal(kStubWireless1);
361  ASSERT_TRUE(is_state_checking_for_portal());
362
363  CompleteURLFetch(net::OK, 200, NULL);
364
365  ASSERT_TRUE(is_state_idle());
366  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
367                   kStubWireless1);
368}
369
370TEST_F(NetworkPortalDetectorImplTest, PortalDetectionTimeout) {
371  ASSERT_TRUE(is_state_idle());
372
373  // For instantaneous timeout.
374  set_request_timeout(base::TimeDelta::FromSeconds(0));
375
376  ASSERT_TRUE(is_state_idle());
377  ASSERT_EQ(0, attempt_count());
378
379  SetConnected(kStubWireless1);
380  base::MessageLoop::current()->RunUntilIdle();
381
382  // First portal detection timeouts, next portal detection is
383  // scheduled.
384  ASSERT_TRUE(is_state_portal_detection_pending());
385  ASSERT_EQ(1, attempt_count());
386  ASSERT_EQ(base::TimeDelta::FromSeconds(3), next_attempt_delay());
387}
388
389TEST_F(NetworkPortalDetectorImplTest, PortalDetectionRetryAfter) {
390  ASSERT_TRUE(is_state_idle());
391
392  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 101\n\n";
393
394  ASSERT_TRUE(is_state_idle());
395  ASSERT_EQ(0, attempt_count());
396
397  SetConnected(kStubWireless1);
398  CompleteURLFetch(net::OK, 503, retry_after);
399
400  // First portal detection completed, next portal detection is
401  // scheduled after 101 seconds.
402  ASSERT_TRUE(is_state_portal_detection_pending());
403  ASSERT_EQ(1, attempt_count());
404  ASSERT_EQ(base::TimeDelta::FromSeconds(101), next_attempt_delay());
405}
406
407TEST_F(NetworkPortalDetectorImplTest, PortalDetectorRetryAfterIsSmall) {
408  ASSERT_TRUE(is_state_idle());
409
410  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 1\n\n";
411
412  ASSERT_TRUE(is_state_idle());
413  ASSERT_EQ(0, attempt_count());
414
415  SetConnected(kStubWireless1);
416  CompleteURLFetch(net::OK, 503, retry_after);
417
418  // First portal detection completed, next portal detection is
419  // scheduled after 3 seconds (due to minimum time between detection
420  // attemps).
421  ASSERT_TRUE(is_state_portal_detection_pending());
422  ASSERT_EQ(1, attempt_count());
423  ASSERT_EQ(base::TimeDelta::FromSeconds(3), next_attempt_delay());
424}
425
426TEST_F(NetworkPortalDetectorImplTest, FirstAttemptFailed) {
427  ASSERT_TRUE(is_state_idle());
428
429  set_min_time_between_attempts(base::TimeDelta());
430  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 0\n\n";
431
432  ASSERT_TRUE(is_state_idle());
433  ASSERT_EQ(0, attempt_count());
434
435  SetConnected(kStubWireless1);
436
437  CompleteURLFetch(net::OK, 503, retry_after);
438  ASSERT_TRUE(is_state_portal_detection_pending());
439  ASSERT_EQ(1, attempt_count());
440  ASSERT_EQ(base::TimeDelta::FromSeconds(0), next_attempt_delay());
441
442  // To run CaptivePortalDetector::DetectCaptivePortal().
443  base::MessageLoop::current()->RunUntilIdle();
444
445  CompleteURLFetch(net::OK, 204, NULL);
446  ASSERT_TRUE(is_state_idle());
447  ASSERT_EQ(2, attempt_count());
448  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
449                   kStubWireless1);
450}
451
452TEST_F(NetworkPortalDetectorImplTest, AllAttemptsFailed) {
453  ASSERT_TRUE(is_state_idle());
454
455  set_min_time_between_attempts(base::TimeDelta());
456  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 0\n\n";
457
458  ASSERT_TRUE(is_state_idle());
459  ASSERT_EQ(0, attempt_count());
460
461  SetConnected(kStubWireless1);
462
463  CompleteURLFetch(net::OK, 503, retry_after);
464  ASSERT_TRUE(is_state_portal_detection_pending());
465  ASSERT_EQ(1, attempt_count());
466  ASSERT_EQ(base::TimeDelta::FromSeconds(0), next_attempt_delay());
467
468  // To run CaptivePortalDetector::DetectCaptivePortal().
469  base::MessageLoop::current()->RunUntilIdle();
470
471  CompleteURLFetch(net::OK, 503, retry_after);
472  ASSERT_TRUE(is_state_portal_detection_pending());
473  ASSERT_EQ(2, attempt_count());
474  ASSERT_EQ(base::TimeDelta::FromSeconds(0), next_attempt_delay());
475
476  // To run CaptivePortalDetector::DetectCaptivePortal().
477  base::MessageLoop::current()->RunUntilIdle();
478
479  CompleteURLFetch(net::OK, 503, retry_after);
480  ASSERT_TRUE(is_state_idle());
481  ASSERT_EQ(3, attempt_count());
482  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE, 503,
483                   kStubWireless1);
484}
485
486TEST_F(NetworkPortalDetectorImplTest, ProxyAuthRequired) {
487  ASSERT_TRUE(is_state_idle());
488  set_min_time_between_attempts(base::TimeDelta());
489
490  SetConnected(kStubWireless1);
491  CompleteURLFetch(net::OK, 407, NULL);
492  ASSERT_EQ(1, attempt_count());
493  ASSERT_TRUE(is_state_portal_detection_pending());
494  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
495                   kStubWireless1);
496
497  // To run CaptivePortalDetector::DetectCaptivePortal().
498  base::MessageLoop::current()->RunUntilIdle();
499
500  CompleteURLFetch(net::OK, 407, NULL);
501  ASSERT_EQ(2, attempt_count());
502  ASSERT_TRUE(is_state_portal_detection_pending());
503  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
504                   kStubWireless1);
505
506  // To run CaptivePortalDetector::DetectCaptivePortal().
507  base::MessageLoop::current()->RunUntilIdle();
508
509  CompleteURLFetch(net::OK, 407, NULL);
510  ASSERT_EQ(3, attempt_count());
511  ASSERT_TRUE(is_state_idle());
512  CheckPortalState(
513      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED, 407,
514      kStubWireless1);
515}
516
517TEST_F(NetworkPortalDetectorImplTest, NoResponseButBehindPortal) {
518  ASSERT_TRUE(is_state_idle());
519  set_min_time_between_attempts(base::TimeDelta());
520
521  SetBehindPortal(kStubWireless1);
522  ASSERT_TRUE(is_state_checking_for_portal());
523
524  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
525                   net::URLFetcher::RESPONSE_CODE_INVALID,
526                   NULL);
527  ASSERT_EQ(1, attempt_count());
528  ASSERT_TRUE(is_state_portal_detection_pending());
529
530  // To run CaptivePortalDetector::DetectCaptivePortal().
531  base::MessageLoop::current()->RunUntilIdle();
532
533  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
534                   net::URLFetcher::RESPONSE_CODE_INVALID,
535                   NULL);
536  ASSERT_EQ(2, attempt_count());
537  ASSERT_TRUE(is_state_portal_detection_pending());
538
539  // To run CaptivePortalDetector::DetectCaptivePortal().
540  base::MessageLoop::current()->RunUntilIdle();
541
542  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
543                   net::URLFetcher::RESPONSE_CODE_INVALID,
544                   NULL);
545  ASSERT_EQ(3, attempt_count());
546  ASSERT_TRUE(is_state_idle());
547
548  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL,
549                   net::URLFetcher::RESPONSE_CODE_INVALID,
550                   kStubWireless1);
551}
552
553TEST_F(NetworkPortalDetectorImplTest, LazyDetectionForOnlineNetwork) {
554  ASSERT_TRUE(is_state_idle());
555  set_min_time_between_attempts(base::TimeDelta());
556  set_lazy_check_interval(base::TimeDelta());
557
558  SetConnected(kStubWireless1);
559  enable_lazy_detection();
560  CompleteURLFetch(net::OK, 204, NULL);
561
562  ASSERT_EQ(1, attempt_count());
563  ASSERT_TRUE(is_state_portal_detection_pending());
564  CheckPortalState(
565      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
566      kStubWireless1);
567
568  // To run CaptivePortalDetector::DetectCaptivePortal().
569  base::MessageLoop::current()->RunUntilIdle();
570
571  CompleteURLFetch(net::OK, 204, NULL);
572
573  ASSERT_EQ(2, attempt_count());
574  ASSERT_TRUE(is_state_portal_detection_pending());
575  CheckPortalState(
576      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
577      kStubWireless1);
578
579  // To run CaptivePortalDetector::DetectCaptivePortal().
580  base::MessageLoop::current()->RunUntilIdle();
581
582  disable_lazy_detection();
583
584  // One more detection result, because DizableLazyDetection() doesn't
585  // cancel last detection request.
586  CompleteURLFetch(net::OK, 204, NULL);
587  ASSERT_EQ(3, attempt_count());
588  ASSERT_TRUE(is_state_idle());
589  CheckPortalState(
590      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
591      kStubWireless1);
592}
593
594TEST_F(NetworkPortalDetectorImplTest, LazyDetectionForPortalNetwork) {
595  ASSERT_TRUE(is_state_idle());
596  set_min_time_between_attempts(base::TimeDelta());
597  set_lazy_check_interval(base::TimeDelta());
598
599  SetConnected(kStubWireless1);
600  enable_lazy_detection();
601
602  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
603                   net::URLFetcher::RESPONSE_CODE_INVALID,
604                   NULL);
605  ASSERT_EQ(1, attempt_count());
606  ASSERT_TRUE(is_state_portal_detection_pending());
607  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
608                   kStubWireless1);
609
610  // To run CaptivePortalDetector::DetectCaptivePortal().
611  base::MessageLoop::current()->RunUntilIdle();
612
613  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
614                   net::URLFetcher::RESPONSE_CODE_INVALID,
615                   NULL);
616  ASSERT_EQ(2, attempt_count());
617  ASSERT_TRUE(is_state_portal_detection_pending());
618  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
619                   kStubWireless1);
620
621  // To run CaptivePortalDetector::DetectCaptivePortal().
622  base::MessageLoop::current()->RunUntilIdle();
623
624  CompleteURLFetch(net::OK, 200, NULL);
625  ASSERT_EQ(3, attempt_count());
626  ASSERT_TRUE(is_state_portal_detection_pending());
627  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
628                   kStubWireless1);
629
630  // To run CaptivePortalDetector::DetectCaptivePortal().
631  base::MessageLoop::current()->RunUntilIdle();
632
633  disable_lazy_detection();
634
635  // One more detection result, because DizableLazyDetection() doesn't
636  // cancel last detection request.
637  CompleteURLFetch(net::OK, 200, NULL);
638  ASSERT_EQ(3, attempt_count());
639  ASSERT_TRUE(is_state_idle());
640  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
641                   kStubWireless1);
642}
643
644TEST_F(NetworkPortalDetectorImplTest, DetectionTimeoutIsCancelled) {
645  ASSERT_TRUE(is_state_idle());
646  set_min_time_between_attempts(base::TimeDelta());
647
648  SetConnected(kStubWireless1);
649  ASSERT_TRUE(is_state_checking_for_portal());
650  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
651                   kStubWireless1);
652
653  cancel_portal_detection();
654
655  ASSERT_TRUE(is_state_idle());
656  ASSERT_TRUE(detection_timeout_is_cancelled());
657  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
658                   kStubWireless1);
659}
660
661TEST_F(NetworkPortalDetectorImplTest, TestDetectionRestart) {
662  ASSERT_TRUE(is_state_idle());
663  set_min_time_between_attempts(base::TimeDelta());
664
665  // First portal detection attempts determines ONLINE state.
666  SetConnected(kStubWireless1);
667  ASSERT_TRUE(is_state_checking_for_portal());
668  ASSERT_FALSE(start_detection_if_idle());
669
670  CompleteURLFetch(net::OK, 204, NULL);
671
672  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
673                   kStubWireless1);
674  ASSERT_TRUE(is_state_idle());
675
676  // First portal detection attempts determines PORTAL state.
677  ASSERT_TRUE(start_detection_if_idle());
678  ASSERT_TRUE(is_state_portal_detection_pending());
679  ASSERT_FALSE(start_detection_if_idle());
680
681  base::MessageLoop::current()->RunUntilIdle();
682  ASSERT_TRUE(is_state_checking_for_portal());
683  CompleteURLFetch(net::OK, 200, NULL);
684
685  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
686                   kStubWireless1);
687  ASSERT_TRUE(is_state_idle());
688}
689
690TEST_F(NetworkPortalDetectorImplTest, RequestTimeouts) {
691  ASSERT_TRUE(is_state_idle());
692  set_min_time_between_attempts(base::TimeDelta());
693  set_lazy_check_interval(base::TimeDelta());
694
695  SetNetworkDeviceEnabled(flimflam::kTypeWifi, false);
696  SetConnected(kStubCellular);
697
698  // First portal detection attempt for cellular1 uses 5sec timeout.
699  CheckRequestTimeoutAndCompleteAttempt(1, 5, net::ERR_CONNECTION_CLOSED,
700                                        net::URLFetcher::RESPONSE_CODE_INVALID);
701
702  // Second portal detection attempt for cellular1 uses 10sec timeout.
703  ASSERT_TRUE(is_state_portal_detection_pending());
704  base::MessageLoop::current()->RunUntilIdle();
705  CheckRequestTimeoutAndCompleteAttempt(2, 10, net::ERR_CONNECTION_CLOSED,
706                                        net::URLFetcher::RESPONSE_CODE_INVALID);
707
708  // Third portal detection attempt for cellular1 uses 15sec timeout.
709  ASSERT_TRUE(is_state_portal_detection_pending());
710  base::MessageLoop::current()->RunUntilIdle();
711  CheckRequestTimeoutAndCompleteAttempt(3, 15, net::ERR_CONNECTION_CLOSED,
712                                        net::URLFetcher::RESPONSE_CODE_INVALID);
713
714  ASSERT_TRUE(is_state_idle());
715
716  // Check that in lazy detection for cellular1 15sec timeout is used.
717  enable_lazy_detection();
718  ASSERT_TRUE(is_state_portal_detection_pending());
719  base::MessageLoop::current()->RunUntilIdle();
720  disable_lazy_detection();
721  CheckRequestTimeoutAndCompleteAttempt(3, 15, net::ERR_CONNECTION_CLOSED,
722                                        net::URLFetcher::RESPONSE_CODE_INVALID);
723  ASSERT_TRUE(is_state_idle());
724
725  SetNetworkDeviceEnabled(flimflam::kTypeWifi, true);
726  SetConnected(kStubWireless1);
727
728  // First portal detection attempt for wifi1 uses 5sec timeout.
729  CheckRequestTimeoutAndCompleteAttempt(1, 5, net::ERR_CONNECTION_CLOSED,
730                                        net::URLFetcher::RESPONSE_CODE_INVALID);
731
732  // Second portal detection attempt for wifi1 also uses 5sec timeout.
733  ASSERT_TRUE(is_state_portal_detection_pending());
734  base::MessageLoop::current()->RunUntilIdle();
735  CheckRequestTimeoutAndCompleteAttempt(2, 10, net::OK, 204);
736  ASSERT_TRUE(is_state_idle());
737
738  // Check that in lazy detection for wifi1 5sec timeout is used.
739  enable_lazy_detection();
740  ASSERT_TRUE(is_state_portal_detection_pending());
741  base::MessageLoop::current()->RunUntilIdle();
742  disable_lazy_detection();
743  CheckRequestTimeoutAndCompleteAttempt(3, 15, net::OK, 204);
744  ASSERT_TRUE(is_state_idle());
745}
746
747TEST_F(NetworkPortalDetectorImplTest, StartDetectionIfIdle) {
748  ASSERT_TRUE(is_state_idle());
749  set_min_time_between_attempts(base::TimeDelta());
750  SetConnected(kStubWireless1);
751
752  // First portal detection attempt for wifi1 uses 5sec timeout.
753  CheckRequestTimeoutAndCompleteAttempt(1, 5, net::ERR_CONNECTION_CLOSED,
754                                        net::URLFetcher::RESPONSE_CODE_INVALID);
755  ASSERT_TRUE(is_state_portal_detection_pending());
756  base::MessageLoop::current()->RunUntilIdle();
757
758  // Second portal detection attempt for wifi1 uses 10sec timeout.
759  CheckRequestTimeoutAndCompleteAttempt(2, 10, net::ERR_CONNECTION_CLOSED,
760                                        net::URLFetcher::RESPONSE_CODE_INVALID);
761  ASSERT_TRUE(is_state_portal_detection_pending());
762  base::MessageLoop::current()->RunUntilIdle();
763
764  // Second portal detection attempt for wifi1 uses 15sec timeout.
765  CheckRequestTimeoutAndCompleteAttempt(3, 15, net::ERR_CONNECTION_CLOSED,
766                                        net::URLFetcher::RESPONSE_CODE_INVALID);
767  ASSERT_TRUE(is_state_idle());
768  start_detection_if_idle();
769
770  ASSERT_TRUE(is_state_portal_detection_pending());
771
772  // First portal detection attempt for wifi1 uses 5sec timeout.
773  base::MessageLoop::current()->RunUntilIdle();
774  CheckRequestTimeoutAndCompleteAttempt(1, 5, net::OK, 204);
775  ASSERT_TRUE(is_state_idle());
776}
777
778}  // namespace chromeos
779