Tests and improvements

Author: CoMPaTech

.github/workflows/verify.yml

@@ -151,7 +151,7 @@ jobs:
         run: |
           . venv/bin/activate
           coverage combine coverage*/.coverage*
-          coverage report --fail-under=50
+          coverage report --fail-under=85
           coverage xml
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v5

airos/discovery.py

@@ -60,9 +60,12 @@ def datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
             if parsed_data:
                 # Schedule the user-provided callback, don't await to keep listener responsive
                 asyncio.create_task(self.callback(parsed_data))  # noqa: RUF006
-        except (AirosEndpointError, AirosListenerError):
-            # Re-raise discovery-specific errors as-is
-            raise
+        except (AirosEndpointError, AirosListenerError) as err:
+            # These are expected types of malformed packets. Log the specific error
+            # and then re-raise as AirosDiscoveryError.
+            log = f"Parsing failed for packet from {host_ip}: {err}"
+            _LOGGER.exception(log)
+            raise AirosDiscoveryError(f"Malformed packet from {host_ip}") from err
         except Exception as err:
             # General error during datagram reception (e.g., in callback itself)
             log = f"Error processing Airos discovery packet from {host_ip}. Data hex: {data.hex()}"
@@ -114,12 +117,12 @@ def parse_airos_packet(self, data: bytes, host_ip: str) -> dict[str, Any] | None
         if len(data) < 6:
             log = f"Packet too short for initial fixed header. Length: {len(data)}. Data: {data.hex()}"
             _LOGGER.debug(log)
-            return None
+            raise AirosEndpointError(f"Malformed packet: {log}")
 
         if data[0] != 0x01 or data[1] != 0x06:
             log = f"Packet does not start with expected Airos header (0x01 0x06). Actual: {data[0:2].hex()}"
             _LOGGER.debug(log)
-            return None
+            raise AirosEndpointError(f"Malformed packet: {log}")
 
         offset: int = 6
 
@@ -147,7 +150,8 @@ def parse_airos_packet(self, data: bytes, host_ip: str) -> dict[str, Any] | None
                     else:
                         log = f"Truncated MAC address TLV (Type 0x06). Expected {expected_length}, got {len(data) - offset} bytes. Remaining: {data[offset:].hex()}"
                         _LOGGER.warning(log)
