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 #include "base/compiler_specific.h" 6 #include "base/message_loop/message_loop.h" 7 #include "chrome/browser/extensions/api/dial/dial_device_data.h" 8 #include "chrome/browser/extensions/api/dial/dial_registry.h" 9 #include "chrome/browser/extensions/api/dial/dial_service.h" 10 #include "chrome/test/base/testing_profile.h" 11 #include "testing/gmock/include/gmock/gmock.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 #include "url/gurl.h" 14 15 using base::Time; 16 using base::TimeDelta; 17 using ::testing::A; 18 using ::testing::AtLeast; 19 using ::testing::Return; 20 using ::testing::InSequence; 21 22 namespace extensions { 23 24 class MockDialObserver : public DialRegistry::Observer { 25 public: 26 MOCK_METHOD1(OnDialDeviceEvent, 27 void(const DialRegistry::DeviceList& devices)); 28 MOCK_METHOD1(OnDialError, void(DialRegistry::DialErrorCode type)); 29 }; 30 31 class MockDialService : public DialService { 32 public: 33 virtual ~MockDialService() {} 34 35 MOCK_METHOD0(Discover, bool()); 36 MOCK_METHOD1(AddObserver, void(DialService::Observer*)); 37 MOCK_METHOD1(RemoveObserver, void(DialService::Observer*)); 38 MOCK_METHOD1(HasObserver, bool(DialService::Observer*)); 39 }; 40 41 class MockDialRegistry : public DialRegistry { 42 public: 43 MockDialRegistry(Observer *dial_api, 44 const base::TimeDelta& refresh_interval, 45 const base::TimeDelta& expiration, 46 const size_t max_devices) 47 : DialRegistry(dial_api, refresh_interval, expiration, max_devices) { 48 time_ = Time::Now(); 49 } 50 51 virtual ~MockDialRegistry() { 52 // Don't let the DialRegistry delete this. 53 DialService* tmp = dial_.release(); 54 if (tmp != NULL) 55 CHECK_EQ(&mock_service_, tmp); 56 } 57 58 // Returns the mock Dial service. 59 MockDialService& mock_service() { 60 return mock_service_; 61 } 62 63 // Set to mock out the current time. 64 Time time_; 65 66 protected: 67 virtual base::Time Now() const OVERRIDE { 68 return time_; 69 } 70 71 virtual DialService* CreateDialService() OVERRIDE { 72 return &mock_service_; 73 } 74 75 virtual void ClearDialService() OVERRIDE { 76 // Release the pointer but don't delete the object because the test owns it. 77 CHECK_EQ(&mock_service_, dial_.release()); 78 } 79 80 private: 81 MockDialService mock_service_; 82 }; 83 84 class DialRegistryTest : public testing::Test { 85 public: 86 DialRegistryTest() 87 : first_device_("first", GURL("http://127.0.0.1/dd.xml"), Time::Now()), 88 second_device_("second", GURL("http://127.0.0.2/dd.xml"), Time::Now()), 89 third_device_("third", GURL("http://127.0.0.3/dd.xml"), Time::Now()) { 90 registry_.reset(new MockDialRegistry(&mock_observer_, 91 TimeDelta::FromSeconds(1000), 92 TimeDelta::FromSeconds(10), 93 10)); 94 list_with_first_device_.push_back(first_device_); 95 list_with_second_device_.push_back(second_device_); 96 } 97 98 protected: 99 scoped_ptr<MockDialRegistry> registry_; 100 MockDialObserver mock_observer_; 101 const DialDeviceData first_device_; 102 const DialDeviceData second_device_; 103 const DialDeviceData third_device_; 104 105 const DialRegistry::DeviceList empty_list_; 106 DialRegistry::DeviceList list_with_first_device_; 107 DialRegistry::DeviceList list_with_second_device_; 108 109 // Must instantiate a MessageLoop for the thread, as the registry starts a 110 // RepeatingTimer when there are listeners. 111 base::MessageLoop message_loop_; 112 113 void SetListenerExpectations() { 114 EXPECT_CALL(registry_->mock_service(), 115 AddObserver(A<DialService::Observer*>())) 116 .Times(1); 117 EXPECT_CALL(registry_->mock_service(), 118 RemoveObserver(A<DialService::Observer*>())) 119 .Times(1); 120 } 121 }; 122 123 TEST_F(DialRegistryTest, TestAddRemoveListeners) { 124 SetListenerExpectations(); 125 EXPECT_CALL(registry_->mock_service(), Discover()) 126 .Times(1); 127 128 EXPECT_FALSE(registry_->repeating_timer_.IsRunning()); 129 registry_->OnListenerAdded(); 130 EXPECT_TRUE(registry_->repeating_timer_.IsRunning()); 131 registry_->OnListenerAdded(); 132 EXPECT_TRUE(registry_->repeating_timer_.IsRunning()); 133 registry_->OnListenerRemoved(); 134 EXPECT_TRUE(registry_->repeating_timer_.IsRunning()); 135 registry_->OnListenerRemoved(); 136 EXPECT_FALSE(registry_->repeating_timer_.IsRunning()); 137 } 138 139 TEST_F(DialRegistryTest, TestNoDevicesDiscovered) { 140 SetListenerExpectations(); 141 EXPECT_CALL(registry_->mock_service(), Discover()) 142 .Times(1); 143 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)) 144 .Times(1); 145 146 registry_->OnListenerAdded(); 147 registry_->OnDiscoveryRequest(NULL); 148 registry_->OnDiscoveryFinished(NULL); 149 registry_->OnListenerRemoved(); 150 }; 151 152 TEST_F(DialRegistryTest, TestDevicesDiscovered) { 153 DialRegistry::DeviceList expected_list2; 154 expected_list2.push_back(first_device_); 155 expected_list2.push_back(second_device_); 156 157 SetListenerExpectations(); 158 EXPECT_CALL(registry_->mock_service(), Discover()) 159 .Times(2); 160 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)) 161 .Times(1); 162 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)) 163 .Times(2); 164 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list2)) 165 .Times(1); 166 167 registry_->OnListenerAdded(); 168 registry_->OnDiscoveryRequest(NULL); 169 registry_->OnDeviceDiscovered(NULL, first_device_); 170 registry_->OnDiscoveryFinished(NULL); 171 172 registry_->DoDiscovery(); 173 registry_->OnDiscoveryRequest(NULL); 174 registry_->OnDeviceDiscovered(NULL, second_device_); 175 registry_->OnDiscoveryFinished(NULL); 176 registry_->OnListenerRemoved(); 177 } 178 179 TEST_F(DialRegistryTest, TestDeviceExpires) { 180 SetListenerExpectations(); 181 EXPECT_CALL(registry_->mock_service(), Discover()) 182 .Times(2); 183 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)) 184 .Times(2); 185 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)) 186 .Times(2); 187 188 registry_->OnListenerAdded(); 189 registry_->OnDiscoveryRequest(NULL); 190 registry_->OnDeviceDiscovered(NULL, first_device_); 191 registry_->OnDiscoveryFinished(NULL); 192 193 registry_->time_ = Time::Now() + TimeDelta::FromSeconds(30); 194 195 registry_->DoDiscovery(); 196 registry_->OnDiscoveryRequest(NULL); 197 registry_->OnDiscoveryFinished(NULL); 198 registry_->OnListenerRemoved(); 199 } 200 201 TEST_F(DialRegistryTest, TestExpiredDeviceIsRediscovered) { 202 std::vector<Time> discovery_times; 203 discovery_times.push_back(Time::Now()); 204 discovery_times.push_back(discovery_times[0] + TimeDelta::FromSeconds(30)); 205 discovery_times.push_back(discovery_times[1] + TimeDelta::FromSeconds(30)); 206 207 DialDeviceData rediscovered_device("first", 208 GURL("http://127.0.0.1/dd.xml"), 209 discovery_times[2]); 210 211 SetListenerExpectations(); 212 213 // TODO(mfoltz): Convert other tests to use InSequence to make expectations 214 // more obvious. 215 InSequence s; 216 217 EXPECT_CALL(registry_->mock_service(), Discover()); 218 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); 219 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)); 220 221 EXPECT_CALL(registry_->mock_service(), Discover()); 222 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)); 223 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); 224 225 EXPECT_CALL(registry_->mock_service(), Discover()); 226 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)); 227 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)); 228 229 registry_->time_ = discovery_times[0]; 230 registry_->OnListenerAdded(); 231 registry_->OnDiscoveryRequest(NULL); 232 registry_->OnDeviceDiscovered(NULL, first_device_); 233 registry_->OnDiscoveryFinished(NULL); 234 235 // Will expire "first" device as it is not discovered this time. 236 registry_->time_ = discovery_times[1]; 237 registry_->DoDiscovery(); 238 registry_->OnDiscoveryRequest(NULL); 239 registry_->OnDiscoveryFinished(NULL); 240 241 // "first" device is rediscovered 30 seconds later. We pass a device object 242 // with a newer discovery time so it is not pruned immediately. 243 registry_->time_ = discovery_times[2]; 244 registry_->DoDiscovery(); 245 registry_->OnDiscoveryRequest(NULL); 246 registry_->OnDeviceDiscovered(NULL, rediscovered_device); 247 registry_->OnDiscoveryFinished(NULL); 248 249 registry_->OnListenerRemoved(); 250 } 251 252 TEST_F(DialRegistryTest, TestRemovingListenerDoesNotClearList) { 253 EXPECT_CALL(registry_->mock_service(), 254 AddObserver(A<DialService::Observer*>())) 255 .Times(2); 256 EXPECT_CALL(registry_->mock_service(), 257 RemoveObserver(A<DialService::Observer*>())) 258 .Times(2); 259 260 EXPECT_CALL(registry_->mock_service(), Discover()) 261 .Times(2); 262 263 InSequence s; 264 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)) 265 .Times(1); 266 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)) 267 .Times(2); 268 269 registry_->OnListenerAdded(); 270 registry_->OnDiscoveryRequest(NULL); 271 registry_->OnDeviceDiscovered(NULL, first_device_); 272 registry_->OnDiscoveryFinished(NULL); 273 registry_->OnListenerRemoved(); 274 275 registry_->OnListenerAdded(); 276 registry_->OnDiscoveryRequest(NULL); 277 registry_->OnDiscoveryFinished(NULL); 278 registry_->OnListenerRemoved(); 279 } 280 281 TEST_F(DialRegistryTest, TestNetworkEventConnectionLost) { 282 SetListenerExpectations(); 283 284 EXPECT_CALL(registry_->mock_service(), Discover()) 285 .Times(1); 286 287 InSequence s; 288 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)) 289 .Times(1); 290 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)) 291 .Times(1); 292 EXPECT_CALL(mock_observer_, OnDialError( 293 DialRegistry::DIAL_NETWORK_DISCONNECTED)).Times(1); 294 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)) 295 .Times(1); 296 297 registry_->OnListenerAdded(); 298 registry_->OnDiscoveryRequest(NULL); 299 registry_->OnDeviceDiscovered(NULL, first_device_); 300 registry_->OnDiscoveryFinished(NULL); 301 302 registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_NONE); 303 304 registry_->OnDiscoveryRequest(NULL); 305 registry_->OnDiscoveryFinished(NULL); 306 registry_->OnListenerRemoved(); 307 } 308 309 TEST_F(DialRegistryTest, TestNetworkEventConnectionRestored) { 310 DialRegistry::DeviceList expected_list3; 311 expected_list3.push_back(second_device_); 312 expected_list3.push_back(third_device_); 313 314 // A disconnection should shutdown the DialService, so we expect the observer 315 // to be added twice. 316 EXPECT_CALL(registry_->mock_service(), 317 AddObserver(A<DialService::Observer*>())) 318 .Times(2); 319 EXPECT_CALL(registry_->mock_service(), 320 RemoveObserver(A<DialService::Observer*>())) 321 .Times(2); 322 323 EXPECT_CALL(registry_->mock_service(), Discover()) 324 .Times(2); 325 326 InSequence s; 327 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)) 328 .Times(1); 329 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_first_device_)) 330 .Times(1); 331 EXPECT_CALL(mock_observer_, 332 OnDialError(DialRegistry::DIAL_NETWORK_DISCONNECTED)) 333 .Times(1); 334 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(empty_list_)) 335 .Times(2); 336 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(list_with_second_device_)) 337 .Times(1); 338 EXPECT_CALL(mock_observer_, OnDialDeviceEvent(expected_list3)) 339 .Times(1); 340 341 registry_->OnListenerAdded(); 342 registry_->OnDiscoveryRequest(NULL); 343 registry_->OnDeviceDiscovered(NULL, first_device_); 344 registry_->OnDiscoveryFinished(NULL); 345 346 registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_NONE); 347 348 registry_->OnDiscoveryRequest(NULL); 349 registry_->OnDiscoveryFinished(NULL); 350 351 registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_WIFI); 352 353 registry_->OnDiscoveryRequest(NULL); 354 registry_->OnDeviceDiscovered(NULL, second_device_); 355 registry_->OnDiscoveryFinished(NULL); 356 357 registry_->OnNetworkChanged(net::NetworkChangeNotifier::CONNECTION_ETHERNET); 358 359 registry_->OnDiscoveryRequest(NULL); 360 registry_->OnDeviceDiscovered(NULL, third_device_); 361 registry_->OnDiscoveryFinished(NULL); 362 363 registry_->OnListenerRemoved(); 364 } 365 366 } // namespace extensions 367
