blob: ec592bc540f0b22bc83b9e5eb516a221487bdc36 [file] [log] [blame]
Arman Ugurayf4c61812013-01-10 18:58:39 -08001// Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
Jason Glasgowef965562012-04-10 16:12:35 -04002// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "shill/cellular_capability_universal.h"
6
Nathan Williams4b7c2a82012-04-13 15:19:47 -04007#include <string>
8#include <vector>
9
Jason Glasgowef965562012-04-10 16:12:35 -040010#include <base/bind.h>
Darin Petkova4ca3c32012-08-17 16:05:24 +020011#include <base/stringprintf.h>
Jason Glasgowef965562012-04-10 16:12:35 -040012#include <chromeos/dbus/service_constants.h>
13#include <gtest/gtest.h>
14#include <mobile_provider.h>
Ben Chan5c853ef2012-10-05 00:05:37 -070015#include <ModemManager/ModemManager.h>
Jason Glasgowef965562012-04-10 16:12:35 -040016
17#include "shill/cellular.h"
18#include "shill/cellular_service.h"
Jason Glasgowaf583282012-04-18 15:18:22 -040019#include "shill/dbus_adaptor.h"
Jason Glasgowef965562012-04-10 16:12:35 -040020#include "shill/error.h"
21#include "shill/event_dispatcher.h"
22#include "shill/mock_adaptors.h"
Ben Chan15786032012-11-04 21:28:02 -080023#include "shill/mock_cellular_operator_info.h"
Jason Glasgow14521872012-05-07 19:12:15 -040024#include "shill/mock_cellular_service.h"
Jason Glasgowaf583282012-04-18 15:18:22 -040025#include "shill/mock_dbus_properties_proxy.h"
Jason Glasgowef965562012-04-10 16:12:35 -040026#include "shill/mock_glib.h"
27#include "shill/mock_manager.h"
28#include "shill/mock_metrics.h"
Arman Uguray6e5639f2012-11-15 20:30:19 -080029#include "shill/mock_mm1_bearer_proxy.h"
Jason Glasgowef965562012-04-10 16:12:35 -040030#include "shill/mock_mm1_modem_modem3gpp_proxy.h"
31#include "shill/mock_mm1_modem_modemcdma_proxy.h"
32#include "shill/mock_mm1_modem_proxy.h"
33#include "shill/mock_mm1_modem_simple_proxy.h"
34#include "shill/mock_mm1_sim_proxy.h"
35#include "shill/mock_profile.h"
36#include "shill/mock_rtnl_handler.h"
37#include "shill/nice_mock_control.h"
38#include "shill/proxy_factory.h"
39
40using base::Bind;
Darin Petkova4ca3c32012-08-17 16:05:24 +020041using base::StringPrintf;
Jason Glasgowef965562012-04-10 16:12:35 -040042using base::Unretained;
43using std::string;
Nathan Williams4b7c2a82012-04-13 15:19:47 -040044using std::vector;
Jason Glasgowef965562012-04-10 16:12:35 -040045using testing::InSequence;
Ben Chan6d0d1e72012-11-06 21:19:28 -080046using testing::Invoke;
Gary Moraine285a842012-08-15 08:23:57 -070047using testing::Mock;
Jason Glasgowef965562012-04-10 16:12:35 -040048using testing::NiceMock;
49using testing::Return;
Jason Glasgowcd0349c2012-05-03 23:32:15 -040050using testing::SaveArg;
Jason Glasgowef965562012-04-10 16:12:35 -040051using testing::_;
52
53namespace shill {
54
55MATCHER(IsSuccess, "") {
56 return arg.IsSuccess();
57}
58MATCHER(IsFailure, "") {
59 return arg.IsFailure();
60}
Jason Glasgow14521872012-05-07 19:12:15 -040061MATCHER_P(HasApn, expected_apn, "") {
62 string apn;
63 return (DBusProperties::GetString(arg,
64 CellularCapabilityUniversal::kConnectApn,
65 &apn) &&
66 apn == expected_apn);
67}
Jason Glasgowef965562012-04-10 16:12:35 -040068
69class CellularCapabilityUniversalTest : public testing::Test {
70 public:
71 CellularCapabilityUniversalTest()
72 : manager_(&control_, &dispatcher_, &metrics_, &glib_),
Arman Uguray6e5639f2012-11-15 20:30:19 -080073 bearer_proxy_(new mm1::MockBearerProxy()),
Ben Chan3ecdf822012-08-06 12:29:23 -070074 modem_3gpp_proxy_(new mm1::MockModemModem3gppProxy()),
75 modem_cdma_proxy_(new mm1::MockModemModemCdmaProxy()),
76 modem_proxy_(new mm1::MockModemProxy()),
77 modem_simple_proxy_(new mm1::MockModemSimpleProxy()),
78 sim_proxy_(new mm1::MockSimProxy()),
79 properties_proxy_(new MockDBusPropertiesProxy()),
80 proxy_factory_(this),
81 capability_(NULL),
82 device_adaptor_(NULL),
83 provider_db_(NULL),
Jason Glasgowef965562012-04-10 16:12:35 -040084 cellular_(new Cellular(&control_,
85 &dispatcher_,
86 NULL,
87 &manager_,
88 "",
89 "",
90 0,
91 Cellular::kTypeUniversal,
92 "",
93 "",
Jason Glasgowa585fc32012-06-06 11:04:09 -040094 "",
Ben Chan3ecdf822012-08-06 12:29:23 -070095 NULL,
Ben Chan62028b22012-11-05 11:20:02 -080096 NULL,
Ben Chan3ecdf822012-08-06 12:29:23 -070097 &proxy_factory_)),
Jason Glasgow14521872012-05-07 19:12:15 -040098 service_(new MockCellularService(&control_,
99 &dispatcher_,
100 &metrics_,
101 &manager_,
Ben Chan3ecdf822012-08-06 12:29:23 -0700102 cellular_)) {}
Jason Glasgowef965562012-04-10 16:12:35 -0400103
104 virtual ~CellularCapabilityUniversalTest() {
105 cellular_->service_ = NULL;
106 capability_ = NULL;
107 device_adaptor_ = NULL;
Darin Petkovb4fccd22012-08-10 11:59:26 +0200108 if (provider_db_) {
109 mobile_provider_close_db(provider_db_);
110 provider_db_ = NULL;
111 }
Jason Glasgowef965562012-04-10 16:12:35 -0400112 }
113
114 virtual void SetUp() {
115 capability_ = dynamic_cast<CellularCapabilityUniversal *>(
116 cellular_->capability_.get());
Jason Glasgowef965562012-04-10 16:12:35 -0400117 device_adaptor_ =
118 dynamic_cast<NiceMock<DeviceMockAdaptor> *>(cellular_->adaptor());
Jason Glasgow14521872012-05-07 19:12:15 -0400119 cellular_->service_ = service_;
Jason Glasgowef965562012-04-10 16:12:35 -0400120 }
121
122 virtual void TearDown() {
123 capability_->proxy_factory_ = NULL;
124 }
125
Darin Petkova4ca3c32012-08-17 16:05:24 +0200126 void SetService() {
127 cellular_->service_ = new CellularService(
128 &control_, &dispatcher_, &metrics_, NULL, cellular_);
129 }
130
Jason Glasgow4380f0d2012-05-03 18:05:04 -0400131 void InitProviderDB() {
132 const char kTestMobileProviderDBPath[] = "provider_db_unittest.bfd";
133
134 provider_db_ = mobile_provider_open_db(kTestMobileProviderDBPath);
135 ASSERT_TRUE(provider_db_);
136 cellular_->provider_db_ = provider_db_;
137 }
138
Jason Glasgowef965562012-04-10 16:12:35 -0400139 void InvokeEnable(bool enable, Error *error,
140 const ResultCallback &callback, int timeout) {
141 callback.Run(Error());
142 }
143 void InvokeEnableFail(bool enable, Error *error,
144 const ResultCallback &callback, int timeout) {
145 callback.Run(Error(Error::kOperationFailed));
146 }
Jason Glasgowaf583282012-04-18 15:18:22 -0400147 void InvokeRegister(const string &operator_id, Error *error,
148 const ResultCallback &callback, int timeout) {
149 callback.Run(Error());
150 }
151
Gary Morainceba6aa2012-05-03 10:28:26 -0700152 void InvokeScan(Error *error, const DBusPropertyMapsCallback &callback,
153 int timeout) {
154 callback.Run(CellularCapabilityUniversal::ScanResults(), Error());
155 }
Jason Glasgowcd0349c2012-05-03 23:32:15 -0400156 void ScanError(Error *error, const DBusPropertyMapsCallback &callback,
157 int timeout) {
158 error->Populate(Error::kOperationFailed);
159 }
Gary Morainceba6aa2012-05-03 10:28:26 -0700160
161 void Set3gppProxy() {
162 capability_->modem_3gpp_proxy_.reset(modem_3gpp_proxy_.release());
163 }
164
Jason Glasgow14521872012-05-07 19:12:15 -0400165 void SetSimpleProxy() {
166 capability_->modem_simple_proxy_.reset(modem_simple_proxy_.release());
167 }
168
Thieu Le3d275392012-07-20 15:32:58 -0700169 void ReleaseCapabilityProxies() {
170 capability_->ReleaseProxies();
171 }
172
Jason Glasgowef965562012-04-10 16:12:35 -0400173 MOCK_METHOD1(TestCallback, void(const Error &error));
174
175 protected:
Arman Uguray6e5639f2012-11-15 20:30:19 -0800176 static const char kActiveBearerPathPrefix[];
Jason Glasgowef965562012-04-10 16:12:35 -0400177 static const char kImei[];
Arman Uguray6e5639f2012-11-15 20:30:19 -0800178 static const char kInactiveBearerPathPrefix[];
Jason Glasgowaf583282012-04-18 15:18:22 -0400179 static const char kSimPath[];
180 static const uint32 kAccessTechnologies;
Jason Glasgowef965562012-04-10 16:12:35 -0400181
182 class TestProxyFactory : public ProxyFactory {
183 public:
184 explicit TestProxyFactory(CellularCapabilityUniversalTest *test) :
185 test_(test) {}
186
Arman Uguray6e5639f2012-11-15 20:30:19 -0800187 virtual mm1::BearerProxyInterface *CreateBearerProxy(
188 const std::string &path,
189 const std::string &/*service*/) {
190 mm1::MockBearerProxy *bearer_proxy = test_->bearer_proxy_.release();
191 if (path.find(kActiveBearerPathPrefix) != std::string::npos)
192 ON_CALL(*bearer_proxy, Connected()).WillByDefault(Return(true));
193 else
194 ON_CALL(*bearer_proxy, Connected()).WillByDefault(Return(false));
195 test_->bearer_proxy_.reset(new mm1::MockBearerProxy());
196 return bearer_proxy;
197 }
198
Jason Glasgowef965562012-04-10 16:12:35 -0400199 virtual mm1::ModemModem3gppProxyInterface *CreateMM1ModemModem3gppProxy(
Arman Uguray6e5639f2012-11-15 20:30:19 -0800200 const std::string &/*path*/,
201 const std::string &/*service*/) {
Jason Glasgowef965562012-04-10 16:12:35 -0400202 return test_->modem_3gpp_proxy_.release();
203 }
204
205 virtual mm1::ModemModemCdmaProxyInterface *CreateMM1ModemModemCdmaProxy(
Arman Uguray6e5639f2012-11-15 20:30:19 -0800206 const std::string &/*path*/,
207 const std::string &/*service*/) {
Jason Glasgowef965562012-04-10 16:12:35 -0400208 return test_->modem_cdma_proxy_.release();
209 }
210
211 virtual mm1::ModemProxyInterface *CreateMM1ModemProxy(
Arman Uguray6e5639f2012-11-15 20:30:19 -0800212 const std::string &/*path*/,
213 const std::string &/*service*/) {
Jason Glasgowef965562012-04-10 16:12:35 -0400214 return test_->modem_proxy_.release();
215 }
216
217 virtual mm1::ModemSimpleProxyInterface *CreateMM1ModemSimpleProxy(
Arman Uguray6e5639f2012-11-15 20:30:19 -0800218 const std::string &/*path*/,
219 const std::string &/*service*/) {
Jason Glasgowef965562012-04-10 16:12:35 -0400220 return test_->modem_simple_proxy_.release();
221 }
222
223 virtual mm1::SimProxyInterface *CreateSimProxy(
Arman Uguray6e5639f2012-11-15 20:30:19 -0800224 const std::string &/*path*/,
225 const std::string &/*service*/) {
Jason Glasgowef965562012-04-10 16:12:35 -0400226 return test_->sim_proxy_.release();
227 }
Jason Glasgowaf583282012-04-18 15:18:22 -0400228 virtual DBusPropertiesProxyInterface *CreateDBusPropertiesProxy(
Arman Uguray6e5639f2012-11-15 20:30:19 -0800229 const std::string &/*path*/,
230 const std::string &/*service*/) {
Jason Glasgowaf583282012-04-18 15:18:22 -0400231 return test_->properties_proxy_.release();
232 }
Jason Glasgowef965562012-04-10 16:12:35 -0400233
234 private:
235 CellularCapabilityUniversalTest *test_;
236 };
237
238 NiceMockControl control_;
239 EventDispatcher dispatcher_;
240 MockMetrics metrics_;
241 MockGLib glib_;
242 MockManager manager_;
Arman Uguray6e5639f2012-11-15 20:30:19 -0800243 scoped_ptr<mm1::MockBearerProxy> bearer_proxy_;
Jason Glasgowef965562012-04-10 16:12:35 -0400244 scoped_ptr<mm1::MockModemModem3gppProxy> modem_3gpp_proxy_;
245 scoped_ptr<mm1::MockModemModemCdmaProxy> modem_cdma_proxy_;
246 scoped_ptr<mm1::MockModemProxy> modem_proxy_;
247 scoped_ptr<mm1::MockModemSimpleProxy> modem_simple_proxy_;
248 scoped_ptr<mm1::MockSimProxy> sim_proxy_;
Jason Glasgowaf583282012-04-18 15:18:22 -0400249 scoped_ptr<MockDBusPropertiesProxy> properties_proxy_;
Jason Glasgowef965562012-04-10 16:12:35 -0400250 TestProxyFactory proxy_factory_;
251 CellularCapabilityUniversal *capability_; // Owned by |cellular_|.
252 NiceMock<DeviceMockAdaptor> *device_adaptor_; // Owned by |cellular_|.
Ben Chan15786032012-11-04 21:28:02 -0800253 MockCellularOperatorInfo cellular_operator_info_;
Jason Glasgow4380f0d2012-05-03 18:05:04 -0400254 mobile_provider_db *provider_db_;
Ben Chan3ecdf822012-08-06 12:29:23 -0700255 CellularRefPtr cellular_;
256 MockCellularService *service_; // owned by cellular_
Jason Glasgowcd0349c2012-05-03 23:32:15 -0400257 DBusPropertyMapsCallback scan_callback_; // saved for testing scan operations
Jason Glasgow14521872012-05-07 19:12:15 -0400258 DBusPathCallback connect_callback_; // saved for testing connect operations
Jason Glasgowef965562012-04-10 16:12:35 -0400259};
260
Arman Uguray6e5639f2012-11-15 20:30:19 -0800261const char CellularCapabilityUniversalTest::kActiveBearerPathPrefix[] =
262 "/bearer/active";
Jason Glasgowef965562012-04-10 16:12:35 -0400263const char CellularCapabilityUniversalTest::kImei[] = "999911110000";
Arman Uguray6e5639f2012-11-15 20:30:19 -0800264const char CellularCapabilityUniversalTest::kInactiveBearerPathPrefix[] =
265 "/bearer/inactive";
Jason Glasgowaf583282012-04-18 15:18:22 -0400266const char CellularCapabilityUniversalTest::kSimPath[] = "/foo/sim";
267const uint32 CellularCapabilityUniversalTest::kAccessTechnologies =
268 MM_MODEM_ACCESS_TECHNOLOGY_LTE |
269 MM_MODEM_ACCESS_TECHNOLOGY_HSPA_PLUS;
Jason Glasgowef965562012-04-10 16:12:35 -0400270
271TEST_F(CellularCapabilityUniversalTest, StartModem) {
Jason Glasgowaf583282012-04-18 15:18:22 -0400272 // Set up mock modem properties
273 DBusPropertiesMap modem_properties;
274 string operator_name = "TestOperator";
275 string operator_code = "001400";
276
277 modem_properties[MM_MODEM_PROPERTY_ACCESSTECHNOLOGIES].
278 writer().append_uint32(kAccessTechnologies);
279
280 ::DBus::Variant v;
281 ::DBus::MessageIter writer = v.writer();
Jason Glasgowef965562012-04-10 16:12:35 -0400282 ::DBus::Struct< uint32_t, bool > quality;
283 quality._1 = 90;
284 quality._2 = true;
Jason Glasgowaf583282012-04-18 15:18:22 -0400285 writer << quality;
286 modem_properties[MM_MODEM_PROPERTY_SIGNALQUALITY] = v;
287
288 // Set up mock modem 3gpp properties
289 DBusPropertiesMap modem3gpp_properties;
290 modem3gpp_properties[MM_MODEM_MODEM3GPP_PROPERTY_ENABLEDFACILITYLOCKS].
291 writer().append_uint32(0);
292 modem3gpp_properties[MM_MODEM_MODEM3GPP_PROPERTY_IMEI].
293 writer().append_string(kImei);
294
295 EXPECT_CALL(*modem_proxy_,
296 Enable(true, _, _, CellularCapability::kTimeoutEnable))
297 .WillOnce(Invoke(this, &CellularCapabilityUniversalTest::InvokeEnable));
298 EXPECT_CALL(*properties_proxy_,
299 GetAll(MM_DBUS_INTERFACE_MODEM))
300 .WillOnce(Return(modem_properties));
301 EXPECT_CALL(*properties_proxy_,
302 GetAll(MM_DBUS_INTERFACE_MODEM_MODEM3GPP))
303 .WillOnce(Return(modem3gpp_properties));
Jason Glasgowef965562012-04-10 16:12:35 -0400304
Gary Moraine285a842012-08-15 08:23:57 -0700305 // Let the modem report that it is initializing. StartModem() should defer
306 // enabling the modem until its state changes to disabled.
307 EXPECT_CALL(*modem_proxy_, State())
308 .WillOnce(Return(Cellular::kModemStateInitializing));
309
Jason Glasgowef965562012-04-10 16:12:35 -0400310 // After setup we lose pointers to the proxies, so it is hard to set
311 // expectations.
312 SetUp();
313
314 Error error;
Gary Moraine285a842012-08-15 08:23:57 -0700315 EXPECT_CALL(*this, TestCallback(_)).Times(0);
Jason Glasgowef965562012-04-10 16:12:35 -0400316 ResultCallback callback =
317 Bind(&CellularCapabilityUniversalTest::TestCallback, Unretained(this));
318 capability_->StartModem(&error, callback);
Gary Moraine285a842012-08-15 08:23:57 -0700319
Arman Uguray6e5639f2012-11-15 20:30:19 -0800320 // Verify that the modem has not been enabled.
Gary Moraine285a842012-08-15 08:23:57 -0700321 EXPECT_TRUE(capability_->imei_.empty());
322 EXPECT_EQ(0, capability_->access_technologies_);
323 Mock::VerifyAndClearExpectations(this);
324
325 // Change the state to kModemStateDisabling and verify that it still has not
Arman Uguray6e5639f2012-11-15 20:30:19 -0800326 // been enabled.
Gary Moraine285a842012-08-15 08:23:57 -0700327 EXPECT_CALL(*this, TestCallback(_)).Times(0);
328 capability_->OnModemStateChangedSignal(Cellular::kModemStateInitializing,
329 Cellular::kModemStateDisabling, 0);
330 EXPECT_TRUE(capability_->imei_.empty());
331 EXPECT_EQ(0, capability_->access_technologies_);
332 Mock::VerifyAndClearExpectations(this);
333
334 // Change the state of the modem to disabled and verify that it gets enabled.
335 EXPECT_CALL(*this, TestCallback(IsSuccess()));
336 capability_->OnModemStateChangedSignal(Cellular::kModemStateDisabling,
337 Cellular::kModemStateDisabled, 0);
Jason Glasgowef965562012-04-10 16:12:35 -0400338 EXPECT_TRUE(error.IsSuccess());
Jason Glasgowaf583282012-04-18 15:18:22 -0400339 EXPECT_EQ(kImei, capability_->imei_);
340 EXPECT_EQ(kAccessTechnologies, capability_->access_technologies_);
Jason Glasgowef965562012-04-10 16:12:35 -0400341}
342
343TEST_F(CellularCapabilityUniversalTest, StartModemFail) {
Gary Moraine285a842012-08-15 08:23:57 -0700344 EXPECT_CALL(*modem_proxy_, State())
345 .WillOnce(Return(Cellular::kModemStateDisabled));
Jason Glasgowef965562012-04-10 16:12:35 -0400346 EXPECT_CALL(*modem_proxy_,
347 Enable(true, _, _, CellularCapability::kTimeoutEnable))
348 .WillOnce(
349 Invoke(this, &CellularCapabilityUniversalTest::InvokeEnableFail));
350 EXPECT_CALL(*this, TestCallback(IsFailure()));
351 ResultCallback callback =
352 Bind(&CellularCapabilityUniversalTest::TestCallback, Unretained(this));
353 SetUp();
354
355 Error error;
356 capability_->StartModem(&error, callback);
Thieu Lee3b36592012-08-30 17:50:26 -0700357 EXPECT_TRUE(error.IsOngoing());
Jason Glasgowef965562012-04-10 16:12:35 -0400358}
359
Jason Glasgow02401cc2012-05-16 10:35:37 -0400360TEST_F(CellularCapabilityUniversalTest, StopModem) {
361 // Save pointers to proxies before they are lost by the call to InitProxies
362 mm1::MockModemProxy *modem_proxy = modem_proxy_.get();
363 SetUp();
364 EXPECT_CALL(*modem_proxy, set_state_changed_callback(_));
365 capability_->InitProxies();
366
367 Error error;
368 ResultCallback callback =
369 Bind(&CellularCapabilityUniversalTest::TestCallback, Unretained(this));
370 capability_->StopModem(&error, callback);
371 EXPECT_TRUE(error.IsSuccess());
372
373 ResultCallback disable_callback;
374 EXPECT_CALL(*modem_proxy,
375 Enable(false, _, _, CellularCapability::kTimeoutEnable))
376 .WillOnce(SaveArg<2>(&disable_callback));
377 dispatcher_.DispatchPendingEvents();
378
379 EXPECT_CALL(*this, TestCallback(IsSuccess()));
380 disable_callback.Run(Error(Error::kSuccess));
381}
382
383TEST_F(CellularCapabilityUniversalTest, StopModemConnected) {
384 // Save pointers to proxies before they are lost by the call to InitProxies
385 mm1::MockModemProxy *modem_proxy = modem_proxy_.get();
386 mm1::MockModemSimpleProxy *modem_simple_proxy = modem_simple_proxy_.get();
387 SetUp();
388 EXPECT_CALL(*modem_proxy, set_state_changed_callback(_));
389 capability_->InitProxies();
390
391 ResultCallback disconnect_callback;
392 Error error;
393 ResultCallback callback =
394 Bind(&CellularCapabilityUniversalTest::TestCallback, Unretained(this));
395 EXPECT_CALL(*modem_simple_proxy,
396 Disconnect(::DBus::Path("/"), _, _,
Thieu Le049adb52012-11-12 17:14:51 -0800397 CellularCapability::kTimeoutDisconnect))
Jason Glasgow02401cc2012-05-16 10:35:37 -0400398 .WillOnce(SaveArg<2>(&disconnect_callback));
Thieu Led0012052012-07-25 16:09:09 -0700399 capability_->cellular()->modem_state_ = Cellular::kModemStateConnected;
Jason Glasgow02401cc2012-05-16 10:35:37 -0400400 capability_->StopModem(&error, callback);
401 EXPECT_TRUE(error.IsSuccess());
402
403 ResultCallback disable_callback;
404 EXPECT_CALL(*modem_proxy,
405 Enable(false, _, _, CellularCapability::kTimeoutEnable))
406 .WillOnce(SaveArg<2>(&disable_callback));
407 disconnect_callback.Run(Error(Error::kSuccess));
408
409 EXPECT_CALL(*this, TestCallback(IsSuccess()));
410 disable_callback.Run(Error(Error::kSuccess));
411}
412
Thieu Le5d6864a2012-07-20 11:43:51 -0700413TEST_F(CellularCapabilityUniversalTest, DisconnectModemNoBearer) {
414 Error error;
415 ResultCallback disconnect_callback;
Thieu Le3d275392012-07-20 15:32:58 -0700416 EXPECT_CALL(*modem_simple_proxy_,
Thieu Le049adb52012-11-12 17:14:51 -0800417 Disconnect(_, _, _, CellularCapability::kTimeoutDisconnect))
Thieu Le5d6864a2012-07-20 11:43:51 -0700418 .Times(0);
419 capability_->Disconnect(&error, disconnect_callback);
420}
421
Thieu Le3d275392012-07-20 15:32:58 -0700422TEST_F(CellularCapabilityUniversalTest, DisconnectNoProxy) {
423 Error error;
424 ResultCallback disconnect_callback;
425 capability_->bearer_path_ = "/foo";
426 EXPECT_CALL(*modem_simple_proxy_,
Thieu Le049adb52012-11-12 17:14:51 -0800427 Disconnect(_, _, _, CellularCapability::kTimeoutDisconnect))
Thieu Le3d275392012-07-20 15:32:58 -0700428 .Times(0);
429 ReleaseCapabilityProxies();
430 capability_->Disconnect(&error, disconnect_callback);
431}
432
Arman Ugurayab9364e2012-12-19 20:45:25 -0800433TEST_F(CellularCapabilityUniversalTest, SimLockStatusChanged) {
434 // Set up mock SIM properties
435 const char kImsi[] = "310100000001";
436 const char kSimIdentifier[] = "9999888";
437 const char kOperatorIdentifier[] = "310240";
438 const char kOperatorName[] = "Custom SPN";
439 DBusPropertiesMap sim_properties;
440 sim_properties[MM_SIM_PROPERTY_IMSI].writer().append_string(kImsi);
441 sim_properties[MM_SIM_PROPERTY_SIMIDENTIFIER].writer()
442 .append_string(kSimIdentifier);
443 sim_properties[MM_SIM_PROPERTY_OPERATORIDENTIFIER].writer()
444 .append_string(kOperatorIdentifier);
445 sim_properties[MM_SIM_PROPERTY_OPERATORNAME].writer()
446 .append_string(kOperatorName);
447
448 EXPECT_CALL(*properties_proxy_, GetAll(MM_DBUS_INTERFACE_SIM))
449 .WillOnce(Return(sim_properties));
450
451 SetUp();
452 InitProviderDB();
453
454 EXPECT_FALSE(capability_->sim_present_);
455 EXPECT_TRUE(capability_->sim_proxy_ == NULL);
456
457 capability_->OnSimPathChanged(kSimPath);
458 EXPECT_TRUE(capability_->sim_present_);
459 EXPECT_TRUE(capability_->sim_proxy_ != NULL);
460 EXPECT_EQ(kSimPath, capability_->sim_path_);
461
462 capability_->imsi_ = "";
463 capability_->sim_identifier_ = "";
464 capability_->operator_id_ = "";
465 capability_->spn_ = "";
466
467 // SIM is locked.
468 capability_->sim_lock_status_.lock_type = "sim-pin";
469 capability_->OnSimLockStatusChanged();
470
471 EXPECT_EQ("", capability_->imsi_);
472 EXPECT_EQ("", capability_->sim_identifier_);
473 EXPECT_EQ("", capability_->operator_id_);
474 EXPECT_EQ("", capability_->spn_);
475
476 // SIM is unlocked.
477 properties_proxy_.reset(new MockDBusPropertiesProxy());
478 EXPECT_CALL(*properties_proxy_, GetAll(MM_DBUS_INTERFACE_SIM))
479 .WillOnce(Return(sim_properties));
480
481 capability_->sim_lock_status_.lock_type = "";
482 capability_->OnSimLockStatusChanged();
483
484 EXPECT_EQ(kImsi, capability_->imsi_);
485 EXPECT_EQ(kSimIdentifier, capability_->sim_identifier_);
486 EXPECT_EQ(kOperatorIdentifier, capability_->operator_id_);
487 EXPECT_EQ(kOperatorName, capability_->spn_);
488}
489
Jason Glasgowaf583282012-04-18 15:18:22 -0400490TEST_F(CellularCapabilityUniversalTest, PropertiesChanged) {
491 // Set up mock modem properties
492 DBusPropertiesMap modem_properties;
493 modem_properties[MM_MODEM_PROPERTY_ACCESSTECHNOLOGIES].
494 writer().append_uint32(kAccessTechnologies);
495 modem_properties[MM_MODEM_PROPERTY_SIM].
496 writer().append_path(kSimPath);
497
498 // Set up mock modem 3gpp properties
499 DBusPropertiesMap modem3gpp_properties;
500 modem3gpp_properties[MM_MODEM_MODEM3GPP_PROPERTY_ENABLEDFACILITYLOCKS].
501 writer().append_uint32(0);
502 modem3gpp_properties[MM_MODEM_MODEM3GPP_PROPERTY_IMEI].
503 writer().append_string(kImei);
504
505 // Set up mock modem sim properties
506 DBusPropertiesMap sim_properties;
507
508 // After setup we lose pointers to the proxies, so it is hard to set
509 // expectations.
510 EXPECT_CALL(*properties_proxy_,
511 GetAll(MM_DBUS_INTERFACE_SIM))
512 .WillOnce(Return(sim_properties));
513
514 SetUp();
515
516 EXPECT_EQ("", capability_->imei_);
517 EXPECT_EQ(MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN,
518 capability_->access_technologies_);
519 EXPECT_FALSE(capability_->sim_proxy_.get());
Jason Glasgowbad114b2012-05-21 15:24:16 -0400520 EXPECT_CALL(*device_adaptor_, EmitStringChanged(
521 flimflam::kTechnologyFamilyProperty, flimflam::kTechnologyFamilyGsm));
Jason Glasgowaf583282012-04-18 15:18:22 -0400522 capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
523 modem_properties, vector<string>());
524 EXPECT_EQ(kAccessTechnologies, capability_->access_technologies_);
525 EXPECT_EQ(kSimPath, capability_->sim_path_);
526 EXPECT_TRUE(capability_->sim_proxy_.get());
527
528 // Changing properties on wrong interface will not have an effect
529 capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
530 modem3gpp_properties,
531 vector<string>());
532 EXPECT_EQ("", capability_->imei_);
533
534 // Changing properties on the right interface gets reflected in the
535 // capabilities object
536 capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM_MODEM3GPP,
537 modem3gpp_properties,
538 vector<string>());
539 EXPECT_EQ(kImei, capability_->imei_);
Jason Glasgowbad114b2012-05-21 15:24:16 -0400540
541 // Expect to see changes when the family changes
542 modem_properties.clear();
543 modem_properties[MM_MODEM_PROPERTY_ACCESSTECHNOLOGIES].
544 writer().append_uint32(MM_MODEM_ACCESS_TECHNOLOGY_1XRTT);
545 EXPECT_CALL(*device_adaptor_, EmitStringChanged(
546 flimflam::kTechnologyFamilyProperty, flimflam::kTechnologyFamilyCdma)).
547 Times(1);
548 capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
549 modem_properties,
550 vector<string>());
551 // Back to LTE
552 modem_properties.clear();
553 modem_properties[MM_MODEM_PROPERTY_ACCESSTECHNOLOGIES].
554 writer().append_uint32(MM_MODEM_ACCESS_TECHNOLOGY_LTE);
555 EXPECT_CALL(*device_adaptor_, EmitStringChanged(
556 flimflam::kTechnologyFamilyProperty, flimflam::kTechnologyFamilyGsm)).
557 Times(1);
558 capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
559 modem_properties,
560 vector<string>());
561
562 // LTE & CDMA - the device adaptor should not be called!
563 modem_properties.clear();
564 modem_properties[MM_MODEM_PROPERTY_ACCESSTECHNOLOGIES].
565 writer().append_uint32(MM_MODEM_ACCESS_TECHNOLOGY_LTE |
566 MM_MODEM_ACCESS_TECHNOLOGY_1XRTT);
567 EXPECT_CALL(*device_adaptor_, EmitStringChanged(_, _)).Times(0);
568 capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
569 modem_properties,
570 vector<string>());
Jason Glasgowaf583282012-04-18 15:18:22 -0400571}
572
Ben Chanbd3aee82012-10-16 23:52:04 -0700573TEST_F(CellularCapabilityUniversalTest, SimPathChanged) {
574 // Set up mock modem SIM properties
575 const char kImsi[] = "310100000001";
576 const char kSimIdentifier[] = "9999888";
577 const char kOperatorIdentifier[] = "310240";
578 const char kOperatorName[] = "Custom SPN";
579 DBusPropertiesMap sim_properties;
580 sim_properties[MM_SIM_PROPERTY_IMSI].writer().append_string(kImsi);
581 sim_properties[MM_SIM_PROPERTY_SIMIDENTIFIER].writer()
582 .append_string(kSimIdentifier);
583 sim_properties[MM_SIM_PROPERTY_OPERATORIDENTIFIER].writer()
584 .append_string(kOperatorIdentifier);
585 sim_properties[MM_SIM_PROPERTY_OPERATORNAME].writer()
586 .append_string(kOperatorName);
587
588 EXPECT_CALL(*properties_proxy_, GetAll(MM_DBUS_INTERFACE_SIM))
589 .Times(1).WillOnce(Return(sim_properties));
590
591 EXPECT_FALSE(capability_->sim_present_);
592 EXPECT_TRUE(capability_->sim_proxy_ == NULL);
593 EXPECT_EQ("", capability_->sim_path_);
594 EXPECT_EQ("", capability_->imsi_);
595 EXPECT_EQ("", capability_->sim_identifier_);
596 EXPECT_EQ("", capability_->operator_id_);
597 EXPECT_EQ("", capability_->spn_);
598
599 capability_->OnSimPathChanged(kSimPath);
600 EXPECT_TRUE(capability_->sim_present_);
601 EXPECT_TRUE(capability_->sim_proxy_ != NULL);
602 EXPECT_EQ(kSimPath, capability_->sim_path_);
603 EXPECT_EQ(kImsi, capability_->imsi_);
604 EXPECT_EQ(kSimIdentifier, capability_->sim_identifier_);
605 EXPECT_EQ(kOperatorIdentifier, capability_->operator_id_);
606 EXPECT_EQ(kOperatorName, capability_->spn_);
607
608 // Changing to the same SIM path should be a no-op.
609 capability_->OnSimPathChanged(kSimPath);
610 EXPECT_TRUE(capability_->sim_present_);
611 EXPECT_TRUE(capability_->sim_proxy_ != NULL);
612 EXPECT_EQ(kSimPath, capability_->sim_path_);
613 EXPECT_EQ(kImsi, capability_->imsi_);
614 EXPECT_EQ(kSimIdentifier, capability_->sim_identifier_);
615 EXPECT_EQ(kOperatorIdentifier, capability_->operator_id_);
616 EXPECT_EQ(kOperatorName, capability_->spn_);
617
618 capability_->OnSimPathChanged("");
619 EXPECT_FALSE(capability_->sim_present_);
620 EXPECT_TRUE(capability_->sim_proxy_ == NULL);
621 EXPECT_EQ("", capability_->sim_path_);
622 EXPECT_EQ("", capability_->imsi_);
623 EXPECT_EQ("", capability_->sim_identifier_);
624 EXPECT_EQ("", capability_->operator_id_);
625 EXPECT_EQ("", capability_->spn_);
626}
627
Jason Glasgowaf583282012-04-18 15:18:22 -0400628TEST_F(CellularCapabilityUniversalTest, SimPropertiesChanged) {
629 // Set up mock modem properties
630 DBusPropertiesMap modem_properties;
631 modem_properties[MM_MODEM_PROPERTY_SIM].writer().append_path(kSimPath);
632
633 // Set up mock modem sim properties
634 const char kImsi[] = "310100000001";
635 DBusPropertiesMap sim_properties;
636 sim_properties[MM_SIM_PROPERTY_IMSI].writer().append_string(kImsi);
637
638 EXPECT_CALL(*properties_proxy_, GetAll(MM_DBUS_INTERFACE_SIM))
639 .WillOnce(Return(sim_properties));
640
641 // After setup we lose pointers to the proxies, so it is hard to set
642 // expectations.
643 SetUp();
Jason Glasgow4380f0d2012-05-03 18:05:04 -0400644 InitProviderDB();
Jason Glasgowaf583282012-04-18 15:18:22 -0400645
Jason Glasgow4380f0d2012-05-03 18:05:04 -0400646 EXPECT_TRUE(cellular_->home_provider().GetName().empty());
647 EXPECT_TRUE(cellular_->home_provider().GetCountry().empty());
648 EXPECT_TRUE(cellular_->home_provider().GetCode().empty());
Jason Glasgowaf583282012-04-18 15:18:22 -0400649 EXPECT_FALSE(capability_->sim_proxy_.get());
650 capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_MODEM,
651 modem_properties, vector<string>());
652 EXPECT_EQ(kSimPath, capability_->sim_path_);
653 EXPECT_TRUE(capability_->sim_proxy_.get());
654 EXPECT_EQ(kImsi, capability_->imsi_);
655
656 // Updating the SIM
657 DBusPropertiesMap new_properties;
Jason Glasgow4380f0d2012-05-03 18:05:04 -0400658 const char kCountry[] = "us";
659 const char kCode[] = "310160";
660 const char kNewImsi[] = "310240123456789";
Jason Glasgowaf583282012-04-18 15:18:22 -0400661 const char kSimIdentifier[] = "9999888";
Jason Glasgow4380f0d2012-05-03 18:05:04 -0400662 const char kOperatorIdentifier[] = "310240";
663 const char kOperatorName[] = "Custom SPN";
Jason Glasgowaf583282012-04-18 15:18:22 -0400664 new_properties[MM_SIM_PROPERTY_IMSI].writer().append_string(kNewImsi);
665 new_properties[MM_SIM_PROPERTY_SIMIDENTIFIER].writer().
666 append_string(kSimIdentifier);
667 new_properties[MM_SIM_PROPERTY_OPERATORIDENTIFIER].writer().
668 append_string(kOperatorIdentifier);
Jason Glasgowaf583282012-04-18 15:18:22 -0400669 capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_SIM,
670 new_properties,
671 vector<string>());
672 EXPECT_EQ(kNewImsi, capability_->imsi_);
673 EXPECT_EQ(kSimIdentifier, capability_->sim_identifier_);
674 EXPECT_EQ(kOperatorIdentifier, capability_->operator_id_);
Jason Glasgow4380f0d2012-05-03 18:05:04 -0400675 EXPECT_EQ("", capability_->spn_);
676 EXPECT_EQ("T-Mobile", cellular_->home_provider().GetName());
677 EXPECT_EQ(kCountry, cellular_->home_provider().GetCountry());
678 EXPECT_EQ(kCode, cellular_->home_provider().GetCode());
679 EXPECT_EQ(4, capability_->apn_list_.size());
680
681 new_properties[MM_SIM_PROPERTY_OPERATORNAME].writer().
682 append_string(kOperatorName);
683 capability_->OnDBusPropertiesChanged(MM_DBUS_INTERFACE_SIM,
684 new_properties,
685 vector<string>());
686 EXPECT_EQ(kOperatorName, cellular_->home_provider().GetName());
Jason Glasgowaf583282012-04-18 15:18:22 -0400687 EXPECT_EQ(kOperatorName, capability_->spn_);
688}
689
Gary Morainceba6aa2012-05-03 10:28:26 -0700690MATCHER_P(SizeIs, value, "") {
691 return static_cast<size_t>(value) == arg.size();
692}
693
Ben Chan5d0d32c2013-01-08 02:05:29 -0800694TEST_F(CellularCapabilityUniversalTest, Reset) {
695 // Save pointers to proxies before they are lost by the call to InitProxies
696 mm1::MockModemProxy *modem_proxy = modem_proxy_.get();
697 SetUp();
698 EXPECT_CALL(*modem_proxy, set_state_changed_callback(_));
699 capability_->InitProxies();
700
701 Error error;
702 ResultCallback reset_callback;
703
704 EXPECT_CALL(*modem_proxy, Reset(_, _, CellularCapability::kTimeoutReset))
705 .WillOnce(SaveArg<1>(&reset_callback));
706
707 capability_->Reset(&error, ResultCallback());
708 EXPECT_TRUE(capability_->resetting_);
709 reset_callback.Run(error);
710 EXPECT_FALSE(capability_->resetting_);
711}
712
Gary Morainceba6aa2012-05-03 10:28:26 -0700713// Validates that OnScanReply does not crash with a null callback.
714TEST_F(CellularCapabilityUniversalTest, ScanWithNullCallback) {
715 Error error;
716 EXPECT_CALL(*modem_3gpp_proxy_, Scan(_, _, CellularCapability::kTimeoutScan))
717 .WillOnce(Invoke(this, &CellularCapabilityUniversalTest::InvokeScan));
718 EXPECT_CALL(*device_adaptor_,
719 EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
720 SizeIs(0)));
721 Set3gppProxy();
722 capability_->Scan(&error, ResultCallback());
723 EXPECT_TRUE(error.IsSuccess());
724}
725
Jason Glasgowcd0349c2012-05-03 23:32:15 -0400726// Validates that the scanning property is updated
727TEST_F(CellularCapabilityUniversalTest, Scan) {
728 Error error;
729
730 EXPECT_CALL(*modem_3gpp_proxy_, Scan(_, _, CellularCapability::kTimeoutScan))
731 .WillRepeatedly(SaveArg<1>(&scan_callback_));
732 EXPECT_CALL(*device_adaptor_,
733 EmitBoolChanged(flimflam::kScanningProperty, true));
734 Set3gppProxy();
735 capability_->Scan(&error, ResultCallback());
736 EXPECT_TRUE(capability_->scanning_);
737
738 // Simulate the completion of the scan with 2 networks in the results.
739 EXPECT_CALL(*device_adaptor_,
740 EmitBoolChanged(flimflam::kScanningProperty, false));
741 EXPECT_CALL(*device_adaptor_,
742 EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
743 SizeIs(2)));
744 vector<DBusPropertiesMap> results;
745 const char kScanID0[] = "testID0";
746 const char kScanID1[] = "testID1";
747 results.push_back(DBusPropertiesMap());
748 results[0][CellularCapabilityUniversal::kOperatorLongProperty].
749 writer().append_string(kScanID0);
750 results.push_back(DBusPropertiesMap());
751 results[1][CellularCapabilityUniversal::kOperatorLongProperty].
752 writer().append_string(kScanID1);
753 scan_callback_.Run(results, error);
754 EXPECT_FALSE(capability_->scanning_);
755
756 // Simulate the completion of the scan with no networks in the results.
757 EXPECT_CALL(*device_adaptor_,
758 EmitBoolChanged(flimflam::kScanningProperty, true));
759 capability_->Scan(&error, ResultCallback());
760 EXPECT_TRUE(capability_->scanning_);
761 EXPECT_CALL(*device_adaptor_,
762 EmitBoolChanged(flimflam::kScanningProperty, false));
763 EXPECT_CALL(*device_adaptor_,
764 EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
765 SizeIs(0)));
766 scan_callback_.Run(vector<DBusPropertiesMap>(), Error());
767 EXPECT_FALSE(capability_->scanning_);
768}
769
770// Validates expected property updates when scan fails
771TEST_F(CellularCapabilityUniversalTest, ScanFailure) {
772 Error error;
773
774 // Test immediate error
775 {
776 InSequence seq;
777 EXPECT_CALL(*modem_3gpp_proxy_,
778 Scan(_, _, CellularCapability::kTimeoutScan))
779 .WillOnce(Invoke(this, &CellularCapabilityUniversalTest::ScanError));
780 EXPECT_CALL(*modem_3gpp_proxy_,
781 Scan(_, _, CellularCapability::kTimeoutScan))
782 .WillOnce(SaveArg<1>(&scan_callback_));
783 }
784 Set3gppProxy();
785 capability_->Scan(&error, ResultCallback());
786 EXPECT_FALSE(capability_->scanning_);
787 EXPECT_TRUE(error.IsFailure());
788
789 // Initiate a scan
790 error.Populate(Error::kSuccess);
791 EXPECT_CALL(*device_adaptor_,
792 EmitBoolChanged(flimflam::kScanningProperty, true));
793 capability_->Scan(&error, ResultCallback());
794 EXPECT_TRUE(capability_->scanning_);
795 EXPECT_TRUE(error.IsSuccess());
796
797 // Validate that error is returned if Scan is called while already scanning.
798 capability_->Scan(&error, ResultCallback());
799 EXPECT_TRUE(capability_->scanning_);
800 EXPECT_TRUE(error.IsFailure());
801
802 // Validate that signals are emitted even if an error is reported.
803 capability_->found_networks_.clear();
804 capability_->found_networks_.push_back(Stringmap());
805 EXPECT_CALL(*device_adaptor_,
806 EmitBoolChanged(flimflam::kScanningProperty, false));
807 EXPECT_CALL(*device_adaptor_,
808 EmitStringmapsChanged(flimflam::kFoundNetworksProperty,
809 SizeIs(0)));
810 vector<DBusPropertiesMap> results;
811 scan_callback_.Run(results, Error(Error::kOperationFailed));
812 EXPECT_FALSE(capability_->scanning_);
813}
814
Arman Uguray6e5639f2012-11-15 20:30:19 -0800815// Validates expected behavior of OnListBearersReply function
816TEST_F(CellularCapabilityUniversalTest, OnListBearersReply) {
817 // Check that bearer_path_ is set correctly when an active bearer
818 // is returned.
819 const size_t kPathCount = 3;
820 DBus::Path active_paths[kPathCount], inactive_paths[kPathCount];
821 for (size_t i = 0; i < kPathCount; ++i) {
822 active_paths[i] =
823 DBus::Path(base::StringPrintf("%s/%zu", kActiveBearerPathPrefix, i));
824 inactive_paths[i] =
825 DBus::Path(base::StringPrintf("%s/%zu", kInactiveBearerPathPrefix, i));
826 }
827
828 std::vector<DBus::Path> paths;
829 paths.push_back(inactive_paths[0]);
830 paths.push_back(inactive_paths[1]);
831 paths.push_back(active_paths[2]);
832 paths.push_back(inactive_paths[1]);
833 paths.push_back(inactive_paths[2]);
834
835 Error error;
836 capability_->OnListBearersReply(paths, error);
837 EXPECT_STREQ(capability_->bearer_path_.c_str(), active_paths[2].c_str());
838
839 paths.clear();
840
841 // Check that bearer_path_ is empty if no active bearers are returned.
842 paths.push_back(inactive_paths[0]);
843 paths.push_back(inactive_paths[1]);
844 paths.push_back(inactive_paths[2]);
845 paths.push_back(inactive_paths[1]);
846
847 capability_->OnListBearersReply(paths, error);
848 EXPECT_TRUE(capability_->bearer_path_.empty());
849
850 // Check that returning multiple bearers causes death.
851 paths.push_back(active_paths[0]);
852 paths.push_back(inactive_paths[1]);
853 paths.push_back(inactive_paths[2]);
854 paths.push_back(active_paths[1]);
855 paths.push_back(inactive_paths[1]);
856
857 EXPECT_DEATH(capability_->OnListBearersReply(paths, error),
858 "Found more than one active bearer.");
859}
860
Jason Glasgow14521872012-05-07 19:12:15 -0400861// Validates expected behavior of Connect function
862TEST_F(CellularCapabilityUniversalTest, Connect) {
863 mm1::MockModemSimpleProxy *modem_simple_proxy = modem_simple_proxy_.get();
864 SetSimpleProxy();
865 Error error;
866 DBusPropertiesMap properties;
867 capability_->apn_try_list_.clear();
868 ResultCallback callback =
869 Bind(&CellularCapabilityUniversalTest::TestCallback, Unretained(this));
870 DBus::Path bearer("/foo");
871
872 // Test connect failures
873 EXPECT_CALL(*modem_simple_proxy, Connect(_, _, _, _))
874 .WillOnce(SaveArg<2>(&connect_callback_));
875 capability_->Connect(properties, &error, callback);
876 EXPECT_TRUE(error.IsSuccess());
877 EXPECT_CALL(*this, TestCallback(IsFailure()));
878 EXPECT_CALL(*service_, ClearLastGoodApn());
879 connect_callback_.Run(bearer, Error(Error::kOperationFailed));
880
881 // Test connect success
882 EXPECT_CALL(*modem_simple_proxy, Connect(_, _, _, _))
883 .WillOnce(SaveArg<2>(&connect_callback_));
884 capability_->Connect(properties, &error, callback);
885 EXPECT_TRUE(error.IsSuccess());
886 EXPECT_CALL(*this, TestCallback(IsSuccess()));
887 connect_callback_.Run(bearer, Error(Error::kSuccess));
Jason Glasgow7234ec32012-05-23 16:01:21 -0400888
889 // Test connect failures without a service. Make sure that shill
890 // does not crash if the connect failed and there is no
891 // CellularService object. This can happen if the modem is enabled
892 // and then quickly disabled.
893 cellular_->service_ = NULL;
894 EXPECT_FALSE(capability_->cellular()->service());
895 EXPECT_CALL(*modem_simple_proxy, Connect(_, _, _, _))
896 .WillOnce(SaveArg<2>(&connect_callback_));
897 capability_->Connect(properties, &error, callback);
898 EXPECT_TRUE(error.IsSuccess());
899 EXPECT_CALL(*this, TestCallback(IsFailure()));
900 connect_callback_.Run(bearer, Error(Error::kOperationFailed));
Jason Glasgow14521872012-05-07 19:12:15 -0400901}
902
903// Validates Connect iterates over APNs
904TEST_F(CellularCapabilityUniversalTest, ConnectApns) {
905 mm1::MockModemSimpleProxy *modem_simple_proxy = modem_simple_proxy_.get();
906 SetSimpleProxy();
907 Error error;
908 DBusPropertiesMap properties;
909 capability_->apn_try_list_.clear();
910 ResultCallback callback =
911 Bind(&CellularCapabilityUniversalTest::TestCallback, Unretained(this));
912 DBus::Path bearer("/bearer0");
913
914 const char apn_name_foo[] = "foo";
915 const char apn_name_bar[] = "bar";
916 EXPECT_CALL(*modem_simple_proxy, Connect(HasApn(apn_name_foo), _, _, _))
917 .WillOnce(SaveArg<2>(&connect_callback_));
918 Stringmap apn1;
919 apn1[flimflam::kApnProperty] = apn_name_foo;
920 capability_->apn_try_list_.push_back(apn1);
921 Stringmap apn2;
922 apn2[flimflam::kApnProperty] = apn_name_bar;
923 capability_->apn_try_list_.push_back(apn2);
924 capability_->FillConnectPropertyMap(&properties);
925 capability_->Connect(properties, &error, callback);
926 EXPECT_TRUE(error.IsSuccess());
927
928 EXPECT_CALL(*modem_simple_proxy, Connect(HasApn(apn_name_bar), _, _, _))
929 .WillOnce(SaveArg<2>(&connect_callback_));
930 EXPECT_CALL(*service_, ClearLastGoodApn());
931 connect_callback_.Run(bearer, Error(Error::kInvalidApn));
932
933 EXPECT_CALL(*service_, SetLastGoodApn(apn2));
934 EXPECT_CALL(*this, TestCallback(IsSuccess()));
935 connect_callback_.Run(bearer, Error(Error::kSuccess));
936}
937
Jason Glasgow9f09aef2012-05-08 16:26:55 -0400938// Validates GetTypeString and AccessTechnologyToTechnologyFamily
939TEST_F(CellularCapabilityUniversalTest, GetTypeString) {
940 const int gsm_technologies[] = {
941 MM_MODEM_ACCESS_TECHNOLOGY_LTE,
942 MM_MODEM_ACCESS_TECHNOLOGY_HSPA_PLUS,
943 MM_MODEM_ACCESS_TECHNOLOGY_HSPA,
944 MM_MODEM_ACCESS_TECHNOLOGY_HSUPA,
945 MM_MODEM_ACCESS_TECHNOLOGY_HSDPA,
946 MM_MODEM_ACCESS_TECHNOLOGY_UMTS,
947 MM_MODEM_ACCESS_TECHNOLOGY_EDGE,
948 MM_MODEM_ACCESS_TECHNOLOGY_GPRS,
949 MM_MODEM_ACCESS_TECHNOLOGY_GSM_COMPACT,
950 MM_MODEM_ACCESS_TECHNOLOGY_GSM,
951 MM_MODEM_ACCESS_TECHNOLOGY_LTE | MM_MODEM_ACCESS_TECHNOLOGY_EVDO0,
952 MM_MODEM_ACCESS_TECHNOLOGY_GSM | MM_MODEM_ACCESS_TECHNOLOGY_EVDO0,
953 MM_MODEM_ACCESS_TECHNOLOGY_LTE | MM_MODEM_ACCESS_TECHNOLOGY_EVDOA,
954 MM_MODEM_ACCESS_TECHNOLOGY_GSM | MM_MODEM_ACCESS_TECHNOLOGY_EVDOA,
955 MM_MODEM_ACCESS_TECHNOLOGY_LTE | MM_MODEM_ACCESS_TECHNOLOGY_EVDOB,
956 MM_MODEM_ACCESS_TECHNOLOGY_GSM | MM_MODEM_ACCESS_TECHNOLOGY_EVDOB,
957 MM_MODEM_ACCESS_TECHNOLOGY_GSM | MM_MODEM_ACCESS_TECHNOLOGY_1XRTT,
958 };
Ben Chan62028b22012-11-05 11:20:02 -0800959 for (size_t i = 0; i < arraysize(gsm_technologies); ++i) {
Jason Glasgow9f09aef2012-05-08 16:26:55 -0400960 capability_->access_technologies_ = gsm_technologies[i];
961 ASSERT_EQ(capability_->GetTypeString(), flimflam::kTechnologyFamilyGsm);
962 }
963 const int cdma_technologies[] = {
964 MM_MODEM_ACCESS_TECHNOLOGY_EVDO0,
965 MM_MODEM_ACCESS_TECHNOLOGY_EVDOA,
966 MM_MODEM_ACCESS_TECHNOLOGY_EVDOA | MM_MODEM_ACCESS_TECHNOLOGY_EVDO0,
967 MM_MODEM_ACCESS_TECHNOLOGY_EVDOB,
968 MM_MODEM_ACCESS_TECHNOLOGY_EVDOB | MM_MODEM_ACCESS_TECHNOLOGY_EVDO0,
969 MM_MODEM_ACCESS_TECHNOLOGY_1XRTT,
970 };
Ben Chan62028b22012-11-05 11:20:02 -0800971 for (size_t i = 0; i < arraysize(cdma_technologies); ++i) {
Jason Glasgow9f09aef2012-05-08 16:26:55 -0400972 capability_->access_technologies_ = cdma_technologies[i];
973 ASSERT_EQ(capability_->GetTypeString(), flimflam::kTechnologyFamilyCdma);
974 }
975 capability_->access_technologies_ = MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN;
976 ASSERT_EQ(capability_->GetTypeString(), "");
977}
978
Darin Petkovf508c822012-09-21 13:43:17 +0200979TEST_F(CellularCapabilityUniversalTest, AllowRoaming) {
980 EXPECT_FALSE(cellular_->allow_roaming_);
981 EXPECT_FALSE(capability_->provider_requires_roaming_);
982 EXPECT_FALSE(capability_->AllowRoaming());
983 capability_->provider_requires_roaming_ = true;
984 EXPECT_TRUE(capability_->AllowRoaming());
985 capability_->provider_requires_roaming_ = false;
986 cellular_->allow_roaming_ = true;
987 EXPECT_TRUE(capability_->AllowRoaming());
988}
989
Darin Petkovb4fccd22012-08-10 11:59:26 +0200990TEST_F(CellularCapabilityUniversalTest, SetHomeProvider) {
991 static const char kTestCarrier[] = "The Cellular Carrier";
992 static const char kCountry[] = "us";
993 static const char kCode[] = "310160";
994 capability_->imsi_ = "310240123456789";
995
Darin Petkovf508c822012-09-21 13:43:17 +0200996 EXPECT_FALSE(capability_->home_provider_);
997 EXPECT_FALSE(capability_->provider_requires_roaming_);
998
Darin Petkovb4fccd22012-08-10 11:59:26 +0200999 capability_->SetHomeProvider(); // No mobile provider DB available.
1000 EXPECT_TRUE(cellular_->home_provider().GetName().empty());
1001 EXPECT_TRUE(cellular_->home_provider().GetCountry().empty());
1002 EXPECT_TRUE(cellular_->home_provider().GetCode().empty());
Darin Petkovf508c822012-09-21 13:43:17 +02001003 EXPECT_FALSE(capability_->provider_requires_roaming_);
Darin Petkovb4fccd22012-08-10 11:59:26 +02001004
1005 InitProviderDB();
1006 capability_->SetHomeProvider();
1007 EXPECT_EQ("T-Mobile", cellular_->home_provider().GetName());
1008 EXPECT_EQ(kCountry, cellular_->home_provider().GetCountry());
1009 EXPECT_EQ(kCode, cellular_->home_provider().GetCode());
1010 EXPECT_EQ(4, capability_->apn_list_.size());
1011 ASSERT_TRUE(capability_->home_provider_);
Darin Petkovf508c822012-09-21 13:43:17 +02001012 EXPECT_FALSE(capability_->provider_requires_roaming_);
Darin Petkovb4fccd22012-08-10 11:59:26 +02001013
1014 Cellular::Operator oper;
1015 cellular_->set_home_provider(oper);
1016 capability_->spn_ = kTestCarrier;
1017 capability_->SetHomeProvider();
1018 EXPECT_EQ(kTestCarrier, cellular_->home_provider().GetName());
1019 EXPECT_EQ(kCountry, cellular_->home_provider().GetCountry());
1020 EXPECT_EQ(kCode, cellular_->home_provider().GetCode());
Darin Petkovf508c822012-09-21 13:43:17 +02001021 EXPECT_FALSE(capability_->provider_requires_roaming_);
Darin Petkovb4fccd22012-08-10 11:59:26 +02001022
1023 static const char kCubic[] = "Cubic";
1024 capability_->spn_ = kCubic;
1025 capability_->SetHomeProvider();
1026 EXPECT_EQ(kCubic, cellular_->home_provider().GetName());
1027 EXPECT_EQ("", cellular_->home_provider().GetCode());
1028 ASSERT_TRUE(capability_->home_provider_);
Darin Petkovf508c822012-09-21 13:43:17 +02001029 EXPECT_TRUE(capability_->provider_requires_roaming_);
Darin Petkovb4fccd22012-08-10 11:59:26 +02001030
1031 static const char kCUBIC[] = "CUBIC";
1032 capability_->spn_ = kCUBIC;
1033 capability_->home_provider_ = NULL;
1034 capability_->SetHomeProvider();
1035 EXPECT_EQ(kCUBIC, cellular_->home_provider().GetName());
1036 EXPECT_EQ("", cellular_->home_provider().GetCode());
1037 ASSERT_TRUE(capability_->home_provider_);
Darin Petkovf508c822012-09-21 13:43:17 +02001038 EXPECT_TRUE(capability_->provider_requires_roaming_);
Darin Petkovb4fccd22012-08-10 11:59:26 +02001039}
1040
Ben Chan6d0d1e72012-11-06 21:19:28 -08001041TEST_F(CellularCapabilityUniversalTest, UpdateOLP) {
1042 CellularService::OLP test_olp;
1043 test_olp.SetURL("http://testurl");
1044 test_olp.SetMethod("POST");
1045 test_olp.SetPostData("esn=${esn}&imei=${imei}&imsi=${imsi}&mdn=${mdn}&"
1046 "meid=${meid}&min=${min}&iccid=${iccid}");
1047
Ben Chan6d0d1e72012-11-06 21:19:28 -08001048 capability_->esn_ = "0";
1049 capability_->imei_ = "1";
1050 capability_->imsi_ = "2";
1051 capability_->mdn_ = "3";
1052 capability_->meid_= "4";
1053 capability_->min_ = "5";
1054 capability_->sim_identifier_ = "6";
1055 capability_->operator_id_ = "123456";
1056 cellular_->cellular_operator_info_ = &cellular_operator_info_;
1057
Arman Ugurayf4c61812013-01-10 18:58:39 -08001058 EXPECT_CALL(cellular_operator_info_,
1059 GetOLPByMCCMNC(capability_->operator_id_))
1060 .WillRepeatedly(Return(&test_olp));
Ben Chan6d0d1e72012-11-06 21:19:28 -08001061
1062 SetService();
1063 capability_->UpdateOLP();
1064 const CellularService::OLP &olp = cellular_->service()->olp();
1065 EXPECT_EQ("http://testurl", olp.GetURL());
1066 EXPECT_EQ("POST", olp.GetMethod());
1067 EXPECT_EQ("esn=0&imei=1&imsi=2&mdn=3&meid=4&min=5&iccid=6",
1068 olp.GetPostData());
1069}
1070
Darin Petkova4ca3c32012-08-17 16:05:24 +02001071TEST_F(CellularCapabilityUniversalTest, UpdateOperatorInfo) {
1072 static const char kOperatorName[] = "Swisscom";
1073 InitProviderDB();
1074 capability_->serving_operator_.SetCode("22801");
1075 SetService();
1076 capability_->UpdateOperatorInfo();
1077 EXPECT_EQ(kOperatorName, capability_->serving_operator_.GetName());
1078 EXPECT_EQ("ch", capability_->serving_operator_.GetCountry());
1079 EXPECT_EQ(kOperatorName, cellular_->service()->serving_operator().GetName());
1080
1081 static const char kTestOperator[] = "Testcom";
1082 capability_->serving_operator_.SetName(kTestOperator);
1083 capability_->serving_operator_.SetCountry("");
1084 capability_->UpdateOperatorInfo();
1085 EXPECT_EQ(kTestOperator, capability_->serving_operator_.GetName());
1086 EXPECT_EQ("ch", capability_->serving_operator_.GetCountry());
1087 EXPECT_EQ(kTestOperator, cellular_->service()->serving_operator().GetName());
1088}
1089
Ben Chan092b12b2012-11-07 22:04:05 -08001090TEST_F(CellularCapabilityUniversalTest, UpdateOperatorInfoViaOperatorId) {
1091 static const char kOperatorName[] = "Swisscom";
1092 static const char kOperatorId[] = "22801";
1093 InitProviderDB();
1094 capability_->serving_operator_.SetCode("");
1095 SetService();
1096 capability_->UpdateOperatorInfo();
1097 EXPECT_EQ("", capability_->serving_operator_.GetName());
1098 EXPECT_EQ("", capability_->serving_operator_.GetCountry());
1099 EXPECT_EQ("", cellular_->service()->serving_operator().GetName());
1100
1101 capability_->operator_id_ = kOperatorId;
1102
1103 // Service activation is not needed
1104 cellular_->cellular_operator_info_ = &cellular_operator_info_;
Arman Ugurayf4c61812013-01-10 18:58:39 -08001105 EXPECT_CALL(cellular_operator_info_, GetOLPByMCCMNC(_))
1106 .WillOnce(Return((const CellularService::OLP *)NULL));
Ben Chan092b12b2012-11-07 22:04:05 -08001107 capability_->UpdateOperatorInfo();
1108 EXPECT_EQ("", capability_->serving_operator_.GetName());
1109 EXPECT_EQ("", capability_->serving_operator_.GetCountry());
1110 EXPECT_EQ("", cellular_->service()->serving_operator().GetName());
1111
1112 // Service activation is needed
1113 capability_->mdn_ = "0000000000";
1114 cellular_->cellular_operator_info_ = &cellular_operator_info_;
Arman Ugurayf4c61812013-01-10 18:58:39 -08001115 CellularService::OLP olp;
1116 EXPECT_CALL(cellular_operator_info_, GetOLPByMCCMNC(_))
1117 .WillOnce(Return(&olp));
Ben Chan092b12b2012-11-07 22:04:05 -08001118
1119 capability_->UpdateOperatorInfo();
1120 EXPECT_EQ(kOperatorId, capability_->serving_operator_.GetCode());
1121 EXPECT_EQ(kOperatorName, capability_->serving_operator_.GetName());
1122 EXPECT_EQ("ch", capability_->serving_operator_.GetCountry());
1123 EXPECT_EQ(kOperatorName, cellular_->service()->serving_operator().GetName());
1124}
1125
Darin Petkova4ca3c32012-08-17 16:05:24 +02001126TEST_F(CellularCapabilityUniversalTest, CreateFriendlyServiceName) {
1127 CellularCapabilityUniversal::friendly_service_name_id_ = 0;
1128 EXPECT_EQ("GSMNetwork0", capability_->CreateFriendlyServiceName());
1129 EXPECT_EQ("GSMNetwork1", capability_->CreateFriendlyServiceName());
1130
Ben Chan092b12b2012-11-07 22:04:05 -08001131 // Service activation is not needed
1132 capability_->operator_id_ = "0123";
1133 EXPECT_EQ("GSMNetwork2", capability_->CreateFriendlyServiceName());
1134
1135 // Service activation is needed
1136 capability_->mdn_ = "0000000000";
1137 cellular_->cellular_operator_info_ = &cellular_operator_info_;
Arman Ugurayf4c61812013-01-10 18:58:39 -08001138 CellularService::OLP olp;
1139 EXPECT_CALL(cellular_operator_info_, GetOLPByMCCMNC(_))
1140 .WillOnce(Return(&olp));
Ben Chan092b12b2012-11-07 22:04:05 -08001141 EXPECT_EQ("cellular_0123", capability_->CreateFriendlyServiceName());
1142 EXPECT_EQ("0123", capability_->serving_operator_.GetCode());
1143
Darin Petkova4ca3c32012-08-17 16:05:24 +02001144 capability_->serving_operator_.SetCode("1234");
1145 EXPECT_EQ("cellular_1234", capability_->CreateFriendlyServiceName());
1146
1147 static const char kHomeProvider[] = "The GSM Home Provider";
1148 cellular_->home_provider_.SetName(kHomeProvider);
1149 EXPECT_EQ("cellular_1234", capability_->CreateFriendlyServiceName());
1150 capability_->registration_state_ = MM_MODEM_3GPP_REGISTRATION_STATE_HOME;
1151 EXPECT_EQ(kHomeProvider, capability_->CreateFriendlyServiceName());
1152
1153 static const char kTestOperator[] = "A GSM Operator";
1154 capability_->serving_operator_.SetName(kTestOperator);
1155 EXPECT_EQ(kTestOperator, capability_->CreateFriendlyServiceName());
1156
1157 capability_->registration_state_ = MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING;
1158 EXPECT_EQ(StringPrintf("%s | %s", kHomeProvider, kTestOperator),
1159 capability_->CreateFriendlyServiceName());
1160}
1161
Ben Chan15786032012-11-04 21:28:02 -08001162TEST_F(CellularCapabilityUniversalTest, IsServiceActivationRequired) {
1163 capability_->mdn_ = "0000000000";
1164 cellular_->cellular_operator_info_ = NULL;
1165 EXPECT_FALSE(capability_->IsServiceActivationRequired());
1166
1167 cellular_->cellular_operator_info_ = &cellular_operator_info_;
Arman Ugurayf4c61812013-01-10 18:58:39 -08001168 CellularService::OLP olp;
1169 EXPECT_CALL(cellular_operator_info_, GetOLPByMCCMNC(_))
1170 .WillOnce(Return((const CellularService::OLP *)NULL))
1171 .WillRepeatedly(Return(&olp));
Ben Chan15786032012-11-04 21:28:02 -08001172 EXPECT_FALSE(capability_->IsServiceActivationRequired());
1173
1174 capability_->mdn_ = "";
1175 EXPECT_FALSE(capability_->IsServiceActivationRequired());
1176 capability_->mdn_ = "1234567890";
1177 EXPECT_FALSE(capability_->IsServiceActivationRequired());
1178 capability_->mdn_ = "+1-234-567-890";
1179 EXPECT_FALSE(capability_->IsServiceActivationRequired());
1180 capability_->mdn_ = "0000000000";
1181 EXPECT_TRUE(capability_->IsServiceActivationRequired());
1182 capability_->mdn_ = "0-000-000-000";
1183 EXPECT_TRUE(capability_->IsServiceActivationRequired());
1184 capability_->mdn_ = "+0-000-000-000";
1185 EXPECT_TRUE(capability_->IsServiceActivationRequired());
1186}
1187
Jason Glasgowef965562012-04-10 16:12:35 -04001188} // namespace shill