| # !/usr/bin/env python3.4 |
| # |
| # Copyright 2017 - The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| import re |
| from acts import asserts |
| from acts.controllers.android_device import SL4A_APK_NAME |
| from acts.libs.ota import ota_updater |
| import acts.signals as signals |
| from acts.test_decorators import test_tracker_info |
| from acts_contrib.test_utils.tel.tel_wifi_utils import WIFI_CONFIG_APBAND_5G |
| import acts_contrib.test_utils.wifi.wifi_test_utils as wutils |
| from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest |
| import acts.utils as utils |
| |
| WifiEnums = wutils.WifiEnums |
| SSID = WifiEnums.SSID_KEY |
| PWD = WifiEnums.PWD_KEY |
| NETID = WifiEnums.NETID_KEY |
| # Default timeout used for reboot, toggle WiFi and Airplane mode, |
| # for the system to settle down after the operation. |
| DEFAULT_TIMEOUT = 10 |
| BAND_2GHZ = 0 |
| BAND_5GHZ = 1 |
| |
| |
| class WifiAutoUpdateTest(WifiBaseTest): |
| """Tests for APIs in Android's WifiManager class. |
| |
| Test Bed Requirement: |
| * One Android device |
| * Several Wi-Fi networks visible to the device, including an open Wi-Fi |
| network. |
| """ |
| |
| def __init__(self, controllers): |
| WifiBaseTest.__init__(self, controllers) |
| self.tests = ( |
| "test_check_wifi_state_after_au", |
| "test_verify_networks_after_au", |
| "test_configstore_after_au", |
| "test_mac_randomization_after_au", |
| "test_wifi_hotspot_5g_psk_after_au", |
| "test_all_networks_connectable_after_au", |
| "test_connect_to_network_suggestion_after_au", |
| "test_check_wifi_toggling_after_au", |
| "test_connection_to_new_networks", |
| "test_reset_wifi_after_au") |
| |
| def setup_class(self): |
| super(WifiAutoUpdateTest, self).setup_class() |
| ota_updater.initialize(self.user_params, self.android_devices) |
| self.dut = self.android_devices[0] |
| self.dut_client = self.android_devices[1] |
| wutils.wifi_test_device_init(self.dut) |
| wutils.wifi_toggle_state(self.dut, True) |
| |
| # configure APs |
| opt_param = ["reference_networks"] |
| self.unpack_userparams(opt_param_names=opt_param) |
| if "AccessPoint" in self.user_params: |
| self.legacy_configure_ap_and_start(wpa_network=True, |
| wep_network=True) |
| elif "OpenWrtAP" in self.user_params: |
| self.configure_openwrt_ap_and_start(wpa_network=True, |
| wep_network=True, |
| ap_count=2) |
| self.wpapsk_2g = self.reference_networks[0]["2g"] |
| self.wpapsk_5g = self.reference_networks[0]["5g"] |
| self.wep_2g = self.wep_networks[0]["2g"] |
| self.wep_5g = self.wep_networks[0]["5g"] |
| |
| # saved & connected networks, network suggestions |
| # and new networks |
| self.saved_networks = [self.wep_2g] |
| self.network_suggestions = [self.wpapsk_5g] |
| self.connected_networks = [self.wpapsk_2g, self.wep_5g] |
| self.new_networks = [self.reference_networks[1]["2g"], |
| self.wep_networks[1]["5g"]] |
| |
| # add pre ota upgrade configuration |
| self.wifi_config_list = [] |
| self.pre_default_mac = {} |
| self.pre_random_mac = {} |
| self.pst_default_mac = {} |
| self.pst_random_mac = {} |
| self.add_pre_update_configuration() |
| |
| # Run OTA below, if ota fails then abort all tests. |
| try: |
| ota_updater.update(self.dut) |
| except Exception as e: |
| raise signals.TestAbortClass( |
| "Failed up apply OTA update. Aborting tests: %s" % e) |
| |
| def setup_test(self): |
| super().setup_test() |
| self.dut.droid.wakeLockAcquireBright() |
| self.dut.droid.wakeUpNow() |
| |
| def teardown_test(self): |
| super().teardown_test() |
| self.dut.droid.wakeLockRelease() |
| self.dut.droid.goToSleepNow() |
| |
| def teardown_class(self): |
| if "AccessPoint" in self.user_params: |
| del self.user_params["reference_networks"] |
| |
| ### Helper Methods |
| |
| def add_pre_update_configuration(self): |
| self.add_network_suggestions(self.network_suggestions) |
| self.add_network_and_enable(self.saved_networks[0]) |
| self.add_wifi_hotspot() |
| self.connect_to_multiple_networks(self.connected_networks) |
| |
| def add_wifi_hotspot(self): |
| self.wifi_hotspot = {"SSID": "hotspot_%s" % utils.rand_ascii_str(6), |
| "password": "pass_%s" % utils.rand_ascii_str(6)} |
| band = WIFI_CONFIG_APBAND_5G |
| if self.dut.build_info["build_id"].startswith("R"): |
| band = WifiEnums.WIFI_CONFIG_SOFTAP_BAND_5G |
| self.wifi_hotspot[WifiEnums.AP_BAND_KEY] = band |
| asserts.assert_true( |
| self.dut.droid.wifiSetWifiApConfiguration(self.wifi_hotspot), |
| "Failed to set WifiAp Configuration") |
| wifi_ap = self.dut.droid.wifiGetApConfiguration() |
| asserts.assert_true( |
| wifi_ap[WifiEnums.SSID_KEY] == self.wifi_hotspot[WifiEnums.SSID_KEY], |
| "Hotspot SSID doesn't match with expected SSID") |
| return |
| if self.dut.build_info["build_id"].startswith("Q"): |
| band = WifiEnums.WIFI_CONFIG_APBAND_5G_OLD |
| self.wifi_hotspot[WifiEnums.AP_BAND_KEY] = band |
| asserts.assert_true( |
| self.dut.droid.wifiSetWifiApConfiguration(self.wifi_hotspot), |
| "Failed to set WifiAp Configuration") |
| wifi_ap = self.dut.droid.wifiGetApConfiguration() |
| asserts.assert_true( |
| wifi_ap[WifiEnums.SSID_KEY] == self.wifi_hotspot[WifiEnums.SSID_KEY], |
| "Hotspot SSID doesn't match with expected SSID") |
| return |
| wutils.save_wifi_soft_ap_config(self.dut, self.wifi_hotspot, band) |
| |
| def verify_wifi_hotspot(self): |
| """Verify wifi tethering.""" |
| wutils.start_wifi_tethering_saved_config(self.dut) |
| wutils.connect_to_wifi_network(self.dut_client, |
| self.wifi_hotspot, |
| check_connectivity=False) |
| wutils.stop_wifi_tethering(self.dut) |
| |
| def connect_to_multiple_networks(self, networks): |
| """Connect to a list of wifi networks. |
| |
| Args: |
| networks : list of wifi networks. |
| """ |
| self.log.info("Connect to multiple wifi networks") |
| for network in networks: |
| ssid = network[SSID] |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, ssid) |
| wutils.wifi_connect(self.dut, network, num_of_tries=6) |
| self.wifi_config_list.append(network) |
| self.pre_default_mac[network[SSID]] = self.get_sta_mac_address() |
| self.pre_random_mac[network[SSID]] = \ |
| self.dut.droid.wifigetRandomizedMacAddress(network) |
| |
| def get_sta_mac_address(self): |
| """Gets the current MAC address being used for client mode.""" |
| out = self.dut.adb.shell("ifconfig wlan0") |
| res = re.match(".* HWaddr (\S+).*", out, re.S) |
| return res.group(1) |
| |
| def add_network_suggestions(self, network_suggestions): |
| """Add wifi network suggestions to DUT. |
| |
| Args: |
| network_suggestions : suggestions to add. |
| """ |
| self.dut.log.info("Adding network suggestions") |
| asserts.assert_true( |
| self.dut.droid.wifiAddNetworkSuggestions(network_suggestions), |
| "Failed to add suggestions") |
| |
| # Enable suggestions by the app. |
| self.dut.log.debug("Enabling suggestions from test") |
| self.dut.adb.shell( |
| "cmd wifi network-suggestions-set-user-approved %s yes" % \ |
| SL4A_APK_NAME) |
| |
| def remove_suggestions_and_ensure_no_connection(self, |
| network_suggestions, |
| expected_ssid): |
| """Remove network suggestions. |
| |
| Args: |
| network_suggestions : suggestions to remove. |
| expected_ssid : SSID to verify that DUT is not connected. |
| """ |
| # remove network suggestion and verify disconnect |
| self.dut.log.info("Removing network suggestions") |
| asserts.assert_true( |
| self.dut.droid.wifiRemoveNetworkSuggestions(network_suggestions), |
| "Failed to remove suggestions") |
| |
| wutils.wait_for_disconnect(self.dut) |
| self.dut.ed.clear_all_events() |
| |
| # Now ensure that we didn't connect back. |
| asserts.assert_false( |
| wutils.wait_for_connect(self.dut, |
| expected_ssid, |
| assert_on_fail=False), |
| "Device should not connect back") |
| |
| def add_network_and_enable(self, network): |
| """Add a network and enable it. |
| |
| Args: |
| network : Network details for the network to be added. |
| """ |
| self.log.info("Add a wifi network and enable it") |
| ret = self.dut.droid.wifiAddNetwork(network) |
| asserts.assert_true(ret != -1, "Add network %r failed" % network) |
| self.wifi_config_list.append({SSID: network[SSID], NETID: ret}) |
| self.dut.droid.wifiEnableNetwork(ret, 0) |
| |
| def check_networks_after_autoupdate(self, networks): |
| """Verify that all previously configured networks are persistent. |
| |
| Args: |
| networks: List of network dicts. |
| """ |
| network_info = self.dut.droid.wifiGetConfiguredNetworks() |
| """ |
| b/189285598, the network id of a network might be changed after \ |
| reboot because the network sequence is not stable on \ |
| backup/restore. This test should find the correct network against |
| the desired SSID before connecting to the network after reboot. |
| Start from Android S. |
| """ |
| network_info_ssid = list() |
| for i in network_info: |
| network_info_ssid.append(i['SSID']) |
| network_info_ssid_list = set(network_info_ssid) |
| networks_ssid= list() |
| for i in networks: |
| networks_ssid.append(i['SSID']) |
| networks_ssid_list = set(networks_ssid) |
| if len(network_info_ssid_list) != len(networks_ssid_list): |
| msg = ( |
| "Number of configured networks before and after Auto-update " |
| "don't match. \nBefore reboot = %s \n After reboot = %s" % |
| (networks, network_info)) |
| raise signals.TestFailure(msg) |
| |
| # For each network, check if it exists in configured list after Auto- |
| # update. |
| for network in networks: |
| exists = wutils.match_networks({SSID: network[SSID]}, network_info) |
| if not exists: |
| raise signals.TestFailure("%s network is not present in the" |
| " configured list after Auto-update" % |
| network[SSID]) |
| |
| # Get the new network id for each network after reboot. |
| network[NETID] = exists[0]["networkId"] |
| |
| def get_enabled_network(self, network1, network2): |
| """Check network status and return currently unconnected network. |
| |
| Args: |
| network1: dict representing a network. |
| network2: dict representing a network. |
| |
| Returns: |
| Network dict of the unconnected network. |
| """ |
| wifi_info = self.dut.droid.wifiGetConnectionInfo() |
| enabled = network1 |
| if wifi_info[SSID] == network1[SSID]: |
| enabled = network2 |
| return enabled |
| |
| ### Tests |
| |
| @test_tracker_info(uuid="9ff1f01e-e5ff-408b-9a95-29e87a2df2d8") |
| @WifiBaseTest.wifi_test_wrap |
| def test_check_wifi_state_after_au(self): |
| """Check if the state of WiFi is enabled after Auto-update.""" |
| if not self.dut.droid.wifiCheckState(): |
| raise signals.TestFailure("WiFi is disabled after Auto-update!!!") |
| |
| @test_tracker_info(uuid="e3ebdbba-71dd-4281-aef8-5b3d42b88770") |
| @WifiBaseTest.wifi_test_wrap |
| def test_verify_networks_after_au(self): |
| """Check if the previously added networks are intact. |
| |
| Steps: |
| Number of networs should be the same and match each network. |
| |
| """ |
| self.check_networks_after_autoupdate(self.wifi_config_list) |
| |
| @test_tracker_info(uuid="799e83c2-305d-4510-921e-dac3c0dbb6c5") |
| @WifiBaseTest.wifi_test_wrap |
| def test_configstore_after_au(self): |
| """Verify DUT automatically connects to wifi networks after ota. |
| |
| Steps: |
| 1. Connect to two wifi networks pre ota. |
| 2. Verify DUT automatically connects to 1 after ota. |
| 3. Re-connect to the other wifi network. |
| """ |
| wifi_info = self.dut.droid.wifiGetConnectionInfo() |
| self.pst_default_mac[wifi_info[SSID]] = self.get_sta_mac_address() |
| self.pst_random_mac[wifi_info[SSID]] = \ |
| self.dut.droid.wifigetRandomizedMacAddress(wifi_info) |
| reconnect_to = self.get_enabled_network(self.wifi_config_list[1], |
| self.wifi_config_list[2]) |
| wutils.start_wifi_connection_scan_and_ensure_network_found( |
| self.dut, reconnect_to[SSID]) |
| wutils.wifi_connect_by_id(self.dut, reconnect_to[NETID]) |
| connect_data = self.dut.droid.wifiGetConnectionInfo() |
| connect_ssid = connect_data[SSID] |
| self.log.info("Expected SSID = %s" % reconnect_to[SSID]) |
| self.log.info("Connected SSID = %s" % connect_ssid) |
| if connect_ssid != reconnect_to[SSID]: |
| raise signals.TestFailure( |
| "Device failed to reconnect to the correct" |
| " network after reboot.") |
| self.pst_default_mac[wifi_info[SSID]] = self.get_sta_mac_address() |
| self.pst_random_mac[wifi_info[SSID]] = \ |
| self.dut.droid.wifigetRandomizedMacAddress(wifi_info) |
| |
| for network in self.connected_networks: |
| wutils.wifi_forget_network(self.dut, network[SSID]) |
| |
| @test_tracker_info(uuid="e26d0ed9-9457-4a95-a962-4d43b0032bac") |
| @WifiBaseTest.wifi_test_wrap |
| def test_mac_randomization_after_au(self): |
| """Verify randomized MAC addrs are persistent after ota. |
| |
| Steps: |
| 1. Reconnect to the wifi networks configured pre ota. |
| 2. Get the randomized MAC addrs. |
| """ |
| for ssid, mac in self.pst_random_mac.items(): |
| asserts.assert_true( |
| self.pre_random_mac[ssid] == mac, |
| "MAC addr of %s is %s after ota. Expected %s" % |
| (ssid, mac, self.pre_random_mac[ssid])) |
| |
| @test_tracker_info(uuid="f68a65e6-97b7-4746-bad8-4c206551d87e") |
| @WifiBaseTest.wifi_test_wrap |
| def test_wifi_hotspot_5g_psk_after_au(self): |
| """Verify hotspot after ota upgrade. |
| |
| Steps: |
| 1. Start wifi hotspot on the saved config. |
| 2. Verify DUT client connects to it. |
| """ |
| self.verify_wifi_hotspot() |
| |
| @test_tracker_info(uuid="21f91372-88a6-44b9-a4e8-d4664823dffb") |
| @WifiBaseTest.wifi_test_wrap |
| def test_connect_to_network_suggestion_after_au(self): |
| """Verify connection to network suggestion after ota. |
| |
| Steps: |
| 1. DUT has network suggestion added before OTA. |
| 2. Wait for the device to connect to it. |
| 3. Remove the suggestions and ensure the device does not |
| connect back. |
| """ |
| wutils.reset_wifi(self.dut) |
| wutils.start_wifi_connection_scan_and_return_status(self.dut) |
| wutils.wait_for_connect(self.dut, self.network_suggestions[0][SSID]) |
| self.remove_suggestions_and_ensure_no_connection( |
| self.network_suggestions, self.network_suggestions[0][SSID]) |
| |
| @test_tracker_info(uuid="b8e47a4f-62fe-4a0e-b999-27ae1ebf4d19") |
| @WifiBaseTest.wifi_test_wrap |
| def test_connection_to_new_networks(self): |
| """Check if we can connect to new networks after Auto-update. |
| |
| Steps: |
| 1. Connect to a PSK network. |
| 2. Connect to an open network. |
| 3. Forget ntworks added in 1 & 2. |
| TODO: (@bmahadev) Add WEP network once it's ready. |
| """ |
| for network in self.new_networks: |
| wutils.connect_to_wifi_network(self.dut, network) |
| for network in self.new_networks: |
| wutils.wifi_forget_network(self.dut, network[SSID]) |
| |
| @test_tracker_info(uuid="1d8309e4-d5a2-4f48-ba3b-895a58c9bf3a") |
| @WifiBaseTest.wifi_test_wrap |
| def test_all_networks_connectable_after_au(self): |
| """Check if previously added networks are connectable. |
| |
| Steps: |
| 1. Connect to previously added PSK network using network id. |
| 2. Connect to previously added open network using network id. |
| TODO: (@bmahadev) Add WEP network once it's ready. |
| """ |
| network = self.wifi_config_list[0] |
| if not wutils.connect_to_wifi_network_with_id(self.dut, |
| network[NETID], |
| network[SSID]): |
| raise signals.TestFailure("Failed to connect to %s after OTA" % |
| network[SSID]) |
| wutils.wifi_forget_network(self.dut, network[SSID]) |
| |
| @test_tracker_info(uuid="05671859-38b1-4dbf-930c-18048971d075") |
| @WifiBaseTest.wifi_test_wrap |
| def test_check_wifi_toggling_after_au(self): |
| """Check if WiFi can be toggled ON/OFF after auto-update.""" |
| self.log.debug("Going from on to off.") |
| wutils.wifi_toggle_state(self.dut, False) |
| self.log.debug("Going from off to on.") |
| wutils.wifi_toggle_state(self.dut, True) |
| |
| @test_tracker_info(uuid="440edf32-4b00-42b0-9811-9f2bc4a83efb") |
| @WifiBaseTest.wifi_test_wrap |
| def test_reset_wifi_after_au(self): |
| """"Check if WiFi can be reset after auto-update.""" |
| wutils.reset_wifi(self.dut) |
