shill: cellular: Implement CDMA activation over non-cellular.
Added OTASP activation logic over a non-cellular network to
CellularCapabilityUniversalCDMA.
BUG=chromium:221698,chromium:217324
TEST=1. Build and run unit tests.
2. - Acquire an unactivated Gobi3k (this can be achieved on an
activated modem by cancelling the account and factory
resetting the modem).
- Reimage the Chromebook (with the above Gobi3k) with an image
which was compiled with 'USE="-gobi qmi"'.
- If the carrier is not already set to Verizon Wireless, switch
firmware to the Verizon firmware.
- Verify that the modem supported by ModemManager and not cromo. The
modem properties should be exposed and the CDMA
ActivationState property should be 'not-activated'. All of this can
be verified using mmcli.
- The Chrome OS UI should display the cellular network as 'not
activated'. Use the UI to activate the service.
- Once payment is done, service should be marked as
"Activating". /var/cache/shill/activating_iccid_store.profile
should have a new entry under "[meid_list]" set to "1".
- Monitor /var/log/net.log (with a debug scope of at least
"cellular" and level "-3"). Cellular activation related
messages should be logged. ModemManager should be in the
process of "automatic activation" and logging appropriate
updates.
- The modem should eventually reset. Afterwards the UI should
pop-up a "3G network activated" dialog.
Change-Id: Iff9d1b88012dad1d3552af12d9ae7f510a988a54
Reviewed-on: https://gerrit.chromium.org/gerrit/49696
Reviewed-by: Arman Uguray <armansito@chromium.org>
Commit-Queue: Arman Uguray <armansito@chromium.org>
Tested-by: Arman Uguray <armansito@chromium.org>
diff --git a/cellular_capability_universal_cdma_unittest.cc b/cellular_capability_universal_cdma_unittest.cc
index eae9390..d26ad36 100644
--- a/cellular_capability_universal_cdma_unittest.cc
+++ b/cellular_capability_universal_cdma_unittest.cc
@@ -29,6 +29,7 @@
#include "shill/mock_mm1_modem_simple_proxy.h"
#include "shill/mock_mm1_sim_proxy.h"
#include "shill/mock_modem_info.h"
+#include "shill/mock_pending_activation_store.h"
#include "shill/nice_mock_control.h"
#include "shill/proxy_factory.h"
@@ -46,10 +47,10 @@
class CellularCapabilityUniversalCDMATest : public testing::Test {
public:
- CellularCapabilityUniversalCDMATest()
+ CellularCapabilityUniversalCDMATest(EventDispatcher *dispatcher)
: capability_(NULL),
device_adaptor_(NULL),
- modem_info_(NULL, &dispatcher_, NULL, NULL, NULL),
+ modem_info_(NULL, dispatcher, NULL, NULL, NULL),
bearer_proxy_(new mm1::MockBearerProxy()),
modem_3gpp_proxy_(new mm1::MockModemModem3gppProxy()),
modem_cdma_proxy_(new mm1::MockModemModemCdmaProxy()),
@@ -165,7 +166,6 @@
CellularCapabilityUniversalCDMA *capability_;
NiceMock<DeviceMockAdaptor> *device_adaptor_;
- EventDispatcher dispatcher_;
MockModemInfo modem_info_;
MockGLib glib_;
scoped_ptr<mm1::MockBearerProxy> bearer_proxy_;
@@ -189,7 +189,24 @@
// static
const char CellularCapabilityUniversalCDMATest::kMeid[] = "11111111111111";
-TEST_F(CellularCapabilityUniversalCDMATest, PropertiesChanged) {
+class CellularCapabilityUniversalCDMAMainTest
+ : public CellularCapabilityUniversalCDMATest {
+ public:
+ CellularCapabilityUniversalCDMAMainTest()
+ : CellularCapabilityUniversalCDMATest(&dispatcher_) {}
+
+ private:
+ EventDispatcher dispatcher_;
+};
+
+class CellularCapabilityUniversalCDMADispatcherTest
+ : public CellularCapabilityUniversalCDMATest {
+ public:
+ CellularCapabilityUniversalCDMADispatcherTest()
+ : CellularCapabilityUniversalCDMATest(NULL) {}
+};
+
+TEST_F(CellularCapabilityUniversalCDMAMainTest, PropertiesChanged) {
// Set up mock modem CDMA properties.
DBusPropertiesMap modem_cdma_properties;
modem_cdma_properties[MM_MODEM_MODEMCDMA_PROPERTY_MEID].
@@ -218,7 +235,7 @@
EXPECT_EQ(kEsn, capability_->esn());
}
-TEST_F(CellularCapabilityUniversalCDMATest, OnCDMARegistrationChanged) {
+TEST_F(CellularCapabilityUniversalCDMAMainTest, OnCDMARegistrationChanged) {
EXPECT_EQ(0, capability_->sid_);
EXPECT_EQ(0, capability_->nid_);
EXPECT_EQ(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN,
@@ -262,21 +279,24 @@
EXPECT_EQ("us", capability_->provider_.GetCountry());
}
-TEST_F(CellularCapabilityUniversalCDMATest, UpdateOperatorInfo) {
+TEST_F(CellularCapabilityUniversalCDMAMainTest, UpdateOperatorInfo) {
EXPECT_EQ("", capability_->provider_.GetCode());
EXPECT_EQ("", capability_->provider_.GetName());
EXPECT_EQ("", capability_->provider_.GetCountry());
+ EXPECT_TRUE(capability_->activation_code_.empty());
capability_->UpdateOperatorInfo();
EXPECT_EQ("", capability_->provider_.GetCode());
EXPECT_EQ("", capability_->provider_.GetName());
EXPECT_EQ("", capability_->provider_.GetCountry());
+ EXPECT_TRUE(capability_->activation_code_.empty());
capability_->UpdateOperatorInfo();
EXPECT_EQ("", capability_->provider_.GetCode());
EXPECT_EQ("", capability_->provider_.GetName());
EXPECT_EQ("", capability_->provider_.GetCountry());
+ EXPECT_TRUE(capability_->activation_code_.empty());
capability_->sid_ = 1;
EXPECT_CALL(*modem_info_.mock_cellular_operator_info(),
@@ -287,12 +307,14 @@
EXPECT_EQ("", capability_->provider_.GetCode());
EXPECT_EQ("", capability_->provider_.GetName());
EXPECT_EQ("", capability_->provider_.GetCountry());
+ EXPECT_TRUE(capability_->activation_code_.empty());
CellularOperatorInfo::CellularOperator *provider =
new CellularOperatorInfo::CellularOperator();
provider->country_ = "us";
provider->is_primary_ = true;
+ provider->activation_code_ = "1234";
provider->name_list_.push_back(
CellularOperatorInfo::LocalizedName("Test", ""));
@@ -307,9 +329,10 @@
EXPECT_EQ("1", capability_->provider_.GetCode());
EXPECT_EQ("Test", capability_->provider_.GetName());
EXPECT_EQ("us", capability_->provider_.GetCountry());
+ EXPECT_EQ("1234", capability_->activation_code_);
}
-TEST_F(CellularCapabilityUniversalCDMATest, CreateFriendlyServiceName) {
+TEST_F(CellularCapabilityUniversalCDMAMainTest, CreateFriendlyServiceName) {
CellularCapabilityUniversalCDMA::friendly_service_name_id_cdma_ = 0;
EXPECT_EQ(0, capability_->sid_);
EXPECT_EQ("CDMANetwork0", capability_->CreateFriendlyServiceName());
@@ -334,7 +357,7 @@
EXPECT_EQ("Test", capability_->CreateFriendlyServiceName());
}
-TEST_F(CellularCapabilityUniversalCDMATest, UpdateOLP) {
+TEST_F(CellularCapabilityUniversalCDMAMainTest, UpdateOLP) {
CellularService::OLP test_olp;
test_olp.SetURL("http://testurl");
test_olp.SetMethod("POST");
@@ -357,4 +380,194 @@
EXPECT_EQ("esn=0&mdn=3&meid=4", olp.GetPostData());
}
+TEST_F(CellularCapabilityUniversalCDMAMainTest, ActivateAutomatic) {
+ mm1::MockModemModemCdmaProxy *cdma_proxy = modem_cdma_proxy_.get();
+ SetUp();
+ capability_->InitProxies();
+
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(_,_))
+ .Times(0);
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ SetActivationState(_,_,_))
+ .Times(0);
+ EXPECT_CALL(*cdma_proxy, Activate(_,_,_,_)).Times(0);
+ capability_->ActivateAutomatic();
+ Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
+ Mock::VerifyAndClearExpectations(modem_cdma_proxy_.get());
+
+ capability_->activation_code_ = "1234";
+
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(PendingActivationStore::kIdentifierMEID, _))
+ .WillOnce(Return(PendingActivationStore::kStatePending))
+ .WillOnce(Return(PendingActivationStore::kStateActivated));
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ SetActivationState(_,_,_))
+ .Times(0);
+ EXPECT_CALL(*cdma_proxy, Activate(_,_,_,_)).Times(0);
+ capability_->ActivateAutomatic();
+ capability_->ActivateAutomatic();
+ Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
+ Mock::VerifyAndClearExpectations(modem_cdma_proxy_.get());
+
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(PendingActivationStore::kIdentifierMEID, _))
+ .WillOnce(Return(PendingActivationStore::kStateUnknown))
+ .WillOnce(Return(PendingActivationStore::kStateFailureRetry));
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ SetActivationState(_,_, PendingActivationStore::kStatePending))
+ .Times(2);
+ EXPECT_CALL(*cdma_proxy, Activate(_,_,_,_)).Times(2);
+ capability_->ActivateAutomatic();
+ capability_->ActivateAutomatic();
+ Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
+ Mock::VerifyAndClearExpectations(modem_cdma_proxy_.get());
+}
+
+TEST_F(CellularCapabilityUniversalCDMAMainTest, IsServiceActivationRequired) {
+ CellularService::OLP olp;
+ EXPECT_CALL(*modem_info_.mock_cellular_operator_info(), GetOLPBySID(_))
+ .WillOnce(Return((const CellularService::OLP *)NULL))
+ .WillRepeatedly(Return(&olp));
+ capability_->activation_state_ =
+ MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
+ EXPECT_FALSE(capability_->IsServiceActivationRequired());
+ EXPECT_TRUE(capability_->IsServiceActivationRequired());
+ capability_->activation_state_ =
+ MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
+ EXPECT_FALSE(capability_->IsServiceActivationRequired());
+ capability_->activation_state_ =
+ MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;
+ EXPECT_FALSE(capability_->IsServiceActivationRequired());
+}
+
+TEST_F(CellularCapabilityUniversalCDMAMainTest,
+ UpdateServiceActivationStateProperty) {
+ CellularService::OLP olp;
+ EXPECT_CALL(*modem_info_.mock_cellular_operator_info(), GetOLPBySID(_))
+ .WillRepeatedly(Return(&olp));
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(_,_))
+ .WillOnce(Return(PendingActivationStore::kStatePending))
+ .WillRepeatedly(Return(PendingActivationStore::kStateUnknown));
+
+ capability_->activation_state_ =
+ MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
+ EXPECT_CALL(*service_,
+ SetActivationState(flimflam::kActivationStateActivating))
+ .Times(1);
+ capability_->UpdateServiceActivationStateProperty();
+ Mock::VerifyAndClearExpectations(service_);
+
+ EXPECT_CALL(*service_,
+ SetActivationState(flimflam::kActivationStateNotActivated))
+ .Times(1);
+ capability_->UpdateServiceActivationStateProperty();
+ Mock::VerifyAndClearExpectations(service_);
+
+ capability_->activation_state_ =
+ MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
+ EXPECT_CALL(*service_,
+ SetActivationState(flimflam::kActivationStateActivating))
+ .Times(1);
+ capability_->UpdateServiceActivationStateProperty();
+ Mock::VerifyAndClearExpectations(service_);
+
+ capability_->activation_state_ =
+ MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;
+ EXPECT_CALL(*service_,
+ SetActivationState(flimflam::kActivationStateActivated))
+ .Times(1);
+ capability_->UpdateServiceActivationStateProperty();
+ Mock::VerifyAndClearExpectations(service_);
+ Mock::VerifyAndClearExpectations(modem_info_.mock_cellular_operator_info());
+ Mock::VerifyAndClearExpectations(
+ modem_info_.mock_pending_activation_store());
+}
+
+TEST_F(CellularCapabilityUniversalCDMAMainTest, IsActivating) {
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(_,_))
+ .WillOnce(Return(PendingActivationStore::kStatePending))
+ .WillOnce(Return(PendingActivationStore::kStatePending))
+ .WillOnce(Return(PendingActivationStore::kStateFailureRetry))
+ .WillRepeatedly(Return(PendingActivationStore::kStateUnknown));
+
+ capability_->activation_state_ =
+ MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
+ EXPECT_TRUE(capability_->IsActivating());
+ EXPECT_TRUE(capability_->IsActivating());
+ capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
+ EXPECT_TRUE(capability_->IsActivating());
+ EXPECT_TRUE(capability_->IsActivating());
+ capability_->activation_state_ =
+ MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
+ EXPECT_FALSE(capability_->IsActivating());
+}
+
+TEST_F(CellularCapabilityUniversalCDMADispatcherTest,
+ UpdatePendingActivationState) {
+ capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED;
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_,_))
+ .Times(1);
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(_,_))
+ .Times(0);
+ EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(0);
+ capability_->UpdatePendingActivationState();
+ Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
+ Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
+
+ capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING;
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_,_))
+ .Times(0);
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(_,_))
+ .Times(2)
+ .WillRepeatedly(Return(PendingActivationStore::kStateUnknown));
+ EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(0);
+ capability_->UpdatePendingActivationState();
+ Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
+ Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
+
+ capability_->activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED;
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_,_))
+ .Times(0);
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(_,_))
+ .Times(2)
+ .WillRepeatedly(Return(PendingActivationStore::kStatePending));
+ EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(0);
+ capability_->UpdatePendingActivationState();
+ Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
+ Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
+
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_,_))
+ .Times(0);
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(_,_))
+ .Times(2)
+ .WillRepeatedly(Return(PendingActivationStore::kStateFailureRetry));
+ EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(1);
+ capability_->UpdatePendingActivationState();
+ Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
+ Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
+
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(), RemoveEntry(_,_))
+ .Times(0);
+ EXPECT_CALL(*modem_info_.mock_pending_activation_store(),
+ GetActivationState(_,_))
+ .Times(4)
+ .WillOnce(Return(PendingActivationStore::kStateActivated))
+ .WillOnce(Return(PendingActivationStore::kStateActivated))
+ .WillOnce(Return(PendingActivationStore::kStateUnknown))
+ .WillOnce(Return(PendingActivationStore::kStateUnknown));
+ EXPECT_CALL(*modem_info_.mock_dispatcher(), PostTask(_)).Times(0);
+ capability_->UpdatePendingActivationState();
+ capability_->UpdatePendingActivationState();
+ Mock::VerifyAndClearExpectations(modem_info_.mock_pending_activation_store());
+ Mock::VerifyAndClearExpectations(modem_info_.mock_dispatcher());
+}
+
} // namespace shill