network_portal_detector_impl_unittest.cc revision 9ab5563a3196760eb381d102cbb2bc0f7abc6a50 
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/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/net/network_portal_detector_impl.h"
12#include "chrome/test/base/testing_profile.h"
13#include "chromeos/dbus/dbus_thread_manager.h"
14#include "chromeos/dbus/shill_device_client.h"
15#include "chromeos/dbus/shill_service_client.h"
16#include "chromeos/network/network_state.h"
17#include "chromeos/network/network_state_handler.h"
18#include "dbus/object_path.h"
19#include "net/base/net_errors.h"
20#include "testing/gtest/include/gtest/gtest.h"
21#include "third_party/cros_system_api/dbus/service_constants.h"
22
23namespace chromeos {
24
25namespace {
26
27void ErrorCallbackFunction(const std::string& error_name,
28                           const std::string& error_message) {
29  LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
30}
31
32}  // namespace
33
34// Service paths for stub network devices.
35const char* kStubEthernet = "stub_ethernet";
36const char* kStubWireless1 = "stub_wifi1";
37const char* kStubWireless2 = "stub_wifi2";
38const char* kStubCellular = "stub_cellular";
39
40class NetworkPortalDetectorImplTest
41    : public testing::Test,
42      public captive_portal::CaptivePortalDetectorTestBase {
43 public:
44  NetworkPortalDetectorImplTest() {}
45  virtual ~NetworkPortalDetectorImplTest() {}
46
47  virtual void SetUp() {
48    DBusThreadManager::InitializeWithStub();
49    SetupNetworkHandler();
50
51    profile_.reset(new TestingProfile());
52    network_portal_detector_.reset(
53        new NetworkPortalDetectorImpl(profile_->GetRequestContext()));
54    network_portal_detector_->Init();
55    network_portal_detector_->Enable(false);
56
57    set_detector(network_portal_detector_->captive_portal_detector_.get());
58
59    // Prevents flakiness due to message loop delays.
60    set_time_ticks(base::TimeTicks::Now());
61  }
62
63  virtual void TearDown() {
64    network_portal_detector_->Shutdown();
65    profile_.reset();
66    NetworkHandler::Shutdown();
67    DBusThreadManager::Shutdown();
68  }
69
70  void CheckPortalState(NetworkPortalDetector::CaptivePortalStatus status,
71                        int response_code,
72                        const std::string& network_service_path) {
73    const NetworkState* network =
74        NetworkHandler::Get()->network_state_handler()->GetNetworkState(
75            network_service_path);
76    NetworkPortalDetector::CaptivePortalState state =
77        network_portal_detector()->GetCaptivePortalState(network);
78    ASSERT_EQ(status, state.status);
79    ASSERT_EQ(response_code, state.response_code);
80  }
81
82  void CheckRequestTimeoutAndCompleteAttempt(
83      int expected_attempt_count,
84      int expected_request_timeout_sec,
85      int net_error,
86      int status_code) {
87    ASSERT_TRUE(is_state_checking_for_portal());
88    ASSERT_EQ(expected_attempt_count, attempt_count());
89    ASSERT_EQ(expected_request_timeout_sec, get_request_timeout_sec());
90    CompleteURLFetch(net_error, status_code, NULL);
91  }
92
93  Profile* profile() { return profile_.get(); }
94
95  NetworkPortalDetectorImpl* network_portal_detector() {
96    return network_portal_detector_.get();
97  }
98
99  NetworkPortalDetectorImpl::State state() {
100    return network_portal_detector()->state();
101  }
102
103  bool start_detection_if_idle() {
104    return network_portal_detector()->StartDetectionIfIdle();
105  }
106
107  void enable_lazy_detection() {
108    network_portal_detector()->EnableLazyDetection();
109  }
110
111  void disable_lazy_detection() {
112    network_portal_detector()->DisableLazyDetection();
113  }
114
115  void cancel_portal_detection() {
116    network_portal_detector()->CancelPortalDetection();
117  }
118
119  bool detection_timeout_is_cancelled() {
120    return
121        network_portal_detector()->DetectionTimeoutIsCancelledForTesting();
122  }
123
124  int get_request_timeout_sec() {
125    return network_portal_detector()->GetRequestTimeoutSec();
126  }
127
128  bool is_state_idle() {
129    return (NetworkPortalDetectorImpl::STATE_IDLE == state());
130  }
131
132  bool is_state_portal_detection_pending() {
133    return (NetworkPortalDetectorImpl::STATE_PORTAL_CHECK_PENDING == state());
134  }
135
136  bool is_state_checking_for_portal() {
137    return (NetworkPortalDetectorImpl::STATE_CHECKING_FOR_PORTAL == state());
138  }
139
140  void set_request_timeout(const base::TimeDelta& timeout) {
141    network_portal_detector()->set_request_timeout_for_testing(timeout);
142  }
143
144  const base::TimeDelta& next_attempt_delay() {
145    return network_portal_detector()->next_attempt_delay_for_testing();
146  }
147
148  int attempt_count() {
149    return network_portal_detector()->attempt_count_for_testing();
150  }
151
152  void set_min_time_between_attempts(const base::TimeDelta& delta) {
153    network_portal_detector()->set_min_time_between_attempts_for_testing(delta);
154  }
155
156  void set_lazy_check_interval(const base::TimeDelta& delta) {
157    network_portal_detector()->set_lazy_check_interval_for_testing(delta);
158  }
159
160  void set_time_ticks(const base::TimeTicks& time_ticks) {
161    network_portal_detector()->set_time_ticks_for_testing(time_ticks);
162  }
163
164  void SetBehindPortal(const std::string& service_path) {
165    DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
166        dbus::ObjectPath(service_path),
167        flimflam::kStateProperty, base::StringValue(flimflam::kStatePortal),
168        base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
169    base::MessageLoop::current()->RunUntilIdle();
170  }
171
172  void SetNetworkDeviceEnabled(const std::string& type, bool enabled) {
173    NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
174        type, enabled, network_handler::ErrorCallback());
175    base::MessageLoop::current()->RunUntilIdle();
176  }
177
178  void SetConnected(const std::string& service_path) {
179    DBusThreadManager::Get()->GetShillServiceClient()->SetProperty(
180        dbus::ObjectPath(service_path),
181        flimflam::kStateProperty, base::StringValue(flimflam::kStateOnline),
182        base::Bind(&base::DoNothing), base::Bind(&ErrorCallbackFunction));
183    base::MessageLoop::current()->RunUntilIdle();
184  }
185
186 private:
187  void SetupDefaultShillState() {
188    base::MessageLoop::current()->RunUntilIdle();
189    ShillServiceClient::TestInterface* service_test =
190        DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
191    service_test->ClearServices();
192    const bool add_to_visible = true;
193    const bool add_to_watchlist = true;
194    service_test->AddService(kStubEthernet,
195                             kStubEthernet,
196                             flimflam::kTypeEthernet, flimflam::kStateIdle,
197                             add_to_visible, add_to_watchlist);
198    service_test->AddService(kStubWireless1,
199                             kStubWireless1,
200                             flimflam::kTypeWifi, flimflam::kStateIdle,
201                             add_to_visible, add_to_watchlist);
202    service_test->AddService(kStubWireless2,
203                             kStubWireless2,
204                             flimflam::kTypeWifi, flimflam::kStateIdle,
205                             add_to_visible, add_to_watchlist);
206    service_test->AddService(kStubCellular,
207                             kStubCellular,
208                             flimflam::kTypeCellular, flimflam::kStateIdle,
209                             add_to_visible, 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