| #!/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 itertools |
| import pprint |
| import queue |
| import time |
| |
| import acts.base_test |
| import acts.test_utils.wifi.wifi_test_utils as wutils |
| |
| |
| import WifiManagerTest |
| from acts import asserts |
| from acts import signals |
| from acts.libs.uicd.uicd_cli import UicdCli |
| from acts.libs.uicd.uicd_cli import UicdError |
| from acts.test_decorators import test_tracker_info |
| from acts.test_utils.tel.tel_test_utils import get_operator_name |
| from acts.utils import force_airplane_mode |
| |
| WifiEnums = wutils.WifiEnums |
| |
| DEFAULT_TIMEOUT = 10 |
| OSU_TEST_TIMEOUT = 300 |
| |
| # Constants for providers. |
| GLOBAL_RE = 0 |
| OSU_BOINGO = 0 |
| BOINGO = 1 |
| ATT = 2 |
| |
| # Constants used for various device operations. |
| RESET = 1 |
| TOGGLE = 2 |
| |
| UNKNOWN_FQDN = "@#@@!00fffffx" |
| |
| class WifiPasspointTest(acts.base_test.BaseTestClass): |
| """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 setup_class(self): |
| self.dut = self.android_devices[0] |
| wutils.wifi_test_device_init(self.dut) |
| req_params = ["passpoint_networks", "uicd_workflows", "uicd_zip"] |
| opt_param = [] |
| self.unpack_userparams( |
| req_param_names=req_params, opt_param_names=opt_param) |
| self.unpack_userparams(req_params) |
| asserts.assert_true( |
| len(self.passpoint_networks) > 0, |
| "Need at least one Passpoint network.") |
| wutils.wifi_toggle_state(self.dut, True) |
| self.unknown_fqdn = UNKNOWN_FQDN |
| # Setup Uicd cli object for UI interation. |
| self.ui = UicdCli(self.uicd_zip[0], self.uicd_workflows) |
| |
| |
| def setup_test(self): |
| self.dut.droid.wakeLockAcquireBright() |
| self.dut.droid.wakeUpNow() |
| |
| |
| def teardown_test(self): |
| self.dut.droid.wakeLockRelease() |
| self.dut.droid.goToSleepNow() |
| wutils.reset_wifi(self.dut) |
| |
| |
| def on_fail(self, test_name, begin_time): |
| self.dut.take_bug_report(test_name, begin_time) |
| |
| |
| """Helper Functions""" |
| |
| |
| def install_passpoint_profile(self, passpoint_config): |
| """Install the Passpoint network Profile. |
| |
| Args: |
| passpoint_config: A JSON dict of the Passpoint configuration. |
| |
| """ |
| asserts.assert_true(WifiEnums.SSID_KEY in passpoint_config, |
| "Key '%s' must be present in network definition." % |
| WifiEnums.SSID_KEY) |
| # Install the Passpoint profile. |
| self.dut.droid.addUpdatePasspointConfig(passpoint_config) |
| |
| |
| def check_passpoint_connection(self, passpoint_network): |
| """Verify the device is automatically able to connect to the Passpoint |
| network. |
| |
| Args: |
| passpoint_network: SSID of the Passpoint network. |
| |
| """ |
| ad = self.dut |
| ad.ed.clear_all_events() |
| wutils.start_wifi_connection_scan(ad) |
| scan_results = ad.droid.wifiGetScanResults() |
| # Wait for scan to complete. |
| time.sleep(5) |
| ssid = passpoint_network |
| wutils.assert_network_in_list({WifiEnums.SSID_KEY: ssid}, scan_results) |
| # Passpoint network takes longer time to connect than normal networks. |
| # Every try comes with a timeout of 30s. Setting total timeout to 120s. |
| wutils.wifi_passpoint_connect(self.dut, passpoint_network, num_of_tries=4) |
| # Re-verify we are connected to the correct network. |
| network_info = self.dut.droid.wifiGetConnectionInfo() |
| if network_info[WifiEnums.SSID_KEY] != passpoint_network: |
| raise signals.TestFailure("Device did not connect to the passpoint" |
| " network.") |
| |
| |
| def get_configured_passpoint_and_delete(self): |
| """Get configured Passpoint network and delete using its FQDN.""" |
| passpoint_config = self.dut.droid.getPasspointConfigs() |
| if not len(passpoint_config): |
| raise signals.TestFailure("Failed to fetch the list of configured" |
| "passpoint networks.") |
| if not wutils.delete_passpoint(self.dut, passpoint_config[0]): |
| raise signals.TestFailure("Failed to delete Passpoint configuration" |
| " with FQDN = %s" % passpoint_config[0]) |
| |
| def start_subscription_provisioning(self, state): |
| """Start subscription provisioning with a default provider.""" |
| |
| self.unpack_userparams(('osu_configs',)) |
| asserts.assert_true( |
| len(self.osu_configs) > 0, |
| "Need at least one osu config.") |
| osu_config = self.osu_configs[OSU_BOINGO] |
| # Clear all previous events. |
| self.dut.ed.clear_all_events() |
| self.dut.droid.startSubscriptionProvisioning(osu_config) |
| start_time = time.time() |
| while time.time() < start_time + OSU_TEST_TIMEOUT: |
| dut_event = self.dut.ed.pop_event("onProvisioningCallback", |
| DEFAULT_TIMEOUT * 18) |
| if dut_event['data']['tag'] == 'success': |
| self.log.info("Passpoint Provisioning Success") |
| # Reset WiFi after provisioning success. |
| if state == RESET: |
| wutils.reset_wifi(self.dut) |
| time.sleep(DEFAULT_TIMEOUT) |
| # Toggle WiFi after provisioning success. |
| elif state == TOGGLE: |
| wutils.toggle_wifi_off_and_on(self.dut) |
| time.sleep(DEFAULT_TIMEOUT) |
| break |
| if dut_event['data']['tag'] == 'failure': |
| raise signals.TestFailure( |
| "Passpoint Provisioning is failed with %s" % |
| dut_event['data'][ |
| 'reason']) |
| break |
| if dut_event['data']['tag'] == 'status': |
| self.log.info( |
| "Passpoint Provisioning status %s" % dut_event['data'][ |
| 'status']) |
| if int(dut_event['data']['status']) == 7: |
| self.ui.run(self.dut.serial, "passpoint-login") |
| # Clear all previous events. |
| self.dut.ed.clear_all_events() |
| |
| # Verify device connects to the Passpoint network. |
| time.sleep(DEFAULT_TIMEOUT) |
| current_passpoint = self.dut.droid.wifiGetConnectionInfo() |
| if current_passpoint[WifiEnums.SSID_KEY] not in osu_config[ |
| "expected_ssids"]: |
| raise signals.TestFailure("Device did not connect to the %s" |
| " passpoint network" % osu_config[ |
| "expected_ssids"]) |
| # Delete the Passpoint profile. |
| self.get_configured_passpoint_and_delete() |
| wutils.wait_for_disconnect(self.dut) |
| |
| |
| """Tests""" |
| |
| @test_tracker_info(uuid="b0bc0153-77bb-4594-8f19-cea2c6bd2f43") |
| def test_add_passpoint_network(self): |
| """Add a Passpoint network and verify device connects to it. |
| |
| Steps: |
| 1. Install a Passpoint Profile. |
| 2. Verify the device connects to the required Passpoint SSID. |
| 3. Get the Passpoint configuration added above. |
| 4. Delete Passpoint configuration using its FQDN. |
| 5. Verify that we are disconnected from the Passpoint network. |
| |
| """ |
| passpoint_config = self.passpoint_networks[BOINGO] |
| self.install_passpoint_profile(passpoint_config) |
| ssid = passpoint_config[WifiEnums.SSID_KEY] |
| self.check_passpoint_connection(ssid) |
| self.get_configured_passpoint_and_delete() |
| wutils.wait_for_disconnect(self.dut) |
| |
| |
| @test_tracker_info(uuid="eb29d6e2-a755-4c9c-9e4e-63ea2277a64a") |
| def test_update_passpoint_network(self): |
| """Update a previous Passpoint network and verify device still connects |
| to it. |
| |
| 1. Install a Passpoint Profile. |
| 2. Verify the device connects to the required Passpoint SSID. |
| 3. Update the Passpoint Profile. |
| 4. Verify device is still connected to the Passpoint SSID. |
| 5. Get the Passpoint configuration added above. |
| 6. Delete Passpoint configuration using its FQDN. |
| |
| """ |
| passpoint_config = self.passpoint_networks[BOINGO] |
| self.install_passpoint_profile(passpoint_config) |
| ssid = passpoint_config[WifiEnums.SSID_KEY] |
| self.check_passpoint_connection(ssid) |
| |
| # Update passpoint configuration using the original profile because we |
| # do not have real profile with updated credentials to use. |
| self.install_passpoint_profile(passpoint_config) |
| |
| # Wait for a Disconnect event from the supplicant. |
| wutils.wait_for_disconnect(self.dut) |
| |
| # Now check if we are again connected with the updated profile. |
| self.check_passpoint_connection(ssid) |
| |
| self.get_configured_passpoint_and_delete() |
| wutils.wait_for_disconnect(self.dut) |
| |
| |
| @test_tracker_info(uuid="b6e8068d-faa1-49f2-b421-c60defaed5f0") |
| def test_add_delete_list_of_passpoint_network(self): |
| """Add multiple passpoint networks, list them and delete one by one. |
| |
| 1. Install Passpoint Profile A. |
| 2. Install Passpoint Profile B. |
| 3. Get all the Passpoint configurations added above and verify. |
| 6. Ensure all Passpoint configurations can be deleted. |
| |
| """ |
| for passpoint_config in self.passpoint_networks[:2]: |
| self.install_passpoint_profile(passpoint_config) |
| time.sleep(DEFAULT_TIMEOUT) |
| configs = self.dut.droid.getPasspointConfigs() |
| # It is length -1 because ATT profile will be handled separately |
| if not len(configs) or len(configs) != len(self.passpoint_networks[:2]): |
| raise signals.TestFailure("Failed to fetch some or all of the" |
| " configured passpoint networks.") |
| for config in configs: |
| if not wutils.delete_passpoint(self.dut, config): |
| raise signals.TestFailure("Failed to delete Passpoint" |
| " configuration with FQDN = %s" % |
| config) |
| |
| |
| @test_tracker_info(uuid="a53251be-7aaf-41fc-a5f3-63984269d224") |
| def test_delete_unknown_fqdn(self): |
| """Negative test to delete Passpoint profile using an unknown FQDN. |
| |
| 1. Pass an unknown FQDN for removal. |
| 2. Verify that it was not successful. |
| |
| """ |
| if wutils.delete_passpoint(self.dut, self.unknown_fqdn): |
| raise signals.TestFailure("Failed because an unknown FQDN" |
| " was successfully deleted.") |
| |
| |
| @test_tracker_info(uuid="bf03c03a-e649-4e2b-a557-1f791bd98951") |
| def test_passpoint_failover(self): |
| """Add a pair of passpoint networks and test failover when one of the" |
| profiles is removed. |
| |
| 1. Install a Passpoint Profile A and B. |
| 2. Verify device connects to a Passpoint network and get SSID. |
| 3. Delete the current Passpoint profile using its FQDN. |
| 4. Verify device fails over and connects to the other Passpoint SSID. |
| 5. Delete Passpoint configuration using its FQDN. |
| |
| """ |
| # Install both Passpoint profiles on the device. |
| passpoint_ssid = list() |
| for passpoint_config in self.passpoint_networks[:2]: |
| passpoint_ssid.append(passpoint_config[WifiEnums.SSID_KEY]) |
| self.install_passpoint_profile(passpoint_config) |
| time.sleep(DEFAULT_TIMEOUT) |
| |
| # Get the current network and the failover network. |
| wutils.wait_for_connect(self.dut) |
| current_passpoint = self.dut.droid.wifiGetConnectionInfo() |
| current_ssid = current_passpoint[WifiEnums.SSID_KEY] |
| if current_ssid not in passpoint_ssid: |
| raise signals.TestFailure("Device did not connect to any of the " |
| "configured Passpoint networks.") |
| |
| expected_ssid = self.passpoint_networks[0][WifiEnums.SSID_KEY] |
| if current_ssid == expected_ssid: |
| expected_ssid = self.passpoint_networks[1][WifiEnums.SSID_KEY] |
| |
| # Remove the current Passpoint profile. |
| for network in self.passpoint_networks[:2]: |
| if network[WifiEnums.SSID_KEY] == current_ssid: |
| if not wutils.delete_passpoint(self.dut, network["fqdn"]): |
| raise signals.TestFailure("Failed to delete Passpoint" |
| " configuration with FQDN = %s" % |
| network["fqdn"]) |
| # Verify device fails over and connects to the other passpoint network. |
| time.sleep(DEFAULT_TIMEOUT) |
| |
| current_passpoint = self.dut.droid.wifiGetConnectionInfo() |
| if current_passpoint[WifiEnums.SSID_KEY] != expected_ssid: |
| raise signals.TestFailure("Device did not failover to the %s" |
| " passpoint network" % expected_ssid) |
| |
| # Delete the remaining Passpoint profile. |
| self.get_configured_passpoint_and_delete() |
| wutils.wait_for_disconnect(self.dut) |
| |
| |
| def test_install_att_passpoint_profile(self): |
| """Add an AT&T Passpoint profile. |
| |
| It is used for only installing the profile for other tests. |
| """ |
| isFound = False |
| for passpoint_config in self.passpoint_networks: |
| if 'att' in passpoint_config['fqdn']: |
| isFound = True |
| self.install_passpoint_profile(passpoint_config) |
| break |
| if not isFound: |
| raise signals.TestFailure("cannot find ATT profile.") |
| |
| |
| @test_tracker_info(uuid="e3e826d2-7c39-4c37-ab3f-81992d5aa0e8") |
| def test_att_passpoint_network(self): |
| """Add a AT&T Passpoint network and verify device connects to it. |
| |
| Steps: |
| 1. Install a AT&T Passpoint Profile. |
| 2. Verify the device connects to the required Passpoint SSID. |
| 3. Get the Passpoint configuration added above. |
| 4. Delete Passpoint configuration using its FQDN. |
| 5. Verify that we are disconnected from the Passpoint network. |
| |
| """ |
| carriers = ["att"] |
| operator = get_operator_name(self.log, self.dut) |
| asserts.skip_if(operator not in carriers, |
| "Device %s does not have a ATT sim" % self.dut.model) |
| |
| passpoint_config = self.passpoint_networks[ATT] |
| self.install_passpoint_profile(passpoint_config) |
| ssid = passpoint_config[WifiEnums.SSID_KEY] |
| self.check_passpoint_connection(ssid) |
| self.get_configured_passpoint_and_delete() |
| wutils.wait_for_disconnect(self.dut) |
| |
| |
| @test_tracker_info(uuid="c85c81b2-7133-4635-8328-9498169ae802") |
| def test_start_subscription_provisioning(self): |
| self.start_subscription_provisioning(0) |
| |
| |
| @test_tracker_info(uuid="fd09a643-0d4b-45a9-881a-a771f9707ab1") |
| def test_start_subscription_provisioning_and_reset_wifi(self): |
| self.start_subscription_provisioning(RESET) |
| |
| |
| @test_tracker_info(uuid="f43ea759-673f-4567-aa11-da3bc2cabf08") |
| def test_start_subscription_provisioning_and_toggle_wifi(self): |
| self.start_subscription_provisioning(TOGGLE) |