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