network_portal_detector_impl_unittest.cc revision eb525c5499e34cc9c4b825d6d9e75bb07cc06ace 
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_visible = true;
194    const bool add_to_watchlist = true;
195    service_test->AddService(kStubEthernet,
196                             kStubEthernet,
197                             flimflam::kTypeEthernet, flimflam::kStateIdle,
198                             add_to_visible, add_to_watchlist);
199    service_test->AddService(kStubWireless1,
200                             kStubWireless1,
201                             flimflam::kTypeWifi, flimflam::kStateIdle,
202                             add_to_visible, add_to_watchlist);
203    service_test->AddService(kStubWireless2,
204                             kStubWireless2,
205                             flimflam::kTypeWifi, flimflam::kStateIdle,
206                             add_to_visible, add_to_watchlist);
207    service_test->AddService(kStubCellular,
208                             kStubCellular,
209                             flimflam::kTypeCellular, flimflam::kStateIdle,
210                             add_to_visible, add_to_watchlist);
211  }
212
213  void SetupNetworkHandler() {
214    SetupDefaultShillState();
215    NetworkHandler::Initialize();
216  }
217
218  base::MessageLoop message_loop_;
219  scoped_ptr<TestingProfile> profile_;
220  scoped_ptr<NetworkPortalDetectorImpl> network_portal_detector_;
221};
222
223TEST_F(NetworkPortalDetectorImplTest, NoPortal) {
224  ASSERT_TRUE(is_state_idle());
225
226  SetConnected(kStubWireless1);
227
228  ASSERT_TRUE(is_state_checking_for_portal());
229  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
230                   kStubWireless1);
231
232  CompleteURLFetch(net::OK, 204, NULL);
233
234  ASSERT_TRUE(is_state_idle());
235  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
236                   kStubWireless1);
237}
238
239TEST_F(NetworkPortalDetectorImplTest, Portal) {
240  ASSERT_TRUE(is_state_idle());
241
242  // Check HTTP 200 response code.
243  SetConnected(kStubWireless1);
244  ASSERT_TRUE(is_state_checking_for_portal());
245
246  CompleteURLFetch(net::OK, 200, NULL);
247
248  ASSERT_TRUE(is_state_idle());
249  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
250                   kStubWireless1);
251
252  // Check HTTP 301 response code.
253  SetConnected(kStubWireless2);
254  ASSERT_TRUE(is_state_checking_for_portal());
255
256  CompleteURLFetch(net::OK, 301, NULL);
257
258  ASSERT_TRUE(is_state_idle());
259  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 301,
260                   kStubWireless2);
261
262  // Check HTTP 302 response code.
263  SetConnected(kStubEthernet);
264  ASSERT_TRUE(is_state_checking_for_portal());
265
266  CompleteURLFetch(net::OK, 302, NULL);
267
268  ASSERT_TRUE(is_state_idle());
269  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 302,
270                   kStubEthernet);
271}
272
273TEST_F(NetworkPortalDetectorImplTest, TwoNetworks) {
274  ASSERT_TRUE(is_state_idle());
275
276  SetConnected(kStubWireless1);
277  ASSERT_TRUE(is_state_checking_for_portal());
278
279  // wifi is in portal state.
280  CompleteURLFetch(net::OK, 200, NULL);
281  ASSERT_TRUE(is_state_idle());
282
283  SetConnected(kStubEthernet);
284  ASSERT_TRUE(is_state_checking_for_portal());
285
286  // ethernet is in online state.
287  CompleteURLFetch(net::OK, 204, NULL);
288  ASSERT_TRUE(is_state_idle());
289  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
290                   kStubEthernet);
291  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
292                   kStubWireless1);
293}
294
295TEST_F(NetworkPortalDetectorImplTest, NetworkChanged) {
296  ASSERT_TRUE(is_state_idle());
297
298  SetConnected(kStubWireless1);
299
300  // WiFi is in portal state.
301  fetcher()->set_response_code(200);
302  ASSERT_TRUE(is_state_checking_for_portal());
303
304  // Active network is changed during portal detection for wifi.
305  SetConnected(kStubEthernet);
306
307  // Portal detection for wifi is cancelled, portal detection for
308  // ethernet is initiated.
309  ASSERT_TRUE(is_state_checking_for_portal());
310
311  // ethernet is in online state.
312  CompleteURLFetch(net::OK, 204, NULL);
313  ASSERT_TRUE(is_state_idle());
314  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
315                   kStubEthernet);
316
317  // As active network was changed during portal detection for wifi
318  // network, it's state must be unknown.
319  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
320                   kStubWireless1);
321}
322
323TEST_F(NetworkPortalDetectorImplTest, NetworkStateNotChanged) {
324  ASSERT_TRUE(is_state_idle());
325
326  SetConnected(kStubWireless1);
327  ASSERT_TRUE(is_state_checking_for_portal());
328
329  CompleteURLFetch(net::OK, 204, NULL);
330
331  ASSERT_TRUE(is_state_idle());
332  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
333                   kStubWireless1);
334
335  SetConnected(kStubWireless1);
336  ASSERT_TRUE(is_state_idle());
337}
338
339TEST_F(NetworkPortalDetectorImplTest, NetworkStateChanged) {
340  // Test for Portal -> Online -> Portal network state transitions.
341  ASSERT_TRUE(is_state_idle());
342
343  SetBehindPortal(kStubWireless1);
344  ASSERT_TRUE(is_state_checking_for_portal());
345
346  CompleteURLFetch(net::OK, 200, NULL);
347
348  ASSERT_TRUE(is_state_idle());
349  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
350                   kStubWireless1);
351
352  SetConnected(kStubWireless1);
353  ASSERT_TRUE(is_state_checking_for_portal());
354
355  CompleteURLFetch(net::OK, 204, NULL);
356
357  ASSERT_TRUE(is_state_idle());
358  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
359                   kStubWireless1);
360
361  SetBehindPortal(kStubWireless1);
362  ASSERT_TRUE(is_state_checking_for_portal());
363
364  CompleteURLFetch(net::OK, 200, NULL);
365
366  ASSERT_TRUE(is_state_idle());
367  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
368                   kStubWireless1);
369}
370
371TEST_F(NetworkPortalDetectorImplTest, PortalDetectionTimeout) {
372  ASSERT_TRUE(is_state_idle());
373
374  // For instantaneous timeout.
375  set_request_timeout(base::TimeDelta::FromSeconds(0));
376
377  ASSERT_TRUE(is_state_idle());
378  ASSERT_EQ(0, attempt_count());
379
380  SetConnected(kStubWireless1);
381  base::MessageLoop::current()->RunUntilIdle();
382
383  // First portal detection timeouts, next portal detection is
384  // scheduled.
385  ASSERT_TRUE(is_state_portal_detection_pending());
386  ASSERT_EQ(1, attempt_count());
387  ASSERT_EQ(base::TimeDelta::FromSeconds(3), next_attempt_delay());
388}
389
390TEST_F(NetworkPortalDetectorImplTest, PortalDetectionRetryAfter) {
391  ASSERT_TRUE(is_state_idle());
392
393  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 101\n\n";
394
395  ASSERT_TRUE(is_state_idle());
396  ASSERT_EQ(0, attempt_count());
397
398  SetConnected(kStubWireless1);
399  CompleteURLFetch(net::OK, 503, retry_after);
400
401  // First portal detection completed, next portal detection is
402  // scheduled after 101 seconds.
403  ASSERT_TRUE(is_state_portal_detection_pending());
404  ASSERT_EQ(1, attempt_count());
405  ASSERT_EQ(base::TimeDelta::FromSeconds(101), next_attempt_delay());
406}
407
408TEST_F(NetworkPortalDetectorImplTest, PortalDetectorRetryAfterIsSmall) {
409  ASSERT_TRUE(is_state_idle());
410
411  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 1\n\n";
412
413  ASSERT_TRUE(is_state_idle());
414  ASSERT_EQ(0, attempt_count());
415
416  SetConnected(kStubWireless1);
417  CompleteURLFetch(net::OK, 503, retry_after);
418
419  // First portal detection completed, next portal detection is
420  // scheduled after 3 seconds (due to minimum time between detection
421  // attemps).
422  ASSERT_TRUE(is_state_portal_detection_pending());
423  ASSERT_EQ(1, attempt_count());
424  ASSERT_EQ(base::TimeDelta::FromSeconds(3), next_attempt_delay());
425}
426
427TEST_F(NetworkPortalDetectorImplTest, FirstAttemptFailed) {
428  ASSERT_TRUE(is_state_idle());
429
430  set_min_time_between_attempts(base::TimeDelta());
431  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 0\n\n";
432
433  ASSERT_TRUE(is_state_idle());
434  ASSERT_EQ(0, attempt_count());
435
436  SetConnected(kStubWireless1);
437
438  CompleteURLFetch(net::OK, 503, retry_after);
439  ASSERT_TRUE(is_state_portal_detection_pending());
440  ASSERT_EQ(1, attempt_count());
441  ASSERT_EQ(base::TimeDelta::FromSeconds(0), next_attempt_delay());
442
443  // To run CaptivePortalDetector::DetectCaptivePortal().
444  base::MessageLoop::current()->RunUntilIdle();
445
446  CompleteURLFetch(net::OK, 204, NULL);
447  ASSERT_TRUE(is_state_idle());
448  ASSERT_EQ(2, attempt_count());
449  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
450                   kStubWireless1);
451}
452
453TEST_F(NetworkPortalDetectorImplTest, AllAttemptsFailed) {
454  ASSERT_TRUE(is_state_idle());
455
456  set_min_time_between_attempts(base::TimeDelta());
457  const char* retry_after = "HTTP/1.1 503 OK\nRetry-After: 0\n\n";
458
459  ASSERT_TRUE(is_state_idle());
460  ASSERT_EQ(0, attempt_count());
461
462  SetConnected(kStubWireless1);
463
464  CompleteURLFetch(net::OK, 503, retry_after);
465  ASSERT_TRUE(is_state_portal_detection_pending());
466  ASSERT_EQ(1, attempt_count());
467  ASSERT_EQ(base::TimeDelta::FromSeconds(0), next_attempt_delay());
468
469  // To run CaptivePortalDetector::DetectCaptivePortal().
470  base::MessageLoop::current()->RunUntilIdle();
471
472  CompleteURLFetch(net::OK, 503, retry_after);
473  ASSERT_TRUE(is_state_portal_detection_pending());
474  ASSERT_EQ(2, attempt_count());
475  ASSERT_EQ(base::TimeDelta::FromSeconds(0), next_attempt_delay());
476
477  // To run CaptivePortalDetector::DetectCaptivePortal().
478  base::MessageLoop::current()->RunUntilIdle();
479
480  CompleteURLFetch(net::OK, 503, retry_after);
481  ASSERT_TRUE(is_state_idle());
482  ASSERT_EQ(3, attempt_count());
483  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_OFFLINE, 503,
484                   kStubWireless1);
485}
486
487TEST_F(NetworkPortalDetectorImplTest, ProxyAuthRequired) {
488  ASSERT_TRUE(is_state_idle());
489  set_min_time_between_attempts(base::TimeDelta());
490
491  SetConnected(kStubWireless1);
492  CompleteURLFetch(net::OK, 407, NULL);
493  ASSERT_EQ(1, attempt_count());
494  ASSERT_TRUE(is_state_portal_detection_pending());
495  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
496                   kStubWireless1);
497
498  // To run CaptivePortalDetector::DetectCaptivePortal().
499  base::MessageLoop::current()->RunUntilIdle();
500
501  CompleteURLFetch(net::OK, 407, NULL);
502  ASSERT_EQ(2, attempt_count());
503  ASSERT_TRUE(is_state_portal_detection_pending());
504  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
505                   kStubWireless1);
506
507  // To run CaptivePortalDetector::DetectCaptivePortal().
508  base::MessageLoop::current()->RunUntilIdle();
509
510  CompleteURLFetch(net::OK, 407, NULL);
511  ASSERT_EQ(3, attempt_count());
512  ASSERT_TRUE(is_state_idle());
513  CheckPortalState(
514      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PROXY_AUTH_REQUIRED, 407,
515      kStubWireless1);
516}
517
518TEST_F(NetworkPortalDetectorImplTest, NoResponseButBehindPortal) {
519  ASSERT_TRUE(is_state_idle());
520  set_min_time_between_attempts(base::TimeDelta());
521
522  SetBehindPortal(kStubWireless1);
523  ASSERT_TRUE(is_state_checking_for_portal());
524
525  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
526                   net::URLFetcher::RESPONSE_CODE_INVALID,
527                   NULL);
528  ASSERT_EQ(1, attempt_count());
529  ASSERT_TRUE(is_state_portal_detection_pending());
530
531  // To run CaptivePortalDetector::DetectCaptivePortal().
532  base::MessageLoop::current()->RunUntilIdle();
533
534  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
535                   net::URLFetcher::RESPONSE_CODE_INVALID,
536                   NULL);
537  ASSERT_EQ(2, attempt_count());
538  ASSERT_TRUE(is_state_portal_detection_pending());
539
540  // To run CaptivePortalDetector::DetectCaptivePortal().
541  base::MessageLoop::current()->RunUntilIdle();
542
543  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
544                   net::URLFetcher::RESPONSE_CODE_INVALID,
545                   NULL);
546  ASSERT_EQ(3, attempt_count());
547  ASSERT_TRUE(is_state_idle());
548
549  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL,
550                   net::URLFetcher::RESPONSE_CODE_INVALID,
551                   kStubWireless1);
552}
553
554TEST_F(NetworkPortalDetectorImplTest, LazyDetectionForOnlineNetwork) {
555  ASSERT_TRUE(is_state_idle());
556  set_min_time_between_attempts(base::TimeDelta());
557  set_lazy_check_interval(base::TimeDelta());
558
559  SetConnected(kStubWireless1);
560  enable_lazy_detection();
561  CompleteURLFetch(net::OK, 204, NULL);
562
563  ASSERT_EQ(1, attempt_count());
564  ASSERT_TRUE(is_state_portal_detection_pending());
565  CheckPortalState(
566      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
567      kStubWireless1);
568
569  // To run CaptivePortalDetector::DetectCaptivePortal().
570  base::MessageLoop::current()->RunUntilIdle();
571
572  CompleteURLFetch(net::OK, 204, NULL);
573
574  ASSERT_EQ(2, attempt_count());
575  ASSERT_TRUE(is_state_portal_detection_pending());
576  CheckPortalState(
577      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
578      kStubWireless1);
579
580  // To run CaptivePortalDetector::DetectCaptivePortal().
581  base::MessageLoop::current()->RunUntilIdle();
582
583  disable_lazy_detection();
584
585  // One more detection result, because DizableLazyDetection() doesn't
586  // cancel last detection request.
587  CompleteURLFetch(net::OK, 204, NULL);
588  ASSERT_EQ(3, attempt_count());
589  ASSERT_TRUE(is_state_idle());
590  CheckPortalState(
591      NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
592      kStubWireless1);
593}
594
595TEST_F(NetworkPortalDetectorImplTest, LazyDetectionForPortalNetwork) {
596  ASSERT_TRUE(is_state_idle());
597  set_min_time_between_attempts(base::TimeDelta());
598  set_lazy_check_interval(base::TimeDelta());
599
600  SetConnected(kStubWireless1);
601  enable_lazy_detection();
602
603  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
604                   net::URLFetcher::RESPONSE_CODE_INVALID,
605                   NULL);
606  ASSERT_EQ(1, attempt_count());
607  ASSERT_TRUE(is_state_portal_detection_pending());
608  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
609                   kStubWireless1);
610
611  // To run CaptivePortalDetector::DetectCaptivePortal().
612  base::MessageLoop::current()->RunUntilIdle();
613
614  CompleteURLFetch(net::ERR_CONNECTION_CLOSED,
615                   net::URLFetcher::RESPONSE_CODE_INVALID,
616                   NULL);
617  ASSERT_EQ(2, attempt_count());
618  ASSERT_TRUE(is_state_portal_detection_pending());
619  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
620                   kStubWireless1);
621
622  // To run CaptivePortalDetector::DetectCaptivePortal().
623  base::MessageLoop::current()->RunUntilIdle();
624
625  CompleteURLFetch(net::OK, 200, NULL);
626  ASSERT_EQ(3, attempt_count());
627  ASSERT_TRUE(is_state_portal_detection_pending());
628  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
629                   kStubWireless1);
630
631  // To run CaptivePortalDetector::DetectCaptivePortal().
632  base::MessageLoop::current()->RunUntilIdle();
633
634  disable_lazy_detection();
635
636  // One more detection result, because DizableLazyDetection() doesn't
637  // cancel last detection request.
638  CompleteURLFetch(net::OK, 200, NULL);
639  ASSERT_EQ(3, attempt_count());
640  ASSERT_TRUE(is_state_idle());
641  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
642                   kStubWireless1);
643}
644
645TEST_F(NetworkPortalDetectorImplTest, DetectionTimeoutIsCancelled) {
646  ASSERT_TRUE(is_state_idle());
647  set_min_time_between_attempts(base::TimeDelta());
648
649  SetConnected(kStubWireless1);
650  ASSERT_TRUE(is_state_checking_for_portal());
651  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
652                   kStubWireless1);
653
654  cancel_portal_detection();
655
656  ASSERT_TRUE(is_state_idle());
657  ASSERT_TRUE(detection_timeout_is_cancelled());
658  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_UNKNOWN, -1,
659                   kStubWireless1);
660}
661
662TEST_F(NetworkPortalDetectorImplTest, TestDetectionRestart) {
663  ASSERT_TRUE(is_state_idle());
664  set_min_time_between_attempts(base::TimeDelta());
665
666  // First portal detection attempts determines ONLINE state.
667  SetConnected(kStubWireless1);
668  ASSERT_TRUE(is_state_checking_for_portal());
669  ASSERT_FALSE(start_detection_if_idle());
670
671  CompleteURLFetch(net::OK, 204, NULL);
672
673  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE, 204,
674                   kStubWireless1);
675  ASSERT_TRUE(is_state_idle());
676
677  // First portal detection attempts determines PORTAL state.
678  ASSERT_TRUE(start_detection_if_idle());
679  ASSERT_TRUE(is_state_portal_detection_pending());
680  ASSERT_FALSE(start_detection_if_idle());
681
682  base::MessageLoop::current()->RunUntilIdle();
683  ASSERT_TRUE(is_state_checking_for_portal());
684  CompleteURLFetch(net::OK, 200, NULL);
685
686  CheckPortalState(NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_PORTAL, 200,
687                   kStubWireless1);
688  ASSERT_TRUE(is_state_idle());
689}
690
691TEST_F(NetworkPortalDetectorImplTest, RequestTimeouts) {
692  ASSERT_TRUE(is_state_idle());
693  set_min_time_between_attempts(base::TimeDelta());
694  set_lazy_check_interval(base::TimeDelta());
695
696  SetNetworkDeviceEnabled(flimflam::kTypeWifi, false);
697  SetConnected(kStubCellular);
698
699  // First portal detection attempt for cellular1 uses 5sec timeout.
700  CheckRequestTimeoutAndCompleteAttempt(1, 5, net::ERR_CONNECTION_CLOSED,
701                                        net::URLFetcher::RESPONSE_CODE_INVALID);
702
703  // Second portal detection attempt for cellular1 uses 10sec timeout.
704  ASSERT_TRUE(is_state_portal_detection_pending());
705  base::MessageLoop::current()->RunUntilIdle();
706  CheckRequestTimeoutAndCompleteAttempt(2, 10, net::ERR_CONNECTION_CLOSED,
707                                        net::URLFetcher::RESPONSE_CODE_INVALID);
708
709  // Third portal detection attempt for cellular1 uses 15sec timeout.
710  ASSERT_TRUE(is_state_portal_detection_pending());
711  base::MessageLoop::current()->RunUntilIdle();
712  CheckRequestTimeoutAndCompleteAttempt(3, 15, net::ERR_CONNECTION_CLOSED,
713                                        net::URLFetcher::RESPONSE_CODE_INVALID);
714
715  ASSERT_TRUE(is_state_idle());
716
717  // Check that in lazy detection for cellular1 15sec timeout is used.
718  enable_lazy_detection();
719  ASSERT_TRUE(is_state_portal_detection_pending());
720  base::MessageLoop::current()->RunUntilIdle();
721  disable_lazy_detection();
722  CheckRequestTimeoutAndCompleteAttempt(3, 15, net::ERR_CONNECTION_CLOSED,
723                                        net::URLFetcher::RESPONSE_CODE_INVALID);
724  ASSERT_TRUE(is_state_idle());
725
726  SetNetworkDeviceEnabled(flimflam::kTypeWifi, true);
727  SetConnected(kStubWireless1);
728
729  // First portal detection attempt for wifi1 uses 5sec timeout.
730  CheckRequestTimeoutAndCompleteAttempt(1, 5, net::ERR_CONNECTION_CLOSED,
731                                        net::URLFetcher::RESPONSE_CODE_INVALID);
732
733  // Second portal detection attempt for wifi1 also uses 5sec timeout.
734  ASSERT_TRUE(is_state_portal_detection_pending());
735  base::MessageLoop::current()->RunUntilIdle();
736  CheckRequestTimeoutAndCompleteAttempt(2, 10, net::OK, 204);
737  ASSERT_TRUE(is_state_idle());
738
739  // Check that in lazy detection for wifi1 5sec timeout is used.
740  enable_lazy_detection();
741  ASSERT_TRUE(is_state_portal_detection_pending());
742  base::MessageLoop::current()->RunUntilIdle();
743  disable_lazy_detection();
744  CheckRequestTimeoutAndCompleteAttempt(3, 15, net::OK, 204);
745  ASSERT_TRUE(is_state_idle());
746}
747
748TEST_F(NetworkPortalDetectorImplTest, StartDetectionIfIdle) {
749  ASSERT_TRUE(is_state_idle());
750  set_min_time_between_attempts(base::TimeDelta());
751  SetConnected(kStubWireless1);
752
753  // First portal detection attempt for wifi1 uses 5sec timeout.
754  CheckRequestTimeoutAndCompleteAttempt(1, 5, net::ERR_CONNECTION_CLOSED,
755                                        net::URLFetcher::RESPONSE_CODE_INVALID);
756  ASSERT_TRUE(is_state_portal_detection_pending());
757  base::MessageLoop::current()->RunUntilIdle();
758
759  // Second portal detection attempt for wifi1 uses 10sec timeout.
760  CheckRequestTimeoutAndCompleteAttempt(2, 10, net::ERR_CONNECTION_CLOSED,
761                                        net::URLFetcher::RESPONSE_CODE_INVALID);
762  ASSERT_TRUE(is_state_portal_detection_pending());
763  base::MessageLoop::current()->RunUntilIdle();
764
765  // Second portal detection attempt for wifi1 uses 15sec timeout.
766  CheckRequestTimeoutAndCompleteAttempt(3, 15, net::ERR_CONNECTION_CLOSED,
767                                        net::URLFetcher::RESPONSE_CODE_INVALID);
768  ASSERT_TRUE(is_state_idle());
769  start_detection_if_idle();
770
771  ASSERT_TRUE(is_state_portal_detection_pending());
772
773  // First portal detection attempt for wifi1 uses 5sec timeout.
774  base::MessageLoop::current()->RunUntilIdle();
775  CheckRequestTimeoutAndCompleteAttempt(1, 5, net::OK, 204);
776  ASSERT_TRUE(is_state_idle());
777}
778
779}  // namespace chromeos
780