1 // 2 // Copyright (C) 2012 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #include "shill/wimax/wimax_provider.h" 18 19 #include <string> 20 #include <vector> 21 22 #include <base/strings/stringprintf.h> 23 #if defined(__ANDROID__) 24 #include <dbus/service_constants.h> 25 #else 26 #include <chromeos/dbus/service_constants.h> 27 #endif // __ANDROID__ 28 29 #include "shill/eap_credentials.h" 30 #include "shill/fake_store.h" 31 #include "shill/mock_device_info.h" 32 #include "shill/mock_manager.h" 33 #include "shill/mock_metrics.h" 34 #include "shill/mock_profile.h" 35 #include "shill/nice_mock_control.h" 36 #include "shill/testing.h" 37 #include "shill/wimax/mock_wimax.h" 38 #include "shill/wimax/mock_wimax_manager_proxy.h" 39 #include "shill/wimax/mock_wimax_network_proxy.h" 40 #include "shill/wimax/mock_wimax_service.h" 41 #include "shill/wimax/wimax_service.h" 42 43 using std::string; 44 using std::vector; 45 using testing::Return; 46 using testing::ReturnNull; 47 using testing::SaveArg; 48 using testing::StartsWith; 49 using testing::_; 50 51 namespace shill { 52 53 namespace { 54 55 string GetTestLinkName(int index) { 56 return base::StringPrintf("wm%d", index); 57 } 58 59 string GetTestPath(int index) { 60 return wimax_manager::kDeviceObjectPathPrefix + GetTestLinkName(index); 61 } 62 63 string GetTestNetworkPath(uint32_t identifier) { 64 return base::StringPrintf("%s%08x", 65 wimax_manager::kNetworkObjectPathPrefix, 66 identifier); 67 } 68 69 } // namespace 70 71 class WiMaxProviderTest : public testing::Test { 72 public: 73 WiMaxProviderTest() 74 : network_proxy_(new MockWiMaxNetworkProxy()), 75 metrics_(nullptr), 76 manager_(&control_, nullptr, &metrics_), 77 device_info_(&control_, nullptr, &metrics_, &manager_), 78 provider_(&control_, nullptr, &metrics_, &manager_) {} 79 80 virtual ~WiMaxProviderTest() {} 81 82 protected: 83 string GetServiceFriendlyName(const ServiceRefPtr& service) { 84 return service->friendly_name(); 85 } 86 87 std::unique_ptr<MockWiMaxNetworkProxy> network_proxy_; 88 NiceMockControl control_; 89 MockMetrics metrics_; 90 MockManager manager_; 91 MockDeviceInfo device_info_; 92 WiMaxProvider provider_; 93 }; 94 95 TEST_F(WiMaxProviderTest, StartStop) { 96 MockWiMaxManagerProxy* wimax_manager_proxy = new MockWiMaxManagerProxy(); 97 98 base::Closure service_appeared_callback; 99 EXPECT_FALSE(provider_.wimax_manager_proxy_.get()); 100 EXPECT_CALL(control_, CreateWiMaxManagerProxy(_, _)) 101 .WillOnce(DoAll(SaveArg<0>(&service_appeared_callback), 102 Return(wimax_manager_proxy))); 103 EXPECT_CALL(*wimax_manager_proxy, set_devices_changed_callback(_)).Times(1); 104 provider_.Start(); 105 EXPECT_TRUE(provider_.wimax_manager_proxy_.get()); 106 107 EXPECT_CALL(*wimax_manager_proxy, Devices(_)) 108 .WillOnce(Return(RpcIdentifiers())); 109 service_appeared_callback.Run(); 110 111 provider_.pending_devices_[GetTestLinkName(2)] = GetTestPath(2); 112 provider_.Stop(); 113 EXPECT_FALSE(provider_.wimax_manager_proxy_.get()); 114 EXPECT_TRUE(provider_.pending_devices_.empty()); 115 } 116 117 TEST_F(WiMaxProviderTest, ConnectDisconnectWiMaxManager) { 118 MockWiMaxManagerProxy* wimax_manager_proxy = new MockWiMaxManagerProxy(); 119 provider_.wimax_manager_proxy_.reset(wimax_manager_proxy); 120 121 EXPECT_CALL(*wimax_manager_proxy, Devices(_)) 122 .WillOnce(Return(RpcIdentifiers())); 123 provider_.ConnectToWiMaxManager(); 124 125 provider_.pending_devices_[GetTestLinkName(2)] = GetTestPath(2); 126 provider_.DisconnectFromWiMaxManager(); 127 EXPECT_TRUE(provider_.pending_devices_.empty()); 128 } 129 130 TEST_F(WiMaxProviderTest, OnDevicesChanged) { 131 EXPECT_CALL(manager_, device_info()).WillRepeatedly(Return(&device_info_)); 132 133 provider_.pending_devices_[GetTestLinkName(1)] = GetTestPath(1); 134 RpcIdentifiers live_devices; 135 live_devices.push_back(GetTestPath(2)); 136 live_devices.push_back(GetTestPath(3)); 137 EXPECT_CALL(device_info_, GetIndex(GetTestLinkName(2))).WillOnce(Return(-1)); 138 EXPECT_CALL(device_info_, GetIndex(GetTestLinkName(3))).WillOnce(Return(-1)); 139 provider_.OnDevicesChanged(live_devices); 140 ASSERT_EQ(2, provider_.pending_devices_.size()); 141 EXPECT_EQ(GetTestPath(2), provider_.pending_devices_[GetTestLinkName(2)]); 142 EXPECT_EQ(GetTestPath(3), provider_.pending_devices_[GetTestLinkName(3)]); 143 } 144 145 TEST_F(WiMaxProviderTest, OnDeviceInfoAvailable) { 146 EXPECT_CALL(manager_, device_info()).WillRepeatedly(Return(&device_info_)); 147 148 provider_.pending_devices_[GetTestLinkName(1)] = GetTestPath(1); 149 EXPECT_CALL(device_info_, GetIndex(GetTestLinkName(1))).WillOnce(Return(1)); 150 EXPECT_CALL(device_info_, GetMACAddress(1, _)).WillOnce(Return(true)); 151 EXPECT_CALL(device_info_, RegisterDevice(_)); 152 provider_.OnDeviceInfoAvailable(GetTestLinkName(1)); 153 EXPECT_TRUE(provider_.pending_devices_.empty()); 154 ASSERT_EQ(1, provider_.devices_.size()); 155 ASSERT_TRUE(ContainsKey(provider_.devices_, GetTestLinkName(1))); 156 EXPECT_EQ(GetTestLinkName(1), 157 provider_.devices_[GetTestLinkName(1)]->link_name()); 158 } 159 160 TEST_F(WiMaxProviderTest, CreateDevice) { 161 EXPECT_CALL(manager_, device_info()).WillRepeatedly(Return(&device_info_)); 162 163 EXPECT_CALL(device_info_, GetIndex(GetTestLinkName(1))).WillOnce(Return(-1)); 164 provider_.CreateDevice(GetTestLinkName(1), GetTestPath(1)); 165 EXPECT_TRUE(provider_.devices_.empty()); 166 ASSERT_EQ(1, provider_.pending_devices_.size()); 167 EXPECT_EQ(GetTestPath(1), provider_.pending_devices_[GetTestLinkName(1)]); 168 169 EXPECT_CALL(device_info_, GetIndex(GetTestLinkName(1))).WillOnce(Return(1)); 170 EXPECT_CALL(device_info_, GetMACAddress(1, _)).WillOnce(Return(true)); 171 EXPECT_CALL(device_info_, RegisterDevice(_)); 172 provider_.CreateDevice(GetTestLinkName(1), GetTestPath(1)); 173 EXPECT_TRUE(provider_.pending_devices_.empty()); 174 ASSERT_EQ(1, provider_.devices_.size()); 175 ASSERT_TRUE(ContainsKey(provider_.devices_, GetTestLinkName(1))); 176 EXPECT_EQ(GetTestLinkName(1), 177 provider_.devices_[GetTestLinkName(1)]->link_name()); 178 179 WiMax* device = provider_.devices_[GetTestLinkName(1)].get(); 180 provider_.CreateDevice(GetTestLinkName(1), GetTestPath(1)); 181 EXPECT_EQ(device, provider_.devices_[GetTestLinkName(1)].get()); 182 } 183 184 TEST_F(WiMaxProviderTest, DestroyDeadDevices) { 185 for (int i = 0; i < 4; i++) { 186 scoped_refptr<MockWiMax> device( 187 new MockWiMax(&control_, nullptr, &metrics_, &manager_, 188 GetTestLinkName(i), "", i, GetTestPath(i))); 189 EXPECT_CALL(*device, OnDeviceVanished()).Times((i == 0 || i == 3) ? 0 : 1); 190 provider_.devices_[GetTestLinkName(i)] = device; 191 } 192 for (int i = 4; i < 8; i++) { 193 provider_.pending_devices_[GetTestLinkName(i)] = GetTestPath(i); 194 } 195 RpcIdentifiers live_devices; 196 live_devices.push_back(GetTestPath(0)); 197 live_devices.push_back(GetTestPath(3)); 198 live_devices.push_back(GetTestPath(4)); 199 live_devices.push_back(GetTestPath(7)); 200 live_devices.push_back(GetTestPath(123)); 201 EXPECT_CALL(manager_, device_info()) 202 .Times(2) 203 .WillRepeatedly(Return(&device_info_)); 204 EXPECT_CALL(device_info_, DeregisterDevice(_)).Times(2); 205 provider_.DestroyDeadDevices(live_devices); 206 ASSERT_EQ(2, provider_.devices_.size()); 207 EXPECT_TRUE(ContainsKey(provider_.devices_, GetTestLinkName(0))); 208 EXPECT_TRUE(ContainsKey(provider_.devices_, GetTestLinkName(3))); 209 EXPECT_EQ(2, provider_.pending_devices_.size()); 210 EXPECT_TRUE(ContainsKey(provider_.pending_devices_, GetTestLinkName(4))); 211 EXPECT_TRUE(ContainsKey(provider_.pending_devices_, GetTestLinkName(7))); 212 } 213 214 TEST_F(WiMaxProviderTest, GetLinkName) { 215 EXPECT_EQ("", provider_.GetLinkName("/random/path")); 216 EXPECT_EQ(GetTestLinkName(1), provider_.GetLinkName(GetTestPath(1))); 217 } 218 219 TEST_F(WiMaxProviderTest, RetrieveNetworkInfo) { 220 static const char kName[] = "Default Network"; 221 const uint32_t kIdentifier = 0xabcdef; 222 static const char kNetworkId[] = "00abcdef"; 223 string network_path = GetTestNetworkPath(kIdentifier); 224 EXPECT_CALL(control_, CreateWiMaxNetworkProxy(network_path)) 225 .WillOnce(ReturnAndReleasePointee(&network_proxy_)); 226 EXPECT_CALL(*network_proxy_, Name(_)).WillOnce(Return(kName)); 227 EXPECT_CALL(*network_proxy_, Identifier(_)).WillOnce(Return(kIdentifier)); 228 provider_.RetrieveNetworkInfo(network_path); 229 EXPECT_EQ(1, provider_.networks_.size()); 230 EXPECT_TRUE(ContainsKey(provider_.networks_, network_path)); 231 EXPECT_EQ(kName, provider_.networks_[network_path].name); 232 EXPECT_EQ(kNetworkId, provider_.networks_[network_path].id); 233 provider_.RetrieveNetworkInfo(network_path); 234 EXPECT_EQ(1, provider_.networks_.size()); 235 } 236 237 TEST_F(WiMaxProviderTest, FindService) { 238 EXPECT_FALSE(provider_.FindService("some_storage_id")); 239 scoped_refptr<MockWiMaxService> service( 240 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_)); 241 static const char kName[] = "WiMAX Network"; 242 static const char kNetworkId[] = "76543210"; 243 service->set_friendly_name(kName); 244 service->set_network_id(kNetworkId); 245 service->InitStorageIdentifier(); 246 provider_.services_[service->GetStorageIdentifier()] = service; 247 EXPECT_EQ(service.get(), 248 provider_.FindService( 249 WiMaxService::CreateStorageIdentifier(kNetworkId, 250 kName)).get()); 251 EXPECT_FALSE(provider_.FindService("some_storage_id")); 252 } 253 254 TEST_F(WiMaxProviderTest, StartLiveServices) { 255 const uint32_t kIdentifier = 0x1234567; 256 static const char kNetworkId[] = "01234567"; 257 static const char kName[] = "Some WiMAX Provider"; 258 vector<scoped_refptr<MockWiMaxService>> services(4); 259 for (size_t i = 0; i < services.size(); i++) { 260 services[i] = 261 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_); 262 if (i == 0) { 263 services[0]->set_network_id("deadbeef"); 264 } else { 265 services[i]->set_network_id(kNetworkId); 266 } 267 // Make services[3] the default service. 268 if (i == 3) { 269 services[i]->set_friendly_name(kName); 270 } else { 271 services[i]->set_friendly_name( 272 base::StringPrintf("Configured %d", static_cast<int>(i))); 273 } 274 services[i]->InitStorageIdentifier(); 275 provider_.services_[services[i]->GetStorageIdentifier()] = services[i]; 276 } 277 WiMaxProvider::NetworkInfo info; 278 info.id = kNetworkId; 279 info.name = kName; 280 provider_.networks_[GetTestNetworkPath(kIdentifier)] = info; 281 network_proxy_.reset(); 282 EXPECT_CALL(*services[0], IsStarted()).Times(0); 283 EXPECT_CALL(*services[1], IsStarted()).WillOnce(Return(true)); 284 EXPECT_CALL(*services[1], Start(_)).Times(0); 285 EXPECT_CALL(*services[2], IsStarted()).WillOnce(Return(false)); 286 EXPECT_CALL(*services[2], Start(_)).WillOnce(Return(true)); 287 EXPECT_CALL(*services[3], IsStarted()).WillOnce(Return(false)); 288 EXPECT_CALL(*services[3], Start(_)).WillOnce(Return(false)); 289 EXPECT_CALL(manager_, RegisterService(_)).Times(0); 290 provider_.StartLiveServices(); 291 EXPECT_FALSE(services[0]->is_default()); 292 EXPECT_FALSE(services[1]->is_default()); 293 EXPECT_FALSE(services[2]->is_default()); 294 EXPECT_TRUE(services[3]->is_default()); 295 } 296 297 TEST_F(WiMaxProviderTest, DestroyAllServices) { 298 vector<scoped_refptr<MockWiMaxService>> services(2); 299 for (size_t i = 0; i < services.size(); i++) { 300 services[i] = 301 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_); 302 provider_.services_[services[i]->GetStorageIdentifier()] = services[i]; 303 EXPECT_CALL(*services[i], Stop()); 304 } 305 EXPECT_CALL(manager_, DeregisterService(_)).Times(services.size()); 306 provider_.DestroyAllServices(); 307 EXPECT_TRUE(provider_.services_.empty()); 308 } 309 310 TEST_F(WiMaxProviderTest, StopDeadServices) { 311 vector<scoped_refptr<MockWiMaxService>> services(4); 312 for (size_t i = 0; i < services.size(); i++) { 313 services[i] = 314 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_); 315 if (i == 0) { 316 EXPECT_CALL(*services[i], IsStarted()).WillOnce(Return(false)); 317 EXPECT_CALL(*services[i], GetNetworkObjectPath()).Times(0); 318 EXPECT_CALL(*services[i], Stop()).Times(0); 319 } else { 320 EXPECT_CALL(*services[i], IsStarted()).WillOnce(Return(true)); 321 EXPECT_CALL(*services[i], GetNetworkObjectPath()) 322 .WillOnce(Return(GetTestNetworkPath(100 + i))); 323 } 324 provider_.services_[services[i]->GetStorageIdentifier()] = services[i]; 325 } 326 services[3]->set_is_default(true); 327 EXPECT_CALL(*services[1], Stop()).Times(0); 328 EXPECT_CALL(*services[2], Stop()); 329 EXPECT_CALL(*services[3], Stop()); 330 EXPECT_CALL(manager_, DeregisterService(_)); 331 provider_.networks_[GetTestNetworkPath(777)].id = "01234567"; 332 provider_.networks_[GetTestNetworkPath(101)].id = "12345678"; 333 provider_.StopDeadServices(); 334 EXPECT_EQ(3, provider_.services_.size()); 335 EXPECT_FALSE(ContainsKey(provider_.services_, 336 services[3]->GetStorageIdentifier())); 337 } 338 339 TEST_F(WiMaxProviderTest, OnNetworksChanged) { 340 static const char kName[] = "Default Network"; 341 const uint32_t kIdentifier = 0xabcdef; 342 static const char kNetworkId[] = "00abcdef"; 343 344 // Started service to be stopped. 345 scoped_refptr<MockWiMaxService> service0( 346 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_)); 347 EXPECT_CALL(*service0, IsStarted()).WillOnce(Return(true)); 348 EXPECT_CALL(*service0, GetNetworkObjectPath()) 349 .WillOnce(Return(GetTestNetworkPath(100))); 350 EXPECT_CALL(*service0, Start(_)).Times(0); 351 EXPECT_CALL(*service0, Stop()).Times(1); 352 service0->set_network_id("1234"); 353 service0->InitStorageIdentifier(); 354 355 // Stopped service to be started. 356 scoped_refptr<MockWiMaxService> service1( 357 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_)); 358 EXPECT_CALL(*service1, IsStarted()).Times(2).WillRepeatedly(Return(false)); 359 EXPECT_CALL(*service1, Start(_)).WillOnce(Return(true)); 360 EXPECT_CALL(*service1, Stop()).Times(0); 361 service1->set_network_id(kNetworkId); 362 service1->set_friendly_name(kName); 363 service1->InitStorageIdentifier(); 364 EXPECT_CALL(control_, CreateWiMaxNetworkProxy(GetTestNetworkPath(101))) 365 .Times(2) 366 .WillOnce(ReturnAndReleasePointee(&network_proxy_)) 367 .WillOnce(ReturnNull()); 368 EXPECT_CALL(*network_proxy_, Name(_)).WillOnce(Return(kName)); 369 EXPECT_CALL(*network_proxy_, Identifier(_)).WillOnce(Return(kIdentifier)); 370 371 provider_.services_[service0->GetStorageIdentifier()] = service0; 372 provider_.services_[service1->GetStorageIdentifier()] = service1; 373 374 for (int i = 0; i < 3; i++) { 375 scoped_refptr<MockWiMax> device( 376 new MockWiMax(&control_, nullptr, &metrics_, &manager_, 377 GetTestLinkName(i), "", i, GetTestPath(i))); 378 provider_.devices_[GetTestLinkName(i)] = device; 379 if (i > 0) { 380 device->networks_.insert(GetTestNetworkPath(101)); 381 } 382 } 383 EXPECT_CALL(manager_, RegisterService(_)).Times(0); 384 EXPECT_CALL(manager_, DeregisterService(_)).Times(0); 385 386 provider_.networks_["/org/chromium/foo"].id = "foo"; 387 provider_.OnNetworksChanged(); 388 EXPECT_EQ(1, provider_.networks_.size()); 389 EXPECT_TRUE(ContainsKey(provider_.networks_, GetTestNetworkPath(101))); 390 } 391 392 TEST_F(WiMaxProviderTest, GetUniqueService) { 393 EXPECT_TRUE(provider_.services_.empty()); 394 395 static const char kName0[] = "Test WiMAX Network"; 396 static const char kName1[] = "Unknown Network"; 397 static const char kNetworkId[] = "12340000"; 398 399 // Service already exists. 400 scoped_refptr<MockWiMaxService> service0( 401 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_)); 402 service0->set_network_id(kNetworkId); 403 service0->set_friendly_name(kName0); 404 service0->InitStorageIdentifier(); 405 provider_.services_[service0->GetStorageIdentifier()] = service0; 406 EXPECT_CALL(manager_, RegisterService(_)).Times(0); 407 WiMaxServiceRefPtr service = provider_.GetUniqueService(kNetworkId, kName0); 408 ASSERT_TRUE(service); 409 EXPECT_EQ(service0.get(), service.get()); 410 EXPECT_EQ(1, provider_.services_.size()); 411 412 // Create a new service. 413 EXPECT_CALL(manager_, RegisterService(_)); 414 service = provider_.GetUniqueService(kNetworkId, kName1); 415 ASSERT_TRUE(service); 416 EXPECT_NE(service0.get(), service.get()); 417 EXPECT_EQ(2, provider_.services_.size()); 418 EXPECT_EQ(WiMaxService::CreateStorageIdentifier(kNetworkId, kName1), 419 service->GetStorageIdentifier()); 420 EXPECT_FALSE(service->is_default()); 421 422 // Service already exists -- it was just created. 423 EXPECT_CALL(manager_, RegisterService(_)).Times(0); 424 WiMaxServiceRefPtr service1 = provider_.GetUniqueService(kNetworkId, kName1); 425 ASSERT_TRUE(service1); 426 EXPECT_EQ(service.get(), service1.get()); 427 EXPECT_EQ(2, provider_.services_.size()); 428 EXPECT_FALSE(service->is_default()); 429 } 430 431 TEST_F(WiMaxProviderTest, CreateServicesFromProfile) { 432 FakeStore store; 433 store.SetString("no_type", "Name", "No Type Entry"); 434 store.SetString("no_wimax", "Type", "vpn"); 435 store.SetString("wimax_network_01234567", "Name", "network"); 436 store.SetString("wimax_network_01234567", "Type", "wimax"); 437 store.SetString("wimax_network_01234567", "NetworkId", "01234567"); 438 store.SetString("no_network_id", "Type", "wimax"); 439 store.SetString("no_name", "Type", "wimax"); 440 store.SetString("no_name", "NetworkId", "76543210"); 441 442 scoped_refptr<MockProfile> profile( 443 new MockProfile(&control_, &metrics_, &manager_)); 444 EXPECT_CALL(*profile, GetConstStorage()) 445 .Times(2) 446 .WillRepeatedly(Return(&store)); 447 EXPECT_CALL(manager_, RegisterService(_)); 448 EXPECT_CALL(*profile, ConfigureService(_)).WillOnce(Return(true)); 449 provider_.CreateServicesFromProfile(profile); 450 ASSERT_EQ(1, provider_.services_.size()); 451 452 WiMaxServiceRefPtr service = provider_.services_.begin()->second; 453 EXPECT_EQ("wimax_network_01234567", service->GetStorageIdentifier()); 454 provider_.CreateServicesFromProfile(profile); 455 ASSERT_EQ(1, provider_.services_.size()); 456 EXPECT_EQ(service.get(), provider_.services_.begin()->second); 457 } 458 459 TEST_F(WiMaxProviderTest, CreateTemporaryServiceFromProfile) { 460 FakeStore store; 461 store.SetString("no_type", "Name", "No Type Entry"); 462 store.SetString("no_wimax", "Type", "vpn"); 463 store.SetString("wimax_network_01234567", "Name", "network"); 464 store.SetString("wimax_network_01234567", "Type", "wimax"); 465 store.SetString("wimax_network_01234567", "NetworkId", "01234567"); 466 store.SetString("no_network_id", "Type", "wimax"); 467 store.SetString("no_name", "Type", "wimax"); 468 store.SetString("no_name", "NetworkId", "76543210"); 469 scoped_refptr<MockProfile> profile( 470 new MockProfile(&control_, &metrics_, &manager_)); 471 EXPECT_CALL(*profile, GetConstStorage()) 472 .WillRepeatedly(Return(&store)); 473 Error error; 474 475 // Network type not specified. 476 EXPECT_EQ(nullptr, 477 provider_.CreateTemporaryServiceFromProfile(profile, 478 "no_type", 479 &error)); 480 EXPECT_FALSE(error.IsSuccess()); 481 EXPECT_THAT(error.message(), 482 StartsWith("Unspecified or invalid network type")); 483 484 // Not a WiMAX network. 485 error.Reset(); 486 EXPECT_EQ(nullptr, 487 provider_.CreateTemporaryServiceFromProfile(profile, 488 "no_wimax", 489 &error)); 490 EXPECT_FALSE(error.IsSuccess()); 491 EXPECT_THAT(error.message(), 492 StartsWith("Unspecified or invalid network type")); 493 494 // WiMAX network with required properties. 495 error.Reset(); 496 EXPECT_TRUE( 497 provider_.CreateTemporaryServiceFromProfile(profile, 498 "wimax_network_01234567", 499 &error)); 500 EXPECT_TRUE(error.IsSuccess()); 501 502 // Network ID not specified. 503 error.Reset(); 504 EXPECT_EQ(nullptr, 505 provider_.CreateTemporaryServiceFromProfile(profile, 506 "no_network_id", 507 &error)); 508 EXPECT_FALSE(error.IsSuccess()); 509 EXPECT_THAT(error.message(), 510 StartsWith("Network ID not specified")); 511 512 // Network name not specified. 513 error.Reset(); 514 EXPECT_EQ(nullptr, 515 provider_.CreateTemporaryServiceFromProfile(profile, 516 "no_name", 517 &error)); 518 EXPECT_FALSE(error.IsSuccess()); 519 EXPECT_THAT(error.message(), 520 StartsWith("Network name not specified")); 521 } 522 523 TEST_F(WiMaxProviderTest, GetService) { 524 KeyValueStore args; 525 Error e; 526 527 args.SetString(kTypeProperty, kTypeWimax); 528 529 // No network id property. 530 ServiceRefPtr service = provider_.GetService(args, &e); 531 EXPECT_EQ(Error::kInvalidArguments, e.type()); 532 EXPECT_FALSE(service); 533 534 // No name property. 535 static const char kNetworkId[] = "1234abcd"; 536 args.SetString(WiMaxService::kNetworkIdProperty, kNetworkId); 537 e.Reset(); 538 service = provider_.GetService(args, &e); 539 EXPECT_EQ(Error::kInvalidArguments, e.type()); 540 EXPECT_FALSE(service); 541 542 // Service created and configured. 543 static const char kName[] = "Test WiMAX Network"; 544 args.SetString(kNameProperty, kName); 545 static const char kIdentity[] = "joe"; 546 args.SetString(kEapIdentityProperty, kIdentity); 547 548 e.Reset(); 549 service = provider_.FindSimilarService(args, &e); 550 EXPECT_EQ(ServiceRefPtr(), service); 551 EXPECT_EQ(Error::kNotFound, e.type()); 552 553 e.Reset(); 554 EXPECT_CALL(manager_, RegisterService(_)); 555 service = provider_.GetService(args, &e); 556 EXPECT_TRUE(e.IsSuccess()); 557 ASSERT_TRUE(service); 558 testing::Mock::VerifyAndClearExpectations(&manager_); 559 560 // GetService should create a service with only identifying parameters set. 561 EXPECT_EQ(kName, GetServiceFriendlyName(service)); 562 EXPECT_EQ("", service->eap()->identity()); 563 564 e.Reset(); 565 ServiceRefPtr similar_service = provider_.FindSimilarService(args, &e); 566 EXPECT_EQ(service, similar_service); 567 EXPECT_TRUE(e.IsSuccess()); 568 569 // After configuring the service, other parameters should be set. 570 service->Configure(args, &e); 571 EXPECT_TRUE(e.IsSuccess()); 572 EXPECT_EQ(kIdentity, service->eap()->identity()); 573 574 e.Reset(); 575 EXPECT_CALL(manager_, RegisterService(_)).Times(0); 576 ServiceRefPtr temporary_service = provider_.CreateTemporaryService(args, &e); 577 EXPECT_NE(ServiceRefPtr(), temporary_service); 578 EXPECT_NE(service, temporary_service); 579 EXPECT_TRUE(e.IsSuccess()); 580 } 581 582 TEST_F(WiMaxProviderTest, SelectCarrier) { 583 scoped_refptr<MockWiMaxService> service( 584 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_)); 585 EXPECT_FALSE(provider_.SelectCarrier(service)); 586 scoped_refptr<MockWiMax> device( 587 new MockWiMax(&control_, nullptr, &metrics_, &manager_, 588 GetTestLinkName(1), "", 1, GetTestPath(1))); 589 provider_.devices_[GetTestLinkName(1)] = device; 590 WiMaxRefPtr carrier = provider_.SelectCarrier(service); 591 EXPECT_EQ(device.get(), carrier.get()); 592 } 593 594 TEST_F(WiMaxProviderTest, OnServiceUnloaded) { 595 scoped_refptr<MockWiMaxService> service( 596 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_)); 597 EXPECT_FALSE(service->is_default()); 598 scoped_refptr<MockWiMaxService> service_default( 599 new MockWiMaxService(&control_, nullptr, &metrics_, &manager_)); 600 service_default->set_is_default(true); 601 provider_.services_[service->GetStorageIdentifier()] = service; 602 provider_.services_[service_default->GetStorageIdentifier()] = 603 service_default; 604 EXPECT_CALL(manager_, DeregisterService(_)).Times(0); 605 EXPECT_FALSE(provider_.OnServiceUnloaded(service_default)); 606 EXPECT_EQ(2, provider_.services_.size()); 607 EXPECT_TRUE(provider_.OnServiceUnloaded(service)); 608 EXPECT_EQ(1, provider_.services_.size()); 609 EXPECT_EQ(service_default.get(), provider_.services_.begin()->second.get()); 610 } 611 612 } // namespace shill 613