acts_tests/tests/google/fuchsia/wlan_policy/HiddenNetworksTest.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.controllers.access_point import setup_ap
from acts.controllers.ap_lib import hostapd_constants
from acts.controllers.ap_lib import hostapd_security
from acts_contrib.test_utils.wifi.WifiBaseTest import WifiBaseTest
from acts.utils import rand_ascii_str
import time

# These tests should have a longer timeout for connecting than normal connect
# tests because the device should probabilistically perform active scans for
# hidden networks. Multiple scans are necessary to verify a very low chance of
# random failure.
TIME_WAIT_FOR_CONNECT = 90
TIME_ATTEMPT_SCANS = 90

CONNECTIONS_ENABLED = "ConnectionsEnabled"
CONNECTIONS_DISABLED = "ConnectionsDisabled"
SECURITY_NONE = "none"
WPA2 = "wpa2"


class HiddenNetworksTest(WifiBaseTest):
    """ Tests that WLAN Policy will detect hidden networks

    Test Bed Requirement:
    * One or more Fuchsia devices
    * One Access Point
    """

    def setup_class(self):
        super().setup_class()
        # Start an AP with a hidden network
        self.hidden_ssid = rand_ascii_str(hostapd_constants.AP_SSID_LENGTH_2G)
        self.access_point = self.access_points[0]
        self.hidden_password = rand_ascii_str(
            hostapd_constants.AP_PASSPHRASE_LENGTH_2G)
        self.hidden_security = WPA2
        security = hostapd_security.Security(
            security_mode=self.hidden_security, password=self.hidden_password)

        self.access_point.stop_all_aps()
        setup_ap(self.access_point,
                 'whirlwind',
                 hostapd_constants.AP_DEFAULT_CHANNEL_5G,
                 self.hidden_ssid,
                 hidden=True,
                 security=security)

        if len(self.fuchsia_devices) < 1:
            raise EnvironmentError("No Fuchsia devices found.")
        for fd in self.fuchsia_devices:
            fd.configure_wlan(association_mechanism='policy',
                              preserve_saved_networks=True)

    def setup_test(self):
        for fd in self.fuchsia_devices:
            if not fd.wlan_policy_controller.remove_all_networks():
                raise EnvironmentError(
                    "Failed to remove all networks in setup")

    def teardown_class(self):
        self.access_point.stop_all_aps()

    def test_scan_hidden_networks(self):
        # Scan a few times and check that we see the hidden networks in the
        # results at least once. Even if hidden networks are scanned
        # probabilistically, we should see it after a few tries.
        for fd in self.fuchsia_devices:
            # A hidden network must be saved to be found in scan results.
            # Stop client connections to not trigger a connect when saving,
            # which would interfere with requested scans.
            fd.wlan_policy_controller.stop_client_connections()
            if not fd.wlan_policy_controller.save_network(
                    self.hidden_ssid,
                    self.hidden_security,
                    password=self.hidden_password):
                raise EnvironmentError("Failed to save network")
            fd.wlan_policy_controller.start_client_connections()
            start_time = time.time()
            num_performed_scans = 0

            while time.time() < start_time + TIME_ATTEMPT_SCANS:
                num_performed_scans = num_performed_scans + 1
                scan_result = fd.wlan_policy_lib.wlanScanForNetworks()
                if scan_result["error"] != None:
                    self.log.warn("Failed to scan for networks with error %s" %
                                  scan_result["error"])
                    continue
                else:
                    scans = scan_result["result"]
                if self.hidden_ssid in scans:
                    self.log.info(
                        "SSID of hidden network seen after %d scans" %
                        num_performed_scans)
                    return
                # Don't overload SL4F with scan requests
                time.sleep(1)

            self.log.error("Failed to see SSID after %d scans" %
                           num_performed_scans)
            raise signals.TestFailure("Failed to see hidden network in scans")

    def test_auto_connect_hidden_on_startup(self):
        """ Test that if we are not connected to anything but have a hidden
            network saved, we will eventually actively scan for it and connect."""
        # Start up AP with an open network with a random SSID

        for fd in self.fuchsia_devices:
            # Test that we will auto connect without anything being triggered by
            # saving a new network.
            fd.wlan_policy_controller.stop_client_connections()

            # Save the network.
            if not fd.wlan_policy_controller.save_network(
                    self.hidden_ssid,
                    self.hidden_security,
                    password=self.hidden_password):
                raise EnvironmentError("Failed to save network")

            # Reboot the device and check that it auto connects.
            fd.reboot()
            if not fd.wlan_policy_controller.wait_for_connect(
                    self.hidden_ssid,
                    self.hidden_security,
                    timeout=TIME_WAIT_FOR_CONNECT):
                raise signals.TestFailure("Failed to connect to network")

    def test_auto_connect_hidden_on_save(self):
        """ Test that if we save a hidden network and are not connected to
            anything, the device will connect to the hidden network that was
            just saved. """
        for fd in self.fuchsia_devices:
            if not fd.wlan_policy_controller.wait_for_no_connections():
                self.log.info(
                    "Failed to get into a disconnected state to start the test"
                )
                raise EnvironmentError("Failed to disconnect all")

            # Save the network and make sure that we see the device auto connect to it.
            if not fd.wlan_policy_controller.save_network(
                    self.hidden_ssid,
                    self.hidden_security,
                    password=self.hidden_password):
                raise EnvironmentError("Failed to save network")

            if not fd.wlan_policy_controller.wait_for_connect(
                    self.hidden_ssid,
                    self.hidden_security,
                    timeout=TIME_WAIT_FOR_CONNECT):
                raise signals.TestFailure("Failed to connect to network")