-                        break
+                        log = f"Malformed packet: {log}"
+                        raise AirosEndpointError(log)
 
                 elif tlv_type in [
                     0x02,
@@ -164,7 +168,8 @@ def parse_airos_packet(self, data: bytes, host_ip: str) -> dict[str, Any] | None
                     if (len(data) - offset) < 2:
                         log = f"Truncated TLV (Type {tlv_type:#x}), no 2-byte length field. Remaining: {data[offset:].hex()}"
                         _LOGGER.warning(log)
-                        break
+                        log = f"Malformed packet: {log}"
+                        raise AirosEndpointError(log)
 
                     tlv_length: int = struct.unpack_from(">H", data, offset)[0]
                     offset += 2
@@ -176,7 +181,8 @@ def parse_airos_packet(self, data: bytes, host_ip: str) -> dict[str, Any] | None
                         _LOGGER.warning(log)
                         log = f"Data from TLV start: {data[offset - 3 :].hex()}"
                         _LOGGER.warning(log)
-                        break
+                        log = f"Malformed packet: {log}"
+                        raise AirosEndpointError(log)
 
                     tlv_value: bytes = data[offset : offset + tlv_length]
 
@@ -250,15 +256,18 @@ def parse_airos_packet(self, data: bytes, host_ip: str) -> dict[str, Any] | None
 
                 else:
                     log = f"Unhandled TLV type: {tlv_type:#x} at offset {offset - 1}. "
+                    log += f"Cannot determine length, stopping parsing. Remaining: {data[offset - 1 :].hex()}"
                     _LOGGER.warning(log)
-                    log = f"Cannot determine length, stopping parsing. Remaining: {data[offset - 1 :].hex()}"
-                    _LOGGER.warning(log)
-                    break
+                    log = f"Malformed packet: {log}"
+                    raise AirosEndpointError(log)
 
         except (struct.error, IndexError) as err:
             log = f"Parsing error (struct/index) in AirosDiscoveryProtocol: {err} at offset {offset}. Remaining data: {data[offset:].hex()}"
-            _LOGGER.warning(log)
-            raise AirosEndpointError from err
+            _LOGGER.debug(log)
+            log = f"Malformed packet: {log}"
+            raise AirosEndpointError(log) from err
+        except AirosEndpointError:  # Catch AirosEndpointError specifically, re-raise it
+            raise
         except Exception as err:
             _LOGGER.exception("Unexpected error during Airos packet parsing")
             raise AirosListenerError from err

fixtures/airos_sta_discovery_packet.bin

@@ -0,0 +1,103 @@
+"""Generate mock discovery packet for testing."""
+
+import logging
+import os
+import socket
+import struct
+
+_LOGGER = logging.getLogger(__name__)
+
+# Define the path to save the fixture
+fixture_dir = os.path.join(os.path.dirname(__file__), "../fixtures")
+os.makedirs(fixture_dir, exist_ok=True)  # Ensure the directory exists
+fixture_path = os.path.join(fixture_dir, "airos_sta_discovery_packet.bin")
+
+# Header: 0x01 0x06 (2 bytes) + 4 reserved bytes = 6 bytes
+HEADER = b"\x01\x06\x00\x00\x00\x00"
+
+# --- Scrubbed Values ---
+SCRUBBED_MAC = "01:23:45:67:89:CD"
+SCRUBBED_MAC_BYTES = bytes.fromhex(SCRUBBED_MAC.replace(":", ""))
+SCRUBBED_IP = "192.168.1.3"
+SCRUBBED_IP_BYTES = socket.inet_aton(SCRUBBED_IP)
+SCRUBBED_HOSTNAME = "name"
+SCRUBBED_HOSTNAME_BYTES = SCRUBBED_HOSTNAME.encode("utf-8")
+
+# --- Values from provided "schuur" JSON (not scrubbed) ---
+FIRMWARE_VERSION = "WA.V8.7.17"
+FIRMWARE_VERSION_BYTES = FIRMWARE_VERSION.encode("ascii")
+UPTIME_SECONDS = 265375
+MODEL = "NanoStation 5AC loco"
+MODEL_BYTES = MODEL.encode("ascii")
+SSID = "DemoSSID"
+SSID_BYTES = SSID.encode("utf-8")
+FULL_MODEL_NAME = (
+    "NanoStation 5AC loco"  # Using the same as Model, as is often the case
+)
+FULL_MODEL_NAME_BYTES = FULL_MODEL_NAME.encode("utf-8")
+
+# TLV Type 0x06: MAC Address (fixed 6-byte value)
+TLV_MAC_TYPE = b"\x06"
+TLV_MAC = TLV_MAC_TYPE + SCRUBBED_MAC_BYTES
+
+# TLV Type 0x02: MAC + IP Address (10 bytes value, with 2-byte length field)
+# Value contains first 6 bytes often MAC, last 4 bytes IP
+TLV_IP_TYPE = b"\x02"
+TLV_IP_VALUE = (
+    SCRUBBED_MAC_BYTES + SCRUBBED_IP_BYTES
+)  # 6 bytes MAC + 4 bytes IP = 10 bytes
+TLV_IP_LENGTH = len(TLV_IP_VALUE).to_bytes(2, "big")
+TLV_IP = TLV_IP_TYPE + TLV_IP_LENGTH + TLV_IP_VALUE
+
+# TLV Type 0x03: Firmware Version (variable length string)
+TLV_FW_TYPE = b"\x03"
+TLV_FW_LENGTH = len(FIRMWARE_VERSION_BYTES).to_bytes(2, "big")
+TLV_FW = TLV_FW_TYPE + TLV_FW_LENGTH + FIRMWARE_VERSION_BYTES
+
+# TLV Type 0x0A: Uptime (4-byte integer)
+TLV_UPTIME_TYPE = b"\x0a"
+TLV_UPTIME_VALUE = struct.pack(">I", UPTIME_SECONDS)  # Unsigned int, big-endian
+TLV_UPTIME_LENGTH = len(TLV_UPTIME_VALUE).to_bytes(2, "big")
+TLV_UPTIME = TLV_UPTIME_TYPE + TLV_UPTIME_LENGTH + TLV_UPTIME_VALUE
+
+# TLV Type 0x0B: Hostname (variable length string)
+TLV_HOSTNAME_TYPE = b"\x0b"
+TLV_HOSTNAME_LENGTH = len(SCRUBBED_HOSTNAME_BYTES).to_bytes(2, "big")
+TLV_HOSTNAME = TLV_HOSTNAME_TYPE + TLV_HOSTNAME_LENGTH + SCRUBBED_HOSTNAME_BYTES
+
+# TLV Type 0x0C: Model (variable length string)
+TLV_MODEL_TYPE = b"\x0c"
+TLV_MODEL_LENGTH = len(MODEL_BYTES).to_bytes(2, "big")
+TLV_MODEL = TLV_MODEL_TYPE + TLV_MODEL_LENGTH + MODEL_BYTES
+
+# TLV Type 0x0D: SSID (variable length string)
+TLV_SSID_TYPE = b"\x0d"
+TLV_SSID_LENGTH = len(SSID_BYTES).to_bytes(2, "big")
+TLV_SSID = TLV_SSID_TYPE + TLV_SSID_LENGTH + SSID_BYTES
+
+# TLV Type 0x14: Full Model Name (variable length string)
+TLV_FULL_MODEL_TYPE = b"\x14"
+TLV_FULL_MODEL_LENGTH = len(FULL_MODEL_NAME_BYTES).to_bytes(2, "big")
+TLV_FULL_MODEL = TLV_FULL_MODEL_TYPE + TLV_FULL_MODEL_LENGTH + FULL_MODEL_NAME_BYTES
+
+# Combine all parts
+FULL_PACKET = (
+    HEADER
+    + TLV_MAC
+    + TLV_IP
+    + TLV_FW
+    + TLV_UPTIME
+    + TLV_HOSTNAME
+    + TLV_MODEL
+    + TLV_SSID
+    + TLV_FULL_MODEL
+)
+
+# Write the actual binary file
+with open(fixture_path, "wb") as f:
+    f.write(FULL_PACKET)
+
+log = f"Generated discovery packet fixture at: {fixture_path}"
+log += f"Packet length: {len(FULL_PACKET)} bytes"
+log += f"Packet hex: {FULL_PACKET.hex()}"
+_LOGGER.info(log)