| # Copyright (c) 2013 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import dbus |
| import dbus.types |
| import os |
| import time |
| |
| from autotest_lib.client.bin import test |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.cros.cellular import mm1_constants |
| from autotest_lib.client.cros.cellular import test_environment |
| from autotest_lib.client.cros.networking import pm_proxy |
| |
| I_ACTIVATION_TEST = 'Interface.CDMAActivationTest' |
| ACTIVATION_STATE_TIMEOUT = 10 |
| MODEM_STATE_TIMEOUT = 10 |
| TEST_MODEMS_MODULE_PATH = os.path.join(os.path.dirname(__file__), 'files', |
| 'modems.py') |
| |
| class ActivationTest(object): |
| """ |
| Super class that implements setup code that is common to the individual |
| tests. |
| |
| """ |
| def __init__(self, test): |
| self.test = test |
| self.modem_properties_interface = None |
| |
| |
| def run(self): |
| """ |
| Restarts the pseudomodem with the modem object to be used for this |
| test and runs the test. |
| |
| """ |
| self.pseudomm = pm_proxy.PseudoMMProxy.get_proxy() |
| self._run_test() |
| |
| |
| def _set_modem_activation_state(self, state): |
| self.pseudomm.get_modem().iface_properties.Set( |
| mm1_constants.I_MODEM_CDMA, |
| 'ActivationState', |
| dbus.types.UInt32(state)) |
| |
| |
| def _get_modem_activation_state(self): |
| modem = self.pseudomm.get_modem() |
| return modem.properties(mm1_constants.I_MODEM_CDMA)['ActivationState'] |
| |
| |
| def pseudomodem_flags(self): |
| """ |
| Subclasses must override this method to setup the flags map passed to |
| pseudomodem to suite their needs. |
| |
| """ |
| raise NotImplementedError() |
| |
| |
| def _run_test(self): |
| raise NotImplementedError() |
| |
| class ActivationStateTest(ActivationTest): |
| """ |
| This test verifies that the service "ActivationState" property matches the |
| cdma activation state exposed by ModemManager. |
| |
| """ |
| def pseudomodem_flags(self): |
| return {'family' : 'CDMA'} |
| |
| |
| def _run_test(self): |
| self.test.reset_modem() |
| |
| # The modem state should be REGISTERED. |
| self.test.check_modem_state(mm1_constants.MM_MODEM_STATE_REGISTERED) |
| |
| # Service should appear as 'activated'. |
| self.test.check_service_activation_state('activated') |
| |
| # Service activation state should change to 'not-activated'. |
| self._set_modem_activation_state( |
| mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED) |
| self.test.check_service_activation_state('not-activated') |
| |
| # Service activation state should change to 'activating'. |
| self._set_modem_activation_state( |
| mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING) |
| self.test.check_service_activation_state('activating') |
| |
| # Service activation state should change to 'partially-activated'. |
| st = mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_PARTIALLY_ACTIVATED |
| self._set_modem_activation_state(st) |
| self.test.check_service_activation_state('partially-activated') |
| |
| # Service activation state should change to 'activated'. |
| self._set_modem_activation_state( |
| mm1_constants.MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED) |
| self.test.check_service_activation_state('activated') |
| |
| |
| class ActivationSuccessTest(ActivationTest): |
| """ |
| This test verifies that the service finally bacomes "activated" when the |
| service is told to initiate OTASP activation. |
| |
| """ |
| def pseudomodem_flags(self): |
| return {'test-module' : TEST_MODEMS_MODULE_PATH, |
| 'test-modem-class' : 'UnactivatedCdmaModem'} |
| |
| |
| def _run_test(self): |
| self.test.reset_modem() |
| |
| # The modem state should be REGISTERED. |
| self.test.check_modem_state(mm1_constants.MM_MODEM_STATE_REGISTERED) |
| |
| # Service should appear as 'not-activated'. |
| self.test.check_service_activation_state('not-activated') |
| |
| # Call 'CompleteActivation' on the service. The service should become |
| # 'activating'. |
| service = self.test.test_env.shill.find_cellular_service_object() |
| service.CompleteCellularActivation() |
| self.test.check_service_activation_state('activating') |
| |
| # The modem should reset in 5 seconds. Wait 5 more seconds to make sure |
| # a new service gets created. |
| time.sleep(10) |
| self.test.check_service_activation_state('activated') |
| |
| |
| class ActivationFailureRetryTest(ActivationTest): |
| """ |
| This test verifies that if "ActivateAutomatic" fails, a retry will be |
| scheduled. |
| |
| """ |
| NUM_ACTIVATE_RETRIES = 5 |
| def pseudomodem_flags(self): |
| return {'test-module' : TEST_MODEMS_MODULE_PATH, |
| 'test-modem-class' : 'ActivationRetryModem', |
| 'test-modem-arg' : [self.NUM_ACTIVATE_RETRIES]} |
| |
| |
| def _run_test(self): |
| self.test.reset_modem() |
| |
| # The modem state should be REGISTERED. |
| self.test.check_modem_state(mm1_constants.MM_MODEM_STATE_REGISTERED) |
| |
| # Service should appear as 'not-activated'. |
| self.test.check_service_activation_state('not-activated') |
| |
| # Call 'CompleteActivation' on the service. |
| service = self.test.test_env.shill.find_cellular_service_object() |
| service.CompleteCellularActivation() |
| |
| # Wait for shill to retry the failed activations, except the last retry |
| # will succeed. |
| # NOTE: Don't check for transitory service activation states while this |
| # is happening because shill will reset the modem once the activation |
| # succeeds which will cause the existing service to get deleted. |
| modem = self.pseudomm.get_modem() |
| utils.poll_for_condition( |
| lambda: (modem.properties(I_ACTIVATION_TEST)['ActivateCount'] == |
| self.NUM_ACTIVATE_RETRIES), |
| exception=error.TestFail( |
| 'Shill did not retry failed activation'), |
| timeout=10) |
| |
| # The modem should reset in 5 seconds. Wait 5 more seconds to make sure |
| # a new service gets created. |
| time.sleep(10) |
| self.test.check_service_activation_state('activated') |
| |
| |
| class cellular_ActivateCDMA(test.test): |
| """ |
| Tests various scenarios that may arise during the post-payment CDMA |
| activation process when shill accesses the modem via ModemManager. |
| |
| """ |
| version = 1 |
| |
| def check_modem_state(self, expected_state, timeout=MODEM_STATE_TIMEOUT): |
| """ |
| Polls until the modem has the expected state within |timeout| seconds. |
| |
| @param expected_state: The modem state the modem is expected to be in. |
| @param timeout: The timeout interval for polling. |
| |
| @raises pm_proxy.ModemManager1ProxyError if the modem doesn't |
| transition to |expected_state| within |timeout|. |
| |
| """ |
| modem = pm_proxy.PseudoMMProxy.get_proxy().get_modem() |
| modem.wait_for_states([expected_state], timeout_seconds=timeout) |
| |
| |
| def check_service_activation_state(self, expected_state): |
| """ |
| Waits until the current cellular service has the expected activation |
| state within ACTIVATION_STATE_TIMEOUT seconds. |
| |
| @param expected_state: The activation state the service is expected to |
| be in. |
| @raises error.TestFail, if no cellular service is found or the service |
| activation state doesn't match |expected_state| within timeout. |
| |
| """ |
| success, state, _ = self.test_env.shill.wait_for_property_in( |
| self.test_env.shill.find_cellular_service_object(), |
| 'Cellular.ActivationState', |
| [expected_state], |
| ACTIVATION_STATE_TIMEOUT) |
| if not success: |
| raise error.TestFail( |
| 'Service activation state should be \'%s\', but it is ' |
| '\'%s\'.' % (expected_state, state)) |
| |
| |
| def reset_modem(self): |
| """ |
| Resets the one and only modem in the DUT. |
| |
| """ |
| modem = self.test_env.shill.find_cellular_device_object() |
| self.test_env.shill.reset_modem(modem) |
| |
| |
| def run_once(self): |
| tests = [ |
| ActivationStateTest(self), |
| ActivationSuccessTest(self), |
| ActivationFailureRetryTest(self) |
| ] |
| |
| for test in tests: |
| self.test_env = test_environment.CellularPseudoMMTestEnvironment( |
| pseudomm_args=(test.pseudomodem_flags(),)) |
| with self.test_env: |
| test.run() |
