| # Copyright (c) 2014 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 |
| import time |
| |
| from autotest_lib.client.bin import test |
| 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 test_utils |
| from collections import namedtuple |
| |
| NetworkInfo = namedtuple('NetworkInfo', 'name guid connectionState security') |
| |
| class network_ChromeWifiEndToEnd(test.test): |
| """ |
| Tests the following with chrome.networkingPrivate APIs: |
| 1. Tests that the configured wifi networks are seen by Chrome. |
| 2. Tests the transitioning between various available networks. |
| 3. Tests that the enabling and disabling WiFi works. |
| |
| """ |
| version = 1 |
| |
| WIFI_NETWORK_DEVICE = 'WiFi' |
| |
| SHORT_TIMEOUT = 2 |
| |
| |
| def _get_wifi_networks(self): |
| """Get list of available wifi networks. |
| |
| @raises error.TestFail if no wifi networks are found. |
| @return List of dictionaries containing wifi network information. |
| |
| """ |
| wifi_networks = self._chrome_testing.find_wifi_networks() |
| if not wifi_networks: |
| raise error.TestFail('No wifi networks found.') |
| |
| return wifi_networks |
| |
| |
| def _extract_wifi_network_info(self, networks_found): |
| """Extract the needed information from the list of networks found |
| via API. |
| |
| @param networks_found: Networks found via getVisibleNetworks api. |
| @return Formated list of available wifi networks. |
| |
| """ |
| network_list = [] |
| |
| for network in networks_found: |
| network = NetworkInfo(name=network['Name'], |
| guid=network['GUID'], |
| connectionState=network['ConnectionState'], |
| security=network['WiFi']['Security']) |
| network_list.append(network) |
| |
| return network_list |
| |
| |
| def _wifi_network_comparison( |
| self, configured_service_name_list, wifi_name_list): |
| """Compare the known wifi SSID's against the SSID's returned via API. |
| |
| @param configured_service_name_list: Known SSID's that are configured |
| by the network_WiFi_ChromeEndToEnd test. |
| @param wifi_name_list: List of SSID's returned by the |
| getVisibleNetworks API. |
| @raises error.TestFail if network names do not match. |
| |
| """ |
| for name in configured_service_name_list: |
| if name not in wifi_name_list: |
| raise error.TestFail( |
| 'Following network does not match: %s' % name) |
| logging.info('Network names match!') |
| |
| |
| def _enable_disable_network_check( |
| self, original_enabled_networks, new_enabled_networks): |
| """Tests enabling and disabling of WiFi. |
| |
| @param original_enabled_networks: List of network devices that were |
| enabled when the test started. |
| @param new_enabled_networks: List of network devices that are now |
| now enabled. |
| @raises error.TestFail if WiFi state is not toggled. |
| |
| """ |
| # Make sure we leave the WiFi network device in enabled state before |
| # ending the test. |
| self._enable_network_device(self.WIFI_NETWORK_DEVICE) |
| |
| if (self.WIFI_NETWORK_DEVICE in original_enabled_networks and |
| self.WIFI_NETWORK_DEVICE in new_enabled_networks): |
| raise error.TestFail('WiFi was not disabled.') |
| if (self.WIFI_NETWORK_DEVICE not in original_enabled_networks and |
| self.WIFI_NETWORK_DEVICE not in new_enabled_networks): |
| raise error.TestFail('WiFi was not enabled.') |
| logging.info('Enabling / Disabling WiFi works!') |
| |
| |
| def _get_enabled_network_devices(self): |
| """Get list of enabled network devices on the device. |
| |
| @return List of enabled network devices. |
| |
| """ |
| enabled_network_types = self._chrome_testing.call_test_function( |
| test_utils.LONG_TIMEOUT, |
| 'getEnabledNetworkDevices') |
| for key, value in enabled_network_types.items(): |
| if key == 'result': |
| logging.info('Enabled Network Devices: %s', value) |
| return value |
| |
| |
| def _enable_network_device(self, network): |
| """Enable given network device. |
| |
| @param network: string name of the network device to be enabled. Options |
| include 'WiFi', 'Cellular' and 'Ethernet'. |
| |
| """ |
| logging.info('Enabling: %s', network) |
| enable_network_result = self._chrome_testing.call_test_function_async( |
| 'enableNetworkDevice', |
| '"' + network + '"') |
| # Added delay to allow DUT enough time to fully transition into enabled |
| # state before other actions are performed. |
| time.sleep(self.SHORT_TIMEOUT) |
| |
| |
| def _disable_network_device(self, network): |
| """Disable given network device. |
| |
| @param network: string name of the network device to be disabled. |
| Options include 'WiFi', 'Cellular' and 'Ethernet'. |
| |
| """ |
| # Do ChromeOS browser session teardown/setup before disabling the |
| # network device because chrome.networkingPrivate.disableNetworkType API |
| # fails to disable the network device on subsequent calls if we do not |
| # teardown and setup the browser session. |
| self._chrome_testing.teardown() |
| self._chrome_testing.setup() |
| |
| logging.info('Disabling: %s', network) |
| disable_network_result = self._chrome_testing.call_test_function_async( |
| 'disableNetworkDevice', |
| '"' + network + '"') |
| |
| |
| def _scan_for_networks(self): |
| self._chrome_testing.call_test_function_async('requestNetworkScan') |
| # Added delay to allow enough time for Chrome to scan and get all the |
| # network ssids and make them available for the test to use. |
| time.sleep(self.SHORT_TIMEOUT) |
| |
| |
| def _find_and_transition_wifi_networks_in_range(self): |
| """Verify all WiFi networks in range are displayed.""" |
| known_service_names_in_wifi_cell = [self.SSID_1, self.SSID_2] |
| networks_found_via_api = self._get_wifi_networks() |
| network_list = self._extract_wifi_network_info(networks_found_via_api) |
| logging.info('Networks found via API: %s', networks_found_via_api) |
| |
| wifi_names_found_via_api = [] |
| known_wifi_network_details = [] |
| |
| for network in network_list: |
| if network.name in known_service_names_in_wifi_cell: |
| known_wifi_network_details.append(network) |
| wifi_names_found_via_api.append(network.name) |
| |
| if self.TEST in ('all', 'findVerifyWiFiNetworks'): |
| self._wifi_network_comparison( |
| known_service_names_in_wifi_cell, wifi_names_found_via_api) |
| if self.TEST in ('all', 'transitionWiFiNetworks'): |
| self._transition_wifi_networks(known_wifi_network_details) |
| |
| |
| def _enable_disable_wifi(self): |
| """Verify that the test is able to enable and disable WiFi.""" |
| original_enabled_networks = self._get_enabled_network_devices() |
| if self.WIFI_NETWORK_DEVICE in original_enabled_networks: |
| self._disable_network_device(self.WIFI_NETWORK_DEVICE) |
| else: |
| self._enable_network_device(self.WIFI_NETWORK_DEVICE) |
| new_enabled_networks = self._get_enabled_network_devices() |
| self._enable_disable_network_check( |
| original_enabled_networks, new_enabled_networks) |
| |
| |
| def _transition_wifi_networks(self, known_wifi_networks): |
| """Verify that the test is able to transition between the two known |
| wifi networks. |
| |
| @param known_wifi_networks: List of known wifi networks. |
| @raises error.TestFail if device is not able to transition to a |
| known wifi network. |
| |
| """ |
| if not known_wifi_networks: |
| raise error.TestFail('No pre-configured network available for ' |
| 'connection/transition.') |
| |
| for network in known_wifi_networks: |
| new_network_connect = self._chrome_testing.call_test_function( |
| test_utils.LONG_TIMEOUT, |
| 'connectToNetwork', |
| '"' + network.guid +'"') |
| if (new_network_connect['status'] == |
| 'chrome-test-call-status-failure'): |
| raise error.TestFail( |
| 'Could not connect to %s network. Error returned by ' |
| 'chrome.networkingPrivate.startConnect API: %s' % |
| (network.name, new_network_connect['error'])) |
| logging.info('Successfully transitioned to: %s', network.name) |
| |
| |
| def run_once(self, ssid_1, ssid_2, test): |
| """Run the test. |
| |
| @param ssid_1: SSID of the first AP. |
| @param ssid_2: SSID of the second AP. |
| @param test: Set by the server test control file depending on the test |
| that is being run. |
| |
| """ |
| self.SSID_1 = ssid_1 |
| self.SSID_2 = ssid_2 |
| self.TEST = test |
| |
| with cntc.ChromeNetworkingTestContext() as testing_context: |
| self._chrome_testing = testing_context |
| enabled_networks_devices = self._get_enabled_network_devices() |
| if self.WIFI_NETWORK_DEVICE not in enabled_networks_devices: |
| self._enable_network_device(self.WIFI_NETWORK_DEVICE) |
| self._scan_for_networks() |
| |
| if test == 'all': |
| self._find_and_transition_wifi_networks_in_range() |
| self._enable_disable_wifi() |
| elif test in ('findVerifyWiFiNetworks', 'transitionWiFiNetworks'): |
| self._find_and_transition_wifi_networks_in_range() |
| elif test == 'enableDisableWiFi': |
| self._enable_disable_wifi() |
