net/android/network_change_notifier_android_unittest.cc

   1 // Copyright (c) 2012 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 // See network_change_notifier_android.h for design explanations.
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/callback.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "net/android/network_change_notifier_android.h"
  13 #include "net/android/network_change_notifier_delegate_android.h"
  14 #include "net/base/network_change_notifier.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace net {
  18
  19 namespace {
  20
  21 class NetworkChangeNotifierDelegateAndroidObserver
  22     : public NetworkChangeNotifierDelegateAndroid::Observer {
  23  public:
  24   NetworkChangeNotifierDelegateAndroidObserver() : notifications_count_(0) {}
  25
  26   // NetworkChangeNotifierDelegateAndroid::Observer:
  27   virtual void OnConnectionTypeChanged() OVERRIDE {
  28     notifications_count_++;
  29   }
  30
  31   int notifications_count() const {
  32     return notifications_count_;
  33   }
  34
  35  private:
  36   int notifications_count_;
  37 };
  38
  39 class NetworkChangeNotifierObserver
  40     : public NetworkChangeNotifier::ConnectionTypeObserver {
  41  public:
  42   NetworkChangeNotifierObserver() : notifications_count_(0) {}
  43
  44   // NetworkChangeNotifier::Observer:
  45   virtual void OnConnectionTypeChanged(
  46       NetworkChangeNotifier::ConnectionType connection_type) OVERRIDE {
  47     notifications_count_++;
  48   }
  49
  50   int notifications_count() const {
  51     return notifications_count_;
  52   }
  53
  54  private:
  55   int notifications_count_;
  56 };
  57
  58 }  // namespace
  59
  60 class BaseNetworkChangeNotifierAndroidTest : public testing::Test {
  61  protected:
  62   typedef NetworkChangeNotifier::ConnectionType ConnectionType;
  63
  64   virtual ~BaseNetworkChangeNotifierAndroidTest() {}
  65
  66   void RunTest(
  67       const base::Callback<int(void)>& notifications_count_getter,
  68       const base::Callback<ConnectionType(void)>&  connection_type_getter) {
  69     EXPECT_EQ(0, notifications_count_getter.Run());
  70     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
  71               connection_type_getter.Run());
  72
  73     // Changing from online to offline should trigger a notification.
  74     SetOffline();
  75     EXPECT_EQ(1, notifications_count_getter.Run());
  76     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
  77               connection_type_getter.Run());
  78
  79     // No notification should be triggered when the offline state hasn't
  80     // changed.
  81     SetOffline();
  82     EXPECT_EQ(1, notifications_count_getter.Run());
  83     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
  84               connection_type_getter.Run());
  85
  86     // Going from offline to online should trigger a notification.
  87     SetOnline();
  88     EXPECT_EQ(2, notifications_count_getter.Run());
  89     EXPECT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
  90               connection_type_getter.Run());
  91   }
  92
  93   void SetOnline() {
  94     delegate_.SetOnline();
  95     // Note that this is needed because ObserverListThreadSafe uses PostTask().
  96     base::MessageLoop::current()->RunUntilIdle();
  97   }
  98
  99   void SetOffline() {
 100     delegate_.SetOffline();
 101     // See comment above.
 102     base::MessageLoop::current()->RunUntilIdle();
 103   }
 104
 105   NetworkChangeNotifierDelegateAndroid delegate_;
 106 };
 107
 108 // Tests that NetworkChangeNotifierDelegateAndroid is initialized with the
 109 // actual connection type rather than a hardcoded one (e.g.
 110 // CONNECTION_UNKNOWN). Initializing the connection type to CONNECTION_UNKNOWN
 111 // and relying on the first network change notification to set it correctly can
 112 // be problematic in case there is a long delay between the delegate's
 113 // construction and the notification.
 114 TEST_F(BaseNetworkChangeNotifierAndroidTest,
 115        DelegateIsInitializedWithCurrentConnectionType) {
 116   SetOffline();
 117   ASSERT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
 118             delegate_.GetCurrentConnectionType());
 119   // Instantiate another delegate to validate that it uses the actual
 120   // connection type at construction.
 121   scoped_ptr<NetworkChangeNotifierDelegateAndroid> other_delegate(
 122       new NetworkChangeNotifierDelegateAndroid());
 123   EXPECT_EQ(NetworkChangeNotifier::CONNECTION_NONE,
 124             other_delegate->GetCurrentConnectionType());
 125
 126   // Toggle the global connectivity state and instantiate another delegate
 127   // again.
 128   SetOnline();
 129   ASSERT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
 130             delegate_.GetCurrentConnectionType());
 131   other_delegate.reset(new NetworkChangeNotifierDelegateAndroid());
 132   EXPECT_EQ(NetworkChangeNotifier::CONNECTION_UNKNOWN,
 133             other_delegate->GetCurrentConnectionType());
 134 }
 135
 136 class NetworkChangeNotifierDelegateAndroidTest
 137     : public BaseNetworkChangeNotifierAndroidTest {
 138  protected:
 139   NetworkChangeNotifierDelegateAndroidTest() {
 140     delegate_.AddObserver(&delegate_observer_);
 141     delegate_.AddObserver(&other_delegate_observer_);
 142   }
 143
 144   virtual ~NetworkChangeNotifierDelegateAndroidTest() {
 145     delegate_.RemoveObserver(&delegate_observer_);
 146     delegate_.RemoveObserver(&other_delegate_observer_);
 147   }
 148
 149   NetworkChangeNotifierDelegateAndroidObserver delegate_observer_;
 150   NetworkChangeNotifierDelegateAndroidObserver other_delegate_observer_;
 151 };
 152
 153 // Tests that the NetworkChangeNotifierDelegateAndroid's observers are notified.
 154 // A testing-only observer is used here for testing. In production the
 155 // delegate's observers are instances of NetworkChangeNotifierAndroid.
 156 TEST_F(NetworkChangeNotifierDelegateAndroidTest, DelegateObserverNotified) {
 157   // Test the logic with a single observer.
 158   RunTest(
 159       base::Bind(
 160           &NetworkChangeNotifierDelegateAndroidObserver::notifications_count,
 161           base::Unretained(&delegate_observer_)),
 162       base::Bind(
 163           &NetworkChangeNotifierDelegateAndroid::GetCurrentConnectionType,
 164           base::Unretained(&delegate_)));
 165   // Check that *all* the observers are notified. Both observers should have the
 166   // same state.
 167   EXPECT_EQ(delegate_observer_.notifications_count(),
 168             other_delegate_observer_.notifications_count());
 169 }
 170
 171 class NetworkChangeNotifierAndroidTest
 172     : public BaseNetworkChangeNotifierAndroidTest {
 173  protected:
 174   NetworkChangeNotifierAndroidTest() : notifier_(&delegate_) {
 175     NetworkChangeNotifier::AddConnectionTypeObserver(
 176         &connection_type_observer_);
 177     NetworkChangeNotifier::AddConnectionTypeObserver(
 178         &other_connection_type_observer_);
 179   }
 180
 181   NetworkChangeNotifierObserver connection_type_observer_;
 182   NetworkChangeNotifierObserver other_connection_type_observer_;
 183   NetworkChangeNotifier::DisableForTest disable_for_test_;
 184   NetworkChangeNotifierAndroid notifier_;
 185 };
 186
 187 // When a NetworkChangeNotifierAndroid is observing a
 188 // NetworkChangeNotifierDelegateAndroid for network state changes, and the
 189 // NetworkChangeNotifierDelegateAndroid's connectivity state changes, the
 190 // NetworkChangeNotifierAndroid should reflect that state.
 191 TEST_F(NetworkChangeNotifierAndroidTest,
 192        NotificationsSentToNetworkChangeNotifierAndroid) {
 193   RunTest(
 194       base::Bind(
 195           &NetworkChangeNotifierObserver::notifications_count,
 196           base::Unretained(&connection_type_observer_)),
 197       base::Bind(
 198           &NetworkChangeNotifierAndroid::GetCurrentConnectionType,
 199           base::Unretained(&notifier_)));
 200 }
 201
 202 // When a NetworkChangeNotifierAndroid's connection state changes, it should
 203 // notify all of its observers.
 204 TEST_F(NetworkChangeNotifierAndroidTest,
 205        NotificationsSentToClientsOfNetworkChangeNotifier) {
 206   RunTest(
 207       base::Bind(
 208           &NetworkChangeNotifierObserver::notifications_count,
 209           base::Unretained(&connection_type_observer_)),
 210       base::Bind(&NetworkChangeNotifier::GetConnectionType));
 211   // Check that *all* the observers are notified.
 212   EXPECT_EQ(connection_type_observer_.notifications_count(),
 213             other_connection_type_observer_.notifications_count());
 214 }
 215
 216 }  // namespace net