google/wifi/WifiPasspointTest.py

#!/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 time

from acts_contrib.test_utils.net import ui_utils as uutils
import acts_contrib.test_utils.wifi.wifi_test_utils as wutils
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest

import WifiManagerTest
from acts import asserts
from acts import signals
from acts.test_decorators import test_tracker_info
from acts_contrib.test_utils.tel.tel_test_utils import get_operator_name
from acts.utils import force_airplane_mode

WifiEnums = wutils.WifiEnums

DEFAULT_TIMEOUT = 15
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"

# Constants for Boingo UI automator
EDIT_TEXT_CLASS_NAME = "android.widget.EditText"
PASSWORD_TEXT = "Password"
PASSPOINT_BUTTON = "Get Passpoint"
BOINGO_UI_TEXT = "Online Sign Up"


class WifiPasspointTest(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 setup_class(self):
        super().setup_class()
        self.dut = self.android_devices[0]
        wutils.wifi_test_device_init(self.dut)
        req_params = [
            "passpoint_networks",
            "boingo_username",
            "boingo_password",
        ]
        self.unpack_userparams(req_param_names=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

    def setup_test(self):
        super().setup_test()
        self.dut.droid.wakeLockAcquireBright()
        self.dut.droid.wakeUpNow()
        self.dut.unlock_screen()
        self.dut.adb.shell("input keyevent KEYCODE_HOME")

    def teardown_test(self):
        super().teardown_test()
        self.dut.droid.wakeLockRelease()
        self.dut.droid.goToSleepNow()
        passpoint_configs = self.dut.droid.getPasspointConfigs()
        for config in passpoint_configs:
            wutils.delete_passpoint(self.dut, config)
        wutils.reset_wifi(self.dut)

    """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()
        try:
            wutils.start_wifi_connection_scan_and_return_status(ad)
            wutils.wait_for_connect(ad)
        except:
            pass
        # Re-verify we are connected to the correct network.
        network_info = self.dut.droid.wifiGetConnectionInfo()
        self.log.info("Network Info: %s" % network_info)
        if not network_info or not network_info[WifiEnums.SSID_KEY] or \
            network_info[WifiEnums.SSID_KEY] not in passpoint_network:
            raise signals.TestFailure(
                "Device did not connect to 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 ui_automator_boingo(self):
        """Run UI automator for boingo passpoint."""
        # Verify the boingo login page shows
        asserts.assert_true(uutils.has_element(self.dut, text=BOINGO_UI_TEXT),
                            "Failed to launch boingohotspot login page")

        # Go to the bottom of the page
        for _ in range(3):
            self.dut.adb.shell("input swipe 300 900 300 300")

        # Enter username & password
        screen_dump = uutils.get_screen_dump_xml(self.dut)
        nodes = screen_dump.getElementsByTagName("node")
        index = 0
        for node in nodes:
            if uutils.match_node(node, class_name="android.widget.EditText"):
                x, y = eval(node.attributes["bounds"].value.split("][")[0][1:])
                self.dut.adb.shell("input tap %s %s" % (x, y))
                if index == 0:
                    self.dut.adb.shell("input text %s" % self.boingo_username)
                    index += 1
                else:
                    self.dut.adb.shell("input text %s" % self.boingo_password)
                    break
                self.dut.adb.shell("input keyevent 111")
        self.dut.adb.shell("input keyevent 111")  # collapse keyboard
        self.dut.adb.shell(
            "input swipe 300 900 300 750")  # swipe up to show text

        # Login
        uutils.wait_and_click(self.dut, text=PASSPOINT_BUTTON)
        time.sleep(DEFAULT_TIMEOUT)

    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:
                    time.sleep(DEFAULT_TIMEOUT)
                    self.ui_automator_boingo()
        # 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, timeout=15)

    def start_subscription_provisioning_OSU_websie(self):
        """Start subscription provisioning with a default websider."""

        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 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:
                    time.sleep(DEFAULT_TIMEOUT)
                    asserts.assert_true(
                        uutils.has_element(self.dut, text=BOINGO_UI_TEXT),
                        "Failed to launch boingohotspot login page")
                    break
        # Clear all previous events.
        self.dut.ed.clear_all_events()

    """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="ac71344f-e5d9-4e70-b15d-8ce24a4b3744")
    def test_global_reach_passpoint(self):
        """Test connection to global reach passpoint.

        Steps:
          1. Install global reach passpoint profile.
          2. Verify connection to the global reach wifi network.
          3. Delete passpoint and verify device disconnects.
        """
        passpoint_config = self.passpoint_networks[GLOBAL_RE]
        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="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.extend(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."
                                      "current: {}, expected: {}".format(
                                          current_ssid, passpoint_ssid))

        expected_ssid = self.passpoint_networks[0][WifiEnums.SSID_KEY]
        if current_ssid in expected_ssid:
            expected_ssid = self.passpoint_networks[1][WifiEnums.SSID_KEY]

        # Remove the current Passpoint profile.
        for network in self.passpoint_networks[:2]:
            if current_ssid in network[WifiEnums.SSID_KEY]:
                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] not in 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)

    @test_tracker_info(uuid="37ae0223-0cb7-43f3-8ba8-474fad6e4b71")
    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)
        if operator not in carriers:
            self.log.warn("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)

    @test_tracker_info(uuid="ad6d5eb8-a3c5-4ce0-9e10-d0f201cd0f40")
    def test_user_override_auto_join_on_passpoint_network(self):
        """Add a Passpoint network, simulate user change the auto join to false, ensure the device
        doesn't auto connect to this passponit network

        Steps:
            1. Install a Passpoint Profile.
            2. Verify the device connects to the required Passpoint SSID.
            3. Disable auto join Passpoint configuration using its FQDN.
            4. disable and enable Wifi toggle, ensure we don't connect back
        """
        passpoint_config = self.passpoint_networks[BOINGO]
        self.install_passpoint_profile(passpoint_config)
        ssid = passpoint_config[WifiEnums.SSID_KEY]
        self.check_passpoint_connection(ssid)
        self.dut.log.info("Disable auto join on passpoint")
        self.dut.droid.wifiEnableAutojoinPasspoint(passpoint_config['fqdn'],
                                                   False)
        wutils.wifi_toggle_state(self.dut, False)
        wutils.wifi_toggle_state(self.dut, True)
        asserts.assert_false(
            wutils.wait_for_connect(self.dut, ssid, assert_on_fail=False),
            "Device should not connect.")

    @test_tracker_info(uuid="03624cd2-96e2-4fda-abfc-517c6daa7cf5")
    def test_passpoint_release_2_OSU_page_swipe_away(self):
        """Before adding a Passpoint network, using recent task  to swip the task
        Steps:
            1. Go to Wi-Fi page
            2. Tap Boingo and tap to sign up
            3. After Online Sign Up (OSU) page show up, open recent task screen
            4. Swipe away OSU page
        Verification:
            Disconnect from Boingo network
        """
        self.start_subscription_provisioning_OSU_websie()
        #launch recent task and kill the osu task
        self.dut.adb.shell("input keyevent KEYCODE_APP_SWITCHER")
        self.dut.adb.shell("input keyevent 20")
        self.dut.adb.shell("input keyevent DEL")
        self.dut.adb.shell("input keyevent KEYCODE_HOME")

        # Clear all previous events.
        self.dut.ed.clear_all_events()
        current_passpoint = self.dut.droid.wifiGetConnectionInfo()
        asserts.assert_false(
            current_passpoint[WifiEnums.SSID_KEY] in
            osu_config["expected_ssids"], "Device should not connect")

        # Verify device does not connects to the Passpoint network.
        asserts.assert_true(
            self.dut.droid.wifiGetConnectionStandard() !=
            wifi_constants.WIFI_CONNECTED, "DUT did not connect to passpoint.")

    @test_tracker_info(uuid="4655ee21-15d3-4742-9638-f07752127ce7")
    def test_passpoint_release_2_connectivity_connection_failure(self):
        """Before adding a Passpoint network, before sig in to use back key to leave the task
        Steps:
            1. Go to Wi-Fi page
            2. Tap Boingo and tap to sign up
            3. Tap back button when device pop up Online Sign Up (OSU)

        Verification:
            Disconnect from Boingo network
        """
        self.start_subscription_provisioning_OSU_websie()
        #launch back key
        self.dut.adb.shell("input keyevent KEYCODE_BACK")
        # Clear all previous events.
        self.dut.ed.clear_all_events()
        # Verify device does not connects to the Passpoint network.
        asserts.assert_true(
            self.dut.droid.wifiGetConnectionStandard() !=
            wifi_constants.WIFI_CONNECTED, "DUT did not connect to passpoint.")

    @test_tracker_info(uuid="3372c605-2934-4739-8413-d9a103e87eef")
    def test_passpoint_release_2_subscription_detail_of_current_connected_network(
            self):
        """Add a Passpoint network and check the connection detail
        Steps:
            1. Connecting a passpoint wifi
            2. Go to Settings> Network & Internet> Wi-Fi
            3. Tap current connected Wi-Fi and check the detail
        Verification:
            1.There is a forget button shown on the UI.
            2.The dut shows Frequency, Security and Advanced (Metered, Privacy, Network detail, etc.
        """
        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")
                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:
                    time.sleep(DEFAULT_TIMEOUT)
                    self.ui_automator_boingo()

        # 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"])
        self.dut.adb.shell("am start-activity -a\
            android.settings.NETWORK_PROVIDER_SETTINGS")

        # Open the Network details pasge and check UI
        uutils.wait_and_click(self.dut,resource_id=\
            "com.android.settings:id/settings_button_no_background")
        time.sleep(DEFAULT_TIMEOUT)

        # Verify Network Details
        asserts.assert_true(
            uutils.has_element(self.dut, content_desc="Network details"),
            "Failed to launch Network details")
        asserts.assert_true(
            uutils.has_element(self.dut, text_contains="Connected / Metered"),
            "failed to find the Connected text")
        asserts.assert_true(
            uutils.has_element(self.dut, text_contains="Passpoint"),
            "failed to find the Passpoint secuty type")
        asserts.assert_true(
            uutils.has_element(self.dut, text_contains="Forget"),
            "failed to find the Forget button")
        asserts.assert_true(
            uutils.has_element(self.dut, text_contains="5 GHz"),
            "failed to find the Frequency text")

        # Delete the Passpoint profile.
        self.get_configured_passpoint_and_delete()
        wutils.wait_for_disconnect(self.dut, timeout=15)