chrome/browser/web_resource/resource_request_allowed_notifier_unittest.cc

   1 // Copyright 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/prefs/testing_pref_service.h"
   6 #include "chrome/browser/chrome_notification_types.h"
   7 #include "chrome/browser/web_resource/eula_accepted_notifier.h"
   8 #include "chrome/browser/web_resource/resource_request_allowed_notifier_test_util.h"
   9 #include "chrome/test/base/testing_browser_process.h"
  10 #include "content/public/browser/notification_service.h"
  11 #include "content/public/test/test_browser_thread.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 // Override NetworkChangeNotifier to simulate connection type changes for tests.
  15 class TestNetworkChangeNotifier : public net::NetworkChangeNotifier {
  16  public:
  17   TestNetworkChangeNotifier()
  18       : net::NetworkChangeNotifier(),
  19         connection_type_to_return_(
  20             net::NetworkChangeNotifier::CONNECTION_UNKNOWN) {
  21   }
  22
  23   // Simulates a change of the connection type to |type|. This will notify any
  24   // objects that are NetworkChangeNotifiers.
  25   void SimulateNetworkConnectionChange(
  26       net::NetworkChangeNotifier::ConnectionType type) {
  27     connection_type_to_return_ = type;
  28     net::NetworkChangeNotifier::NotifyObserversOfConnectionTypeChange();
  29     base::MessageLoop::current()->RunUntilIdle();
  30   }
  31
  32  private:
  33   virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
  34     return connection_type_to_return_;
  35   }
  36
  37   // The currently simulated network connection type. If this is set to
  38   // CONNECTION_NONE, then NetworkChangeNotifier::IsOffline will return true.
  39   net::NetworkChangeNotifier::ConnectionType connection_type_to_return_;
  40
  41   DISALLOW_COPY_AND_ASSIGN(TestNetworkChangeNotifier);
  42 };
  43
  44 // EulaAcceptedNotifier test class that allows mocking the EULA accepted state
  45 // and issuing simulated notifications.
  46 class TestEulaAcceptedNotifier : public EulaAcceptedNotifier {
  47  public:
  48   TestEulaAcceptedNotifier()
  49       : EulaAcceptedNotifier(NULL),
  50         eula_accepted_(false) {
  51   }
  52   virtual ~TestEulaAcceptedNotifier() {
  53   }
  54
  55   virtual bool IsEulaAccepted() OVERRIDE {
  56     return eula_accepted_;
  57   }
  58
  59   void SetEulaAcceptedForTesting(bool eula_accepted) {
  60     eula_accepted_ = eula_accepted;
  61   }
  62
  63   void SimulateEulaAccepted() {
  64     NotifyObserver();
  65   }
  66
  67  private:
  68   bool eula_accepted_;
  69
  70   DISALLOW_COPY_AND_ASSIGN(TestEulaAcceptedNotifier);
  71 };
  72
  73 // A test fixture class for ResourceRequestAllowedNotifier tests that require
  74 // network state simulations. This also acts as the service implementing the
  75 // ResourceRequestAllowedNotifier::Observer interface.
  76 class ResourceRequestAllowedNotifierTest
  77     : public testing::Test,
  78       public ResourceRequestAllowedNotifier::Observer {
  79  public:
  80   ResourceRequestAllowedNotifierTest()
  81     : ui_thread(content::BrowserThread::UI, &message_loop),
  82       eula_notifier_(new TestEulaAcceptedNotifier),
  83       was_notified_(false) {
  84     resource_request_allowed_notifier_.InitWithEulaAcceptNotifier(
  85         this, scoped_ptr<EulaAcceptedNotifier>(eula_notifier_));
  86   }
  87   virtual ~ResourceRequestAllowedNotifierTest() { }
  88
  89   bool was_notified() const { return was_notified_; }
  90
  91   // ResourceRequestAllowedNotifier::Observer override:
  92   virtual void OnResourceRequestsAllowed() OVERRIDE {
  93     was_notified_ = true;
  94   }
  95
  96   // Network manipulation methods:
  97   void SetWaitingForNetwork(bool waiting) {
  98     resource_request_allowed_notifier_.SetWaitingForNetworkForTesting(waiting);
  99   }
 100
 101   void SimulateNetworkConnectionChange(
 102       net::NetworkChangeNotifier::ConnectionType type) {
 103     network_notifier.SimulateNetworkConnectionChange(type);
 104   }
 105
 106   // Simulate a resource request from the test service. It returns true if
 107   // resource request is allowed. Otherwise returns false and will change the
 108   // result of was_notified() to true when the request is allowed.
 109   bool SimulateResourceRequest() {
 110     return resource_request_allowed_notifier_.ResourceRequestsAllowed();
 111   }
 112
 113   void SimulateEulaAccepted() {
 114     eula_notifier_->SimulateEulaAccepted();
 115   }
 116
 117   // Eula manipulation methods:
 118   void SetNeedsEulaAcceptance(bool needs_acceptance) {
 119     eula_notifier_->SetEulaAcceptedForTesting(!needs_acceptance);
 120   }
 121
 122   void SetWaitingForEula(bool waiting) {
 123     resource_request_allowed_notifier_.SetWaitingForEulaForTesting(waiting);
 124   }
 125
 126   // Used in tests involving the EULA. Disables both the EULA accepted state
 127   // and the network.
 128   void DisableEulaAndNetwork() {
 129     SetWaitingForNetwork(true);
 130     SimulateNetworkConnectionChange(
 131         net::NetworkChangeNotifier::CONNECTION_NONE);
 132     SetWaitingForEula(true);
 133     SetNeedsEulaAcceptance(true);
 134   }
 135
 136   virtual void SetUp() OVERRIDE {
 137     // Assume the test service has already requested permission, as all tests
 138     // just test that criteria changes notify the server.
 139     // Set default EULA state to done (not waiting and EULA accepted) to
 140     // simplify non-ChromeOS tests.
 141     SetWaitingForEula(false);
 142     SetNeedsEulaAcceptance(false);
 143   }
 144
 145  private:
 146   base::MessageLoopForUI message_loop;
 147   content::TestBrowserThread ui_thread;
 148   TestNetworkChangeNotifier network_notifier;
 149   TestRequestAllowedNotifier resource_request_allowed_notifier_;
 150   TestEulaAcceptedNotifier* eula_notifier_;  // Weak, owned by RRAN.
 151   bool was_notified_;
 152
 153   DISALLOW_COPY_AND_ASSIGN(ResourceRequestAllowedNotifierTest);
 154 };
 155
 156 TEST_F(ResourceRequestAllowedNotifierTest, DoNotNotifyIfOffline) {
 157   SetWaitingForNetwork(true);
 158   EXPECT_FALSE(SimulateResourceRequest());
 159   SimulateNetworkConnectionChange(net::NetworkChangeNotifier::CONNECTION_NONE);
 160   EXPECT_FALSE(was_notified());
 161 }
 162
 163 TEST_F(ResourceRequestAllowedNotifierTest, DoNotNotifyIfOnlineToOnline) {
 164   SetWaitingForNetwork(false);
 165   EXPECT_TRUE(SimulateResourceRequest());
 166   SimulateNetworkConnectionChange(
 167       net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 168   EXPECT_FALSE(was_notified());
 169 }
 170
 171 TEST_F(ResourceRequestAllowedNotifierTest, NotifyOnReconnect) {
 172   SetWaitingForNetwork(true);
 173   EXPECT_FALSE(SimulateResourceRequest());
 174   SimulateNetworkConnectionChange(
 175       net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 176   EXPECT_TRUE(was_notified());
 177 }
 178
 179 TEST_F(ResourceRequestAllowedNotifierTest, NoNotifyOnWardriving) {
 180   SetWaitingForNetwork(false);
 181   EXPECT_TRUE(SimulateResourceRequest());
 182   SimulateNetworkConnectionChange(
 183       net::NetworkChangeNotifier::CONNECTION_WIFI);
 184   EXPECT_FALSE(was_notified());
 185   SimulateNetworkConnectionChange(
 186       net::NetworkChangeNotifier::CONNECTION_3G);
 187   EXPECT_FALSE(was_notified());
 188   SimulateNetworkConnectionChange(
 189       net::NetworkChangeNotifier::CONNECTION_4G);
 190   EXPECT_FALSE(was_notified());
 191   SimulateNetworkConnectionChange(
 192       net::NetworkChangeNotifier::CONNECTION_WIFI);
 193   EXPECT_FALSE(was_notified());
 194 }
 195
 196 TEST_F(ResourceRequestAllowedNotifierTest, NoNotifyOnFlakyConnection) {
 197   // SimulateResourceRequest() returns true because network is online.
 198   SetWaitingForNetwork(false);
 199   EXPECT_TRUE(SimulateResourceRequest());
 200   // The callback is nerver invoked whatever happens on network connection.
 201   SimulateNetworkConnectionChange(
 202       net::NetworkChangeNotifier::CONNECTION_WIFI);
 203   EXPECT_FALSE(was_notified());
 204   SimulateNetworkConnectionChange(
 205       net::NetworkChangeNotifier::CONNECTION_NONE);
 206   EXPECT_FALSE(was_notified());
 207   SimulateNetworkConnectionChange(
 208       net::NetworkChangeNotifier::CONNECTION_WIFI);
 209   EXPECT_FALSE(was_notified());
 210 }
 211
 212 TEST_F(ResourceRequestAllowedNotifierTest, NotifyOnFlakyConnection) {
 213   SetWaitingForNetwork(false);
 214   EXPECT_TRUE(SimulateResourceRequest());
 215   // Network goes online, but not notified because SimulateResourceRequest()
 216   // returns true before.
 217   SimulateNetworkConnectionChange(
 218       net::NetworkChangeNotifier::CONNECTION_WIFI);
 219   EXPECT_FALSE(was_notified());
 220   SimulateNetworkConnectionChange(
 221       net::NetworkChangeNotifier::CONNECTION_NONE);
 222   EXPECT_FALSE(SimulateResourceRequest());
 223   // Now, SimulateResourceRequest() returns false and will be notified later.
 224   EXPECT_FALSE(was_notified());
 225   SimulateNetworkConnectionChange(
 226       net::NetworkChangeNotifier::CONNECTION_WIFI);
 227   EXPECT_TRUE(was_notified());
 228 }
 229
 230 TEST_F(ResourceRequestAllowedNotifierTest, NoNotifyOnEulaAfterGoOffline) {
 231   DisableEulaAndNetwork();
 232   EXPECT_FALSE(SimulateResourceRequest());
 233
 234   SimulateNetworkConnectionChange(
 235       net::NetworkChangeNotifier::CONNECTION_WIFI);
 236   EXPECT_FALSE(was_notified());
 237   SimulateNetworkConnectionChange(
 238       net::NetworkChangeNotifier::CONNECTION_NONE);
 239   EXPECT_FALSE(was_notified());
 240   SimulateEulaAccepted();
 241   EXPECT_FALSE(was_notified());
 242 }
 243
 244 TEST_F(ResourceRequestAllowedNotifierTest, NoRequestNoNotify) {
 245   // Ensure that if the observing service does not request access, it does not
 246   // get notified, even if the criteria is met. Note that this is done by not
 247   // calling SimulateResourceRequest here.
 248   SetWaitingForNetwork(true);
 249   SimulateNetworkConnectionChange(
 250       net::NetworkChangeNotifier::CONNECTION_ETHERNET);
 251   EXPECT_FALSE(was_notified());
 252 }
 253
 254 TEST_F(ResourceRequestAllowedNotifierTest, EulaOnlyNetworkOffline) {
 255   DisableEulaAndNetwork();
 256   EXPECT_FALSE(SimulateResourceRequest());
 257
 258   SimulateEulaAccepted();
 259   EXPECT_FALSE(was_notified());
 260 }
 261
 262 TEST_F(ResourceRequestAllowedNotifierTest, EulaFirst) {
 263   DisableEulaAndNetwork();
 264   EXPECT_FALSE(SimulateResourceRequest());
 265
 266   SimulateEulaAccepted();
 267   EXPECT_FALSE(was_notified());
 268
 269   SimulateNetworkConnectionChange(
 270       net::NetworkChangeNotifier::CONNECTION_WIFI);
 271   EXPECT_TRUE(was_notified());
 272 }
 273
 274 TEST_F(ResourceRequestAllowedNotifierTest, NetworkFirst) {
 275   DisableEulaAndNetwork();
 276   EXPECT_FALSE(SimulateResourceRequest());
 277
 278   SimulateNetworkConnectionChange(
 279       net::NetworkChangeNotifier::CONNECTION_WIFI);
 280   EXPECT_FALSE(was_notified());
 281
 282   SimulateEulaAccepted();
 283   EXPECT_TRUE(was_notified());
 284 }
 285
 286 TEST_F(ResourceRequestAllowedNotifierTest, NoRequestNoNotifyEula) {
 287   // Ensure that if the observing service does not request access, it does not
 288   // get notified, even if the criteria is met. Note that this is done by not
 289   // calling SimulateResourceRequest here.
 290   DisableEulaAndNetwork();
 291
 292   SimulateNetworkConnectionChange(
 293       net::NetworkChangeNotifier::CONNECTION_WIFI);
 294   EXPECT_FALSE(was_notified());
 295
 296   SimulateEulaAccepted();
 297   EXPECT_FALSE(was_notified());
 298 }