acts_tests/tests/google/fuchsia/wlan_policy/RegulatoryRecoveryTest.py

#!/usr/bin/env python3
#
#   Copyright 2020 - 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

from acts import signals
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest


class RegulatoryRecoveryTest(WifiBaseTest):
    """Tests the policy layer's response to setting country code.

    Test Bed Requirements:
    * One Fuchsia device that is capable of operating as a WLAN client and AP.

    Example Config:
    "regulatory_recovery_test_params": {
        "country_code": "US"
    }

    If no configuration information is provided, the test will default to
    toggling between WW and US.
    """

    def setup_class(self):
        super().setup_class()
        if len(self.fuchsia_devices) < 1:
            raise EnvironmentError("No Fuchsia devices found.")

        self.config_test_params = self.user_params.get(
            "regulatory_recovery_test_params", {})
        self.country_code = self.config_test_params.get("country_code", "US")
        self.negative_test = self.config_test_params.get(
            "negative_test", False)

        for fd in self.fuchsia_devices:
            fd.configure_wlan(association_mechanism='policy')

    def teardown_class(self):
        if not self.negative_test:
            for fd in self.fuchsia_devices:
                fd.wlan_controller.set_country_code(self.country_code)

        super().teardown_class()

    def setup_test(self):
        for fd in self.fuchsia_devices:
            # Remove all network configs.  These tests do not require
            # connecting to a network, they merely verify whether or not client
            # mode is functional.
            if not fd.wlan_policy_controller.remove_all_networks():
                raise EnvironmentError(
                    "Failed to remove all networks in setup")

            # To ensure that DUTs are initially in a known state, set all of
            # their PHYs to world-wide mode.  Also disable client and AP
            # functionality so that there is no automated WLAN behavior.
            fd.wlan_controller.set_country_code("WW")
            fd.wlan_policy_controller.stop_client_connections()
            fd.sl4f.wlan_ap_policy_lib.wlanStopAllAccessPoint()

    def set_country_code(self, fd):
        try:
            fd.wlan_controller.set_country_code(self.country_code)
        except EnvironmentError as e:
            if self.negative_test:
                # In the negative case, setting the country code for an
                # invalid country should fail.
                pass
            else:
                # If this is not a negative test case, re-raise the
                # exception.
                raise e
        else:
            # The negative test case should have failed to set the country
            # code and the positive test case should succeed.
            if self.negative_test:
                raise EnvironmentError(
                    "Setting invalid country code succeeded.")
            else:
                pass

    def test_interfaces_not_recreated_when_initially_disabled(self):
        """This test ensures that after a new regulatory region is applied
        while client connections and access points are disabled, no new
        interfaces are automatically recreated.
        """
        for fd in self.fuchsia_devices:
            # Set the region code.
            self.set_country_code(fd)

            # Reset the listeners and verify the current state.
            fd.sl4f.wlan_policy_lib.wlanSetNewListener()
            fd.sl4f.wlan_ap_policy_lib.wlanSetNewListener()

            # Verify that the client and AP are still stopped.
            client_state = fd.sl4f.wlan_policy_lib.wlanGetUpdate()
            if client_state["error"]:
                raise signals.TestFailure(
                    "error querying client state: {}".format(
                        client_state["error"]))
            elif client_state["result"]["state"] != "ConnectionsDisabled":
                raise signals.TestFailure(
                    "client connections in unexpected state: {}".format(
                        client_state["result"]["state"]))

            ap_state = fd.sl4f.wlan_ap_policy_lib.wlanGetUpdate()
            if ap_state["error"]:
                raise signals.TestFailure("error querying AP state: {}".format(
                    ap_state["error"]))

            ap_updates = ap_state["result"]
            if ap_updates:
                raise signals.TestFailure(
                    "AP in unexpected state: {}".format(ap_updates))

    def test_interfaces_recreated_when_initially_enabled(self):
        """This test ensures that after a new regulatory region is applied
        while client connections and access points are enabled, all
        interfaces are recreated.
        """
        test_ssid = "test_ssid"
        test_security_type = "none"
        for fd in self.fuchsia_devices:
            # Start client connections and start an AP before setting the
            # country code.
            fd.wlan_policy_controller.start_client_connections()
            fd.sl4f.wlan_ap_policy_lib.wlanStartAccessPoint(
                test_ssid, test_security_type, "", "local_only", "any")

            # Set the country code.
            self.set_country_code(fd)

            # Reset the listeners and verify the current state.
            fd.sl4f.wlan_policy_lib.wlanSetNewListener()
            fd.sl4f.wlan_ap_policy_lib.wlanSetNewListener()

            # Verify that client connections are enabled and the AP is brought
            # up again.
            client_state = fd.sl4f.wlan_policy_lib.wlanGetUpdate()
            if client_state["error"]:
                raise signals.TestFailure(
                    "error querying client state: {}".format(
                        client_state["error"]))
            elif client_state["result"]["state"] != "ConnectionsEnabled":
                raise signals.TestFailure(
                    "client connections in unexpected state: {}".format(
                        client_state["result"]["state"]))

            ap_state = fd.sl4f.wlan_ap_policy_lib.wlanGetUpdate()
            if ap_state["error"]:
                raise signals.TestFailure("error querying AP state: {}".format(
                    ap_state["error"]))

            ap_updates = ap_state["result"]
            if len(ap_updates) != 1:
                raise signals.TestFailure(
                    "No APs are running: {}".format(ap_updates))
            else:
                if ap_updates[0]["id"]["ssid"] != test_ssid or ap_updates[0][
                        "id"]["type_"].lower() != test_security_type:
                    raise signals.TestFailure(
                        "AP in unexpected state: {}".format(ap_updates[0]))