| # Copyright 2015 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 logging, json |
| |
| from autotest_lib.client.bin import test, utils |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.cros.networking.chrome_testing \ |
| import chrome_networking_test_context as cntc |
| from autotest_lib.client.cros.networking.chrome_testing \ |
| import chrome_networking_test_api as cnta |
| from autotest_lib.client.cros.networking.chrome_testing import test_utils |
| from autotest_lib.client.cros.power import sys_power |
| from collections import namedtuple |
| |
| NetworkInfo = namedtuple('NetworkInfo', ['name', 'guid', 'connectionState', |
| 'networkType']) |
| |
| class network_ChromeCellularEndToEnd(test.test): |
| """ |
| Tests the following UI functionality with chrome.networkingPrivate APIs: |
| 1. Tests that the device auto connects to cellular network. |
| 3. Tests that the device prefers ethernet over cellular network. |
| 4. Tests that the enabling and disabling of cellular modem works. |
| |
| """ |
| version = 1 |
| |
| |
| def _extract_network_info(self, networks_found): |
| """Extract the needed information from the list of networks. |
| |
| @param networks_found: Networks found via api. |
| @return Formatted list of available cellular networks. |
| |
| """ |
| formatted_network_list = [] |
| |
| for network in networks_found: |
| network = NetworkInfo(name=network['Name'], |
| guid=network['GUID'], |
| connectionState=network.get('ConnectionState', 'none'), |
| networkType=network['Type']) |
| formatted_network_list.append(network) |
| |
| return formatted_network_list |
| |
| |
| def _set_autoconnect(self, service, value=True): |
| """Turn on autoconnect for cellular network. |
| |
| @param service: Cellular service dictionary |
| @value: Set / unset autoconnect |
| |
| """ |
| logging.debug('_set_autoconnect') |
| properties = json.dumps({'Cellular': {'AutoConnect': value}}) |
| set_properties = test_utils.call_test_function_check_success( |
| self._chrome_testing, |
| 'setProperties', |
| ('"' + service['GUID'] + '"', properties)) |
| self.chrome_net.scan_for_networks() |
| |
| |
| def _is_cellular_network_connected(self, service): |
| """Check if device is connected to cellular network. |
| |
| @param service: Cellular service dict |
| @return True if connected to cellular, else False |
| |
| """ |
| network_properties = self.chrome_net._chrome_testing.call_test_function( |
| test_utils.LONG_TIMEOUT, |
| 'getNetworkInfo', |
| ('"' + service['GUID'] + '"')) |
| |
| logging.debug('Network properties: %s', network_properties) |
| |
| if network_properties['status'] == 'chrome-test-call-status-failure': |
| raise error.TestFail('getNetworkInfo did not return with status ' |
| 'SUCCESS: %s' % network_properties['error']) |
| |
| if network_properties['result']['ConnectionState'] == 'Connected': |
| return True |
| |
| return False |
| |
| |
| def _cellular_service(self): |
| """Find cellular service. |
| |
| @return Cellular service dict |
| |
| """ |
| cell_networks = self.chrome_net._chrome_testing.find_cellular_networks() |
| for service in cell_networks: |
| if service['GUID']: |
| return service |
| |
| return None |
| |
| |
| def _find_cellular_service(self): |
| """Find and return cellular service if available. |
| |
| @return Cellular service |
| |
| """ |
| utils.poll_for_condition(lambda: self._cellular_service() is not None, |
| exception=error.TestFail('No cell service.'), |
| sleep_interval=1, |
| timeout=60) |
| return self._cellular_service() |
| |
| |
| def _connect_to_cellular_network(self, service): |
| """Connect to cellular network. |
| |
| @param service: Cellular service dict |
| |
| """ |
| logging.debug('_connect_to_cellular_network') |
| if service is None: |
| raise error.TestFail('GUID not available for cellular network.') |
| self.chrome_net.connect_to_network(service) |
| self.chrome_net.scan_for_networks() |
| |
| |
| def _autoconnect_cellular(self): |
| """Verify that the DUT is able to autoconnect to cellular network.""" |
| logging.debug('_autoconnect_cellular') |
| service = self._find_cellular_service() |
| logging.debug('Cellular service: %s', service) |
| |
| if service['ConnectionState'] == 'NotConnected': |
| self._connect_to_cellular_network(service) |
| |
| self._set_autoconnect(service) |
| |
| logging.debug('Suspend and resume device') |
| sys_power.do_suspend(20) |
| service = self._find_cellular_service() |
| |
| utils.poll_for_condition( |
| lambda: self._is_cellular_network_connected(service), |
| exception=error.TestFail('Network not connected after suspend ' |
| 'and resume.'), |
| sleep_interval=1, |
| timeout=60) |
| logging.debug('Autoconnect works after suspend/resume.') |
| |
| |
| def _get_networks(self, network_type='All'): |
| """Get available networks with getNetworks api. |
| |
| @param network_type: Type of network, defaults to All |
| @return List of networks found |
| |
| """ |
| logging.debug('_get_networks') |
| properties = json.dumps({'networkType': network_type, |
| 'visible': True, |
| 'limit': 2}) |
| network_list = self.chrome_net._chrome_testing.call_test_function( |
| test_utils.LONG_TIMEOUT, |
| 'getNetworks', |
| (properties)) |
| return network_list |
| |
| |
| def _ethernet_preferred_over_cellular(self): |
| """Verify that the DUT prefers ethernet over cellular connection.""" |
| logging.debug('_ethernet_preferred_over_cellular') |
| self.chrome_net.disable_network_device(self.chrome_net.WIFI_DEVICE) |
| network_list = self._get_networks() |
| |
| if not len(network_list['result']) > 1: |
| logging.debug('Available networks: %s', network_list) |
| raise error.TestFail('Not enough networks available to check ' |
| 'network preference. Need minimum 2 networks ' |
| 'to do a successfull comparision.') |
| |
| formatted_network_list = self._extract_network_info( |
| network_list['result']) |
| |
| logging.debug('Available network list: %s', formatted_network_list) |
| |
| if not formatted_network_list[0].networkType == 'Ethernet': |
| raise error.TestFail('Ethernet is not preferred.') |
| |
| if not formatted_network_list[1].networkType == 'Cellular': |
| raise error.TestFail('Cellular is not available to determine ' |
| 'network preference.') |
| |
| if (not formatted_network_list[0].connectionState == 'Connected' or |
| not formatted_network_list[1].connectionState == 'Connected'): |
| raise error.TestFail('Ethernet and Cellular should both be ' |
| 'connected to successfully determine ' |
| 'network preference.') |
| |
| logging.debug('Ethernet is preferred over cellular.') |
| |
| |
| def _enable_disable_network_check( |
| self, original_enabled_networks, new_enabled_networks): |
| """Tests enabling and disabling of Cellular. |
| |
| @param original_enabled_networks: Original list of network devices that |
| were enabled when the test started. |
| @param new_enabled_networks: New list of network devices that are |
| enabled now. |
| @raises error.TestFail if Cellular state is not toggled. |
| |
| """ |
| # Make sure we leave the Cellular modem in enabled state before |
| # ending the test. |
| logging.debug('_enable_disable_network_check') |
| self.chrome_net.enable_network_device(self.chrome_net.CELLULAR) |
| |
| if self.chrome_net.CELLULAR in original_enabled_networks: |
| if self.chrome_net.CELLULAR in new_enabled_networks: |
| raise error.TestFail('Cellular was not disabled.') |
| elif self.chrome_net.CELLULAR not in new_enabled_networks: |
| logging.info('Cellular was successfully disabled.') |
| |
| if self.chrome_net.CELLULAR not in original_enabled_networks: |
| if self.chrome_net.CELLULAR not in new_enabled_networks: |
| raise error.TestFail('Cellular was not enabled.') |
| elif self.chrome_net.CELLULAR in new_enabled_networks: |
| logging.info('Cellular was successfully enabled.') |
| |
| |
| def _enable_disable_cellular(self): |
| """Verify that the test is able to enable and disable Cellular.""" |
| logging.debug('_enable_disable_cellular') |
| original_enabled_networks = self.chrome_net.get_enabled_devices() |
| if self.chrome_net.CELLULAR in original_enabled_networks: |
| self.chrome_net.disable_network_device(self.chrome_net.CELLULAR) |
| else: |
| self.chrome_net.enable_network_device(self.chrome_net.CELLULAR) |
| new_enabled_networks = self.chrome_net.get_enabled_devices() |
| self._enable_disable_network_check( |
| original_enabled_networks, new_enabled_networks) |
| |
| |
| def run_once(self, test): |
| """Runs the test. |
| |
| @param test: Set by the server test control file depending on the test |
| that is being run. |
| |
| """ |
| with cntc.ChromeNetworkingTestContext() as testing_context: |
| self._chrome_testing = testing_context |
| self.chrome_net = cnta.ChromeNetworkProvider(testing_context) |
| enabled_devices = self.chrome_net.get_enabled_devices() |
| |
| logging.debug('Enabled devices: %s', enabled_devices) |
| if (self.chrome_net.CELLULAR not in enabled_devices): |
| self.chrome_net.enable_network_device( |
| self.chrome_net.CELLULAR) |
| self.chrome_net.scan_for_networks() |
| |
| if test == 'autoconnectCellular': |
| self._autoconnect_cellular() |
| elif test == 'ethernetPreferred': |
| self._ethernet_preferred_over_cellular() |
| elif test == 'enableDisableCellular': |
| self._enable_disable_cellular() |
