Home | History | Annotate | Download | only in web_resource 
      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 }
    299