diff --git a/tests/wlan_policy/PolicyScanTest.py b/tests/wlan_policy/PolicyScanTest.py
index 8739c33..969054f 100644
--- a/tests/wlan_policy/PolicyScanTest.py
+++ b/tests/wlan_policy/PolicyScanTest.py
@@ -18,8 +18,10 @@
 
 import logging
 from datetime import datetime
+from typing import Any, List
 
-from mobly import signals, test_runner
+from mobly import asserts, signals, test_runner
+from typing_extensions import TypeGuard
 
 from antlion.controllers.ap_lib import (
     hostapd_ap_preset,
@@ -27,9 +29,14 @@
     hostapd_constants,
     hostapd_security,
 )
+from antlion.controllers.fuchsia_device import FuchsiaDevice
 from antlion.test_utils.wifi import base_test
 
 
+def is_str_list(val: Any) -> TypeGuard[List[str]]:
+    return isinstance(val, list) and all(isinstance(x, str) for x in val)
+
+
 class PolicyScanTest(base_test.WifiBaseTest):
     """WLAN policy scan test class.
 
@@ -38,7 +45,7 @@
     * One Whirlwind Access Point
     """
 
-    def setup_class(self):
+    def setup_class(self) -> None:
         super().setup_class()
         self.log = logging.getLogger()
 
@@ -54,8 +61,8 @@
         self.access_point = self.access_points[0]
         self.access_point.stop_all_aps()
         # Generate network params.
-        bss_settings_2g = []
-        bss_settings_5g = []
+        bss_settings_2g: List[hostapd_bss_settings.BssSettings] = []
+        bss_settings_5g: List[hostapd_bss_settings.BssSettings] = []
         open_network = self.get_open_network(False, [])
         self.open_network_2g = open_network["2g"]
         self.open_network_5g = open_network["5g"]
@@ -107,15 +114,16 @@
             self.wpa2_network_5g["SSID"],
         ]
 
-    def setup_test(self):
+    def setup_test(self) -> None:
         super().setup_test()
         for fd in self.fuchsia_devices:
             # stub for setting up all the fuchsia devices in the testbed.
-            return (
-                fd.wlan_policy_controller.remove_all_networks_and_wait_for_no_connections()
+            asserts.assert_true(
+                fd.wlan_policy_controller.remove_all_networks_and_wait_for_no_connections(),
+                f"Failed to remove all networks on {fd.mdns_name}",
             )
 
-    def teardown_test(self):
+    def teardown_test(self) -> None:
         for fd in self.fuchsia_devices:
             # stub until policy layer has something useful to use here.
             pass
@@ -123,7 +131,7 @@
 
     """Helper Functions"""
 
-    def perform_scan(self, fd):
+    def perform_scan(self, fd: FuchsiaDevice) -> List[str]:
         """Initiates scan on a Fuchsia device and returns results
 
         Args:
@@ -150,6 +158,12 @@
         # the scan command did not get an error response - go ahead
         # and check for scan results
         scan_results = scan_response["result"]
+        if not is_str_list(scan_results):
+            raise TypeError(
+                "Expected wlan_policy.scan_networks to return a list of strings, "
+                f"got {type(scan_results)}"
+            )
+
         total_time_ms = (datetime.now() - start_time).total_seconds() * 1000
 
         self.log.info("scan contained %d results", len(scan_results))
@@ -157,7 +171,7 @@
 
         return scan_results
 
-    def connect_to_network(self, wlan_network_params, fd):
+    def connect_to_network(self, network: base_test.Network, fd: FuchsiaDevice) -> None:
         """Connects the Fuchsia device to the specified network
 
         Args:
@@ -167,19 +181,17 @@
         Raises:
             signals.TestFailure: if the device fails to connect
         """
-        target_ssid = wlan_network_params["SSID"]
-        target_pwd = wlan_network_params.get("password")
-        target_security = wlan_network_params.get("security")
-
         # TODO(mnck): use the Policy version of this call, when it is available.
         connection_response = fd.wlan_policy_controller.save_and_connect(
-            target_ssid, target_security, password=target_pwd
+            network["SSID"],
+            network["security"].fuchsia_security_type(),
+            network["password"],
         )
         if not connection_response:
             raise signals.TestFailure("Aborting test - Connect call failed")
         self.log.info("Network connection successful.")
 
-    def assert_network_is_in_results(self, scan_results, *, ssid):
+    def assert_network_is_in_results(self, scan_results: List[str], ssid: str) -> None:
         """Verified scan results contain a specified network
 
         Args:
@@ -190,53 +202,53 @@
             signals.TestFailure: if the network is not present in the scan
             results
         """
-        if ssid not in scan_results:
-            raise signals.TestFailure(
-                f'Network "{ssid}" was not found in scan results: {scan_results}'
-            )
+        asserts.assert_true(
+            ssid in scan_results,
+            f'Network "{ssid}" was not found in scan results: {scan_results}',
+        )
 
     """Tests"""
 
-    def test_basic_scan_request(self):
+    def test_basic_scan_request(self) -> None:
         """Verify a scan returns all expected networks"""
         for fd in self.fuchsia_devices:
             scan_results = self.perform_scan(fd)
             if len(scan_results) == 0:
                 raise signals.TestFailure("Scan failed or did not " "find any networks")
             for ssid in self.all_ssids:
-                self.assert_network_is_in_results(scan_results, ssid=ssid)
+                self.assert_network_is_in_results(scan_results, ssid)
 
-    def test_scan_while_connected_open_network_2g(self):
+    def test_scan_while_connected_open_network_2g(self) -> None:
         """Connect to an open 2g network and perform a scan"""
         for fd in self.fuchsia_devices:
             self.connect_to_network(self.open_network_2g, fd)
             scan_results = self.perform_scan(fd)
             for ssid in self.all_ssids:
-                self.assert_network_is_in_results(scan_results, ssid=ssid)
+                self.assert_network_is_in_results(scan_results, ssid)
 
-    def test_scan_while_connected_wpa2_network_2g(self):
+    def test_scan_while_connected_wpa2_network_2g(self) -> None:
         """Connect to a WPA2 2g network and perform a scan"""
         for fd in self.fuchsia_devices:
             self.connect_to_network(self.wpa2_network_2g, fd)
             scan_results = self.perform_scan(fd)
             for ssid in self.all_ssids:
-                self.assert_network_is_in_results(scan_results, ssid=ssid)
+                self.assert_network_is_in_results(scan_results, ssid)
 
-    def test_scan_while_connected_open_network_5g(self):
+    def test_scan_while_connected_open_network_5g(self) -> None:
         """Connect to an open 5g network and perform a scan"""
         for fd in self.fuchsia_devices:
             self.connect_to_network(self.open_network_5g, fd)
             scan_results = self.perform_scan(fd)
             for ssid in self.all_ssids:
-                self.assert_network_is_in_results(scan_results, ssid=ssid)
+                self.assert_network_is_in_results(scan_results, ssid)
 
-    def test_scan_while_connected_wpa2_network_5g(self):
+    def test_scan_while_connected_wpa2_network_5g(self) -> None:
         """Connect to a WPA2 5g network and perform a scan"""
         for fd in self.fuchsia_devices:
             self.connect_to_network(self.wpa2_network_5g, fd)
             scan_results = self.perform_scan(fd)
             for ssid in self.all_ssids:
-                self.assert_network_is_in_results(scan_results, ssid=ssid)
+                self.assert_network_is_in_results(scan_results, ssid)
 
 
 if __name__ == "__main__":