nac-test-pyats-common 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

nac_test_pyats_common/__init__.py

@@ -29,7 +29,12 @@ __version__ = "1.0.0"
 
 # Public API - Import from subpackages
 from nac_test_pyats_common.aci import APICAuth, APICTestBase
-from nac_test_pyats_common.catc import CatalystCenterAuth, CatalystCenterTestBase
+from nac_test_pyats_common.catc import (
+    CatalystCenterAuth,
+    CatalystCenterDeviceResolver,
+    CatalystCenterSSHTestBase,
+    CatalystCenterTestBase,
+)
 from nac_test_pyats_common.sdwan import (
     SDWANDeviceResolver,
     SDWANManagerAuth,
@@ -49,4 +54,6 @@ __all__ = [
     # Catalyst Center
     "CatalystCenterAuth",
     "CatalystCenterTestBase",
+    "CatalystCenterSSHTestBase",
+    "CatalystCenterDeviceResolver",
 ]

nac_test_pyats_common/catc/__init__.py

@@ -3,15 +3,23 @@
 
 """Catalyst Center adapter module for NAC PyATS testing.
 
-This module provides Catalyst Center-specific authentication and test base class
-implementations for use with the nac-test framework. Catalyst Center (formerly
-DNA Center) is Cisco's enterprise network management platform.
+This module provides Catalyst Center-specific authentication, test base classes, and
+device resolver implementations for use with the nac-test framework. It includes support
+for both Catalyst Center API testing and SSH-based device-to-device (D2D) testing.
 
 Classes:
-    CatalystCenterAuth: Token-based authentication with automatic endpoint detection.
-    CatalystCenterTestBase: Base class for Catalyst Center API tests with tracking.
+    CatalystCenterAuth: Token-based authentication with automatic endpoint
+        detection.
+    CatalystCenterTestBase: Base class for Catalyst Center API tests with
+        tracking.
+    CatalystCenterSSHTestBase: Base class for Catalyst Center SSH/D2D tests
+        with device inventory.
+    CatalystCenterDeviceResolver: Resolves device information from the
+        Catalyst Center data model.
 
 Example:
+    For Catalyst Center API testing:
+
     >>> from nac_test_pyats_common.catc import CatalystCenterTestBase
     >>>
     >>> class VerifyNetworkDevices(CatalystCenterTestBase):
@@ -23,16 +31,26 @@ Example:
     ...             f"/dna/intent/api/v1/network-device/{item}"
     ...         )
     ...         return response.status_code == 200
-    ...
+
+    For SSH/D2D testing:
+
+    >>> from nac_test_pyats_common.catc import CatalystCenterSSHTestBase
+    >>>
+    >>> class VerifyInterfaceStatus(CatalystCenterSSHTestBase):
     ...     @aetest.test
-    ...     def verify_devices(self, steps):
-    ...         self.run_async_verification_test(steps)
+    ...     def verify_interfaces(self, steps, device):
+    ...         # SSH-based verification
+    ...         pass
 """
 
+from .api_test_base import CatalystCenterTestBase
 from .auth import CatalystCenterAuth
-from .test_base import CatalystCenterTestBase
+from .device_resolver import CatalystCenterDeviceResolver
+from .ssh_test_base import CatalystCenterSSHTestBase
 
 __all__ = [
     "CatalystCenterAuth",
     "CatalystCenterTestBase",
+    "CatalystCenterSSHTestBase",
+    "CatalystCenterDeviceResolver",
 ]

nac_test_pyats_common/catc/device_resolver.py

@@ -0,0 +1,164 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (c) 2025 Daniel Schmidt
+
+"""Catalyst Center-specific device resolver for parsing the NAC data model.
+
+This module provides the CatalystCenterDeviceResolver class, which extends
+BaseDeviceResolver to implement Catalyst Center schema navigation for D2D testing.
+"""
+
+import logging
+from typing import Any
+
+from nac_test_pyats_common.common import BaseDeviceResolver
+from nac_test_pyats_common.iosxe.registry import register_iosxe_resolver
+
+logger = logging.getLogger(__name__)
+
+
+@register_iosxe_resolver("CC")
+class CatalystCenterDeviceResolver(BaseDeviceResolver):
+    """Catalyst Center device resolver for D2D testing.
+
+    Navigates the Catalyst Center NAC schema (catalyst_center.inventory.devices[])
+    to extract device information for SSH testing.
+
+    Schema structure:
+        catalyst_center:
+          inventory:
+            devices:
+              - name: P3-BN1
+                fqdn_name: P3-BN1.cisco.eu
+                device_ip: 192.168.38.1
+                pid: C9300-24P
+                state: PROVISION
+                device_role: ACCESS
+                site: Global/MAX_AREA/MAX_BUILDING
+
+    Credentials:
+        Uses IOSXE_USERNAME and IOSXE_PASSWORD environment variables
+        for SSH access to managed IOS-XE devices.
+
+    Example:
+        >>> resolver = CatalystCenterDeviceResolver(data_model)
+        >>> devices = resolver.get_resolved_inventory()
+        >>> for device in devices:
+        ...     print(f"{device['hostname']}: {device['host']}")
+    """
+
+    def get_architecture_name(self) -> str:
+        """Return 'catalyst_center' as the architecture identifier.
+
+        Returns:
+            Architecture name used in logging and error messages.
+        """
+        return "catalyst_center"
+
+    def get_schema_root_key(self) -> str:
+        """Return 'catalyst_center' as the root key in the data model.
+
+        Returns:
+            Root key used when navigating the schema.
+        """
+        return "catalyst_center"
+
+    def navigate_to_devices(self) -> list[dict[str, Any]]:
+        """Navigate Catalyst Center schema: catalyst_center.inventory.devices[].
+
+        Traverses the Catalyst Center data model structure to find all
+        managed devices in the inventory.
+
+        Returns:
+            List of device dictionaries from the inventory.
+        """
+        devices: list[dict[str, Any]] = []
+        cc_data = self.data_model.get("catalyst_center", {})
+        inventory = cc_data.get("inventory", {})
+        devices.extend(inventory.get("devices", []))
+        return devices
+
+    def validate_device_data(self, device_data: dict[str, Any]) -> None:
+        """Validate device state before extraction.
+
+        Skip devices with INIT or PNP states as they are not fully provisioned.
+
+        Args:
+            device_data: Device data dictionary from the data model.
+
+        Raises:
+            ValueError: If the device has an unsupported state (INIT, PNP).
+        """
+        state = device_data.get("state", "").upper()
+        if state in ("INIT", "PNP"):
+            raise ValueError(
+                f"Device has unsupported state '{state}' "
+                "(devices in INIT or PNP state are not fully provisioned)"
+            )
+
+    def extract_hostname(self, device_data: dict[str, Any]) -> str:
+        """Extract hostname from the 'name' field.
+
+        Uses the device name as the hostname for SSH connections.
+
+        Args:
+            device_data: Device data dictionary from the data model.
+
+        Returns:
+            Device hostname string.
+        """
+        name = device_data.get("name")
+        if not name:
+            raise ValueError("Device missing 'name' field")
+        return str(name)
+
+    def extract_host_ip(self, device_data: dict[str, Any]) -> str:
+        """Extract management IP from device_ip field.
+
+        Reads the device_ip field directly from the device data.
+        Handles CIDR notation if present (e.g., "10.1.1.100/32" -> "10.1.1.100").
+
+        Args:
+            device_data: Device data dictionary from the data model.
+
+        Returns:
+            IP address string without CIDR notation (e.g., "192.168.38.1").
+
+        Raises:
+            ValueError: If device_ip field is not found.
+        """
+        device_ip = device_data.get("device_ip")
+        if not device_ip:
+            raise ValueError(
+                "Device missing 'device_ip' field. "
+                "Ensure device_ip is configured in the inventory."
+            )
+
+        ip_value = str(device_ip)
+
+        # Strip CIDR notation if present
+        if "/" in ip_value:
+            ip_value = ip_value.split("/")[0]
+
+        return ip_value
+
+    def extract_os_type(self, device_data: dict[str, Any]) -> str:
+        """Return 'iosxe' as all managed devices are IOS-XE based.
+
+        Args:
+            device_data: Device data dictionary (unused, OS is hardcoded).
+
+        Returns:
+            Always returns 'iosxe'.
+        """
+        return "iosxe"
+
+    def get_credential_env_vars(self) -> tuple[str, str]:
+        """Return IOS-XE credential env vars for managed devices.
+
+        Catalyst Center D2D tests connect to IOS-XE devices,
+        NOT the Catalyst Center controller.
+
+        Returns:
+            Tuple of (username_env_var, password_env_var).
+        """
+        return ("IOSXE_USERNAME", "IOSXE_PASSWORD")

nac_test_pyats_common/catc/ssh_test_base.py

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (c) 2025 Daniel Schmidt
+
+"""Catalyst Center specific base test class for SSH/Direct-to-Device testing.
+
+This module provides the CatalystCenterSSHTestBase class, which extends the generic
+SSHTestBase to add Catalyst Center-specific functionality for device-to-device (D2D)
+testing.
+
+The class delegates device inventory resolution to CatalystCenterDeviceResolver, which
+handles all Catalyst Center schema navigation and credential injection.
+
+Credentials:
+    Catalyst Center D2D tests connect to IOS-XE devices managed by Catalyst Center,
+    NOT the Catalyst Center controller. Set these environment variables:
+    - IOSXE_USERNAME: SSH username for managed devices
+    - IOSXE_PASSWORD: SSH password for managed devices
+"""
+
+import logging
+import os
+from typing import Any
+
+from nac_test.pyats_core.common.ssh_base_test import (
+    SSHTestBase,  # type: ignore[import-untyped]
+)
+
+from .device_resolver import CatalystCenterDeviceResolver
+
+logger = logging.getLogger(__name__)
+
+
+class CatalystCenterSSHTestBase(SSHTestBase):  # type: ignore[misc]
+    """Catalyst Center-specific base test class for SSH/D2D testing.
+
+    This class extends SSHTestBase and implements the contract required by
+    nac-test's SSH execution engine. Device inventory resolution is fully
+    delegated to CatalystCenterDeviceResolver.
+
+    Credentials:
+        Catalyst Center D2D tests require IOSXE_USERNAME and IOSXE_PASSWORD
+        environment variables (NOT CC_* which are for the controller).
+
+    Example:
+        class MyCatalystCenterSSHTest(CatalystCenterSSHTestBase):
+            @aetest.test
+            def verify_device_connectivity(self, steps, device):
+                # SSH-based verification logic here
+                pass
+    """
+
+    # Class-level storage for the last resolver instance
+    # This allows nac-test to access skipped_devices after calling
+    # get_ssh_device_inventory()
+    _last_resolver: "CatalystCenterDeviceResolver | None" = None
+
+    @classmethod
+    def get_ssh_device_inventory(
+        cls, data_model: dict[str, Any]
+    ) -> list[dict[str, Any]]:
+        """Parse the Catalyst Center data model to retrieve the device inventory.
+
+        This method is the entry point called by nac-test's orchestrator.
+        All device inventory resolution is delegated to CatalystCenterDeviceResolver,
+        which handles:
+        - Schema navigation (catalyst_center.inventory.devices[])
+        - Device metadata extraction (name, device_ip, etc.)
+        - Credential injection (IOSXE_USERNAME, IOSXE_PASSWORD)
+
+        After calling this method, access cls._last_resolver.skipped_devices
+        to get information about devices that failed resolution.
+
+        Args:
+            data_model: The merged data model from nac-test containing all
+                configuration data with resolved variables.
+
+        Returns:
+            List of device dictionaries, each containing:
+            - hostname (str): Device hostname
+            - host (str): Management IP address for SSH connection
+            - os (str): Operating system type (e.g., "iosxe")
+            - username (str): SSH username from IOSXE_USERNAME
+            - password (str): SSH password from IOSXE_PASSWORD
+            - device_id (str): Device identifier (name)
+
+        Raises:
+            ValueError: If IOSXE_USERNAME or IOSXE_PASSWORD env vars are not set.
+        """
+        logger.info(
+            "CatalystCenterSSHTestBase: Resolving device inventory via "
+            "CatalystCenterDeviceResolver"
+        )
+
+        cls._last_resolver = CatalystCenterDeviceResolver(data_model)
+        return cls._last_resolver.get_resolved_inventory()
+
+    def get_device_credentials(self, device: dict[str, Any]) -> dict[str, str | None]:
+        """Get Catalyst Center managed device SSH credentials from env vars.
+
+        Catalyst Center D2D tests connect to IOS-XE devices managed by
+        Catalyst Center, NOT the Catalyst Center controller. Use IOSXE_*
+        environment variables.
+
+        Args:
+            device: Device dictionary (not used - all devices share credentials).
+
+        Returns:
+            Dictionary containing:
+            - username (str | None): SSH username from IOSXE_USERNAME
+            - password (str | None): SSH password from IOSXE_PASSWORD
+        """
+        return {
+            "username": os.environ.get("IOSXE_USERNAME"),
+            "password": os.environ.get("IOSXE_PASSWORD"),
+        }

nac_test_pyats_common/common/base_device_resolver.py

@@ -8,14 +8,12 @@ Architecture-specific resolvers extend this class and implement the
 abstract methods for schema navigation and credential retrieval.
 """
 
+import ipaddress
 import logging
 import os
 from abc import ABC, abstractmethod
 from typing import Any
 
-import yaml
-from nac_test.utils.file_discovery import find_data_file
-
 logger = logging.getLogger(__name__)
 
 
@@ -23,29 +21,27 @@ class BaseDeviceResolver(ABC):
     """Abstract base class for architecture-specific device resolvers.
 
     This class implements the Template Method pattern for device inventory
-    resolution. It handles common logic (inventory loading, credential
-    injection, device dict construction) while delegating schema-specific
-    work to abstract methods.
+    resolution. It handles common logic (credential injection, device dict
+    construction) while delegating schema-specific work to abstract methods.
 
     Subclasses MUST implement:
         - get_architecture_name(): Return architecture identifier (e.g., "sdwan")
         - get_schema_root_key(): Return the root key in data model (e.g., "sdwan")
         - navigate_to_devices(): Navigate schema to get iterable of device data
-        - extract_device_id(): Extract unique device identifier from device data
         - extract_hostname(): Extract hostname from device data
         - extract_host_ip(): Extract management IP from device data
         - extract_os_type(): Extract OS type from device data
         - get_credential_env_vars(): Return (username_env_var, password_env_var)
 
     Subclasses MAY override:
-        - get_inventory_filename(): Return inventory filename
-          (default: "test_inventory.yaml")
+        - extract_device_id(): Extract device identifier (default: uses hostname)
         - build_device_dict(): Customize device dict construction
-        - _load_inventory(): Customize inventory loading
+        - validate_device_data(): Pre-extraction validation hook
 
     Attributes:
         data_model: The merged NAC data model dictionary.
-        test_inventory: The test inventory dictionary (devices to test).
+        skipped_devices: List of dicts with device_id and reason for devices
+            that failed resolution. Populated after get_resolved_inventory().
 
     Example:
         >>> class SDWANDeviceResolver(BaseDeviceResolver):
@@ -61,33 +57,24 @@ class BaseDeviceResolver(ABC):
         >>> devices = resolver.get_resolved_inventory()
     """
 
-    def __init__(
-        self,
-        data_model: dict[str, Any],
-        test_inventory: dict[str, Any] | None = None,
-    ) -> None:
+    def __init__(self, data_model: dict[str, Any]) -> None:
         """Initialize the device resolver.
 
         Args:
             data_model: The merged NAC data model containing all architecture
                 data with resolved variables.
-            test_inventory: Optional test inventory specifying which devices
-                to test. If not provided, will attempt to load from file.
         """
         self.data_model = data_model
-        self.test_inventory = test_inventory or self._load_inventory()
-        logger.debug(
-            f"Initialized {self.get_architecture_name()} resolver with "
-            f"{len(self.test_inventory.get('devices', []))} devices in inventory"
-        )
+        self.skipped_devices: list[dict[str, str]] = []
+        logger.debug(f"Initialized {self.get_architecture_name()} resolver")
 
     def get_resolved_inventory(self) -> list[dict[str, Any]]:
         """Get resolved device inventory ready for SSH connection.
 
         This is the main entry point. It:
         1. Navigates the data model to find device data
-        2. Matches devices against test inventory (if provided)
-        3. Extracts hostname, IP, OS from each device
+        2. Extracts hostname and management IP from each device
+        3. Sets OS type (architecture-specific, e.g., hardcoded to 'iosxe' for SD-WAN)
         4. Injects SSH credentials from environment variables
         5. Returns list of device dicts ready for nac-test
 
@@ -106,10 +93,15 @@ class BaseDeviceResolver(ABC):
         logger.info(f"Resolving device inventory for {self.get_architecture_name()}")
 
         resolved_devices: list[dict[str, Any]] = []
-        devices_to_test = self._get_devices_to_test()
+        self.skipped_devices = []  # Reset for each resolution
+        all_devices = list(self.navigate_to_devices())
+        logger.debug(f"Found {len(all_devices)} devices in data model")
 
-        for device_data in devices_to_test:
+        for device_data in all_devices:
             try:
+                # Validate device data before extraction (optional hook)
+                self.validate_device_data(device_data)
+
                 device_dict = self.build_device_dict(device_data)
 
                 # Validate extracted fields
@@ -129,18 +121,53 @@ class BaseDeviceResolver(ABC):
                 )
             except (KeyError, ValueError) as e:
                 device_id = self._safe_extract_device_id(device_data)
-                logger.warning(f"Skipping device {device_id}: {e}")
+                logger.debug(f"Skipping device {device_id}: {e}")
+                self.skipped_devices.append(
+                    {
+                        "device_id": device_id,
+                        "reason": str(e),
+                    }
+                )
                 continue
 
         # Inject credentials (fail fast if missing)
         self._inject_credentials(resolved_devices)
 
+        skipped_msg = (
+            f", skipped {len(self.skipped_devices)}" if self.skipped_devices else ""
+        )
         logger.info(
             f"Resolved {len(resolved_devices)} devices for "
-            f"{self.get_architecture_name()} D2D testing"
+            f"{self.get_architecture_name()} D2D testing{skipped_msg}"
         )
         return resolved_devices
 
+    def validate_device_data(self, _device_data: dict[str, Any]) -> None:  # noqa: B027
+        """Validate device data before extraction (optional hook).
+
+        Override this method to perform architecture-specific validation
+        before device field extraction. This is useful for filtering devices
+        based on state, type, or other criteria.
+
+        The default implementation does nothing - all devices pass validation.
+        Subclasses can override this to implement custom validation logic.
+
+        Args:
+            _device_data: Raw device data from the data model (unused in base class).
+
+        Raises:
+            ValueError: If the device should be skipped. The error message
+                will be logged and included in skipped_devices tracking.
+
+        Example (Catalyst Center - skip devices in INIT/PNP states):
+            >>> def validate_device_data(self, device_data):
+            ...     state = device_data.get("state", "").upper()
+            ...     if state in ("INIT", "PNP"):
+            ...         raise ValueError(f"Device has unsupported state '{state}'")
+        """
+        # Default implementation does nothing - subclasses can override
+        pass
+
     def build_device_dict(self, device_data: dict[str, Any]) -> dict[str, Any]:
         """Build a device dictionary from raw device data.
 
@@ -151,8 +178,7 @@ class BaseDeviceResolver(ABC):
             device_data: Raw device data from the data model.
 
         Returns:
-            Device dictionary with hostname, host, os, device_id fields,
-            plus any test-relevant fields like connection_options.
+            Device dictionary with hostname, host, os, device_id fields.
             Credentials are injected separately.
 
         Raises:
@@ -168,150 +194,31 @@ class BaseDeviceResolver(ABC):
             raise ValueError(f"Invalid hostname: {hostname!r}")
         if not isinstance(host, str) or not host:
             raise ValueError(f"Invalid host IP: {host!r}")
+
+        # Validate IP address format (after CIDR stripping done by subclass)
+        try:
+            ipaddress.ip_address(host)
+        except ValueError:
+            raise ValueError(
+                f"Invalid IP address format: '{host}'. "
+                "Ensure the field contains a valid IPv4 or IPv6 address."
+            ) from None
         if not isinstance(os_type, str) or not os_type:
             raise ValueError(f"Invalid OS type: {os_type!r}")
         if not isinstance(device_id, str) or not device_id:
             raise ValueError(f"Invalid device ID: {device_id!r}")
 
-        # Start with required fields
-        result = {
+        return {
             "hostname": hostname,
             "host": host,
             "os": os_type,
             "device_id": device_id,
         }
 
-        # Preserve connection_options from test_inventory if present
-        # This allows specifying custom SSH ports, protocols, etc.
-        if "connection_options" in device_data:
-            result["connection_options"] = device_data["connection_options"]
-
-        return result
-
     # -------------------------------------------------------------------------
     # Private helper methods
     # -------------------------------------------------------------------------
 
-    def _load_inventory(self) -> dict[str, Any]:
-        """Load test inventory from file.
-
-        Searches for the inventory file using the generic file discovery
-        utility. Subclasses can override this to customize loading behavior.
-
-        Returns:
-            Test inventory dictionary, or empty dict if not found.
-        """
-        filename = self.get_inventory_filename()
-        inventory_path = find_data_file(filename)
-
-        if inventory_path is None:
-            logger.warning(
-                f"Test inventory file '{filename}' not found for "
-                f"{self.get_architecture_name()}. Using empty inventory."
-            )
-            return {}
-
-        logger.info(f"Loading test inventory from {inventory_path}")
-        try:
-            with open(inventory_path) as f:
-                raw_data = yaml.safe_load(f) or {}
-
-            # Support both nested and flat formats:
-            # Nested: {arch: {test_inventory: {...}}}
-            # Flat: {test_inventory: {...}}
-            arch_key = self.get_schema_root_key()
-            if arch_key in raw_data and "test_inventory" in raw_data[arch_key]:
-                return raw_data[arch_key]["test_inventory"]  # type: ignore[no-any-return]
-            elif "test_inventory" in raw_data:
-                return raw_data["test_inventory"]  # type: ignore[no-any-return]
-            else:
-                return raw_data
-
-        except yaml.YAMLError as e:
-            logger.error(f"Failed to parse test inventory YAML: {e}")
-            return {}
-        except OSError as e:
-            logger.error(f"Failed to read test inventory file: {e}")
-            return {}
-
-    def _get_devices_to_test(self) -> list[dict[str, Any]]:
-        """Get the list of device data dicts to process.
-
-        If test_inventory specifies devices, filter to only those.
-        Otherwise, return all devices from the data model.
-
-        Returns:
-            List of device data dictionaries from the data model.
-        """
-        all_devices = list(self.navigate_to_devices())
-        logger.debug(f"Found {len(all_devices)} total devices in data model")
-
-        # If no test inventory, test all devices
-        inventory_devices = self.test_inventory.get("devices", [])
-        if not inventory_devices:
-            logger.debug("No test inventory devices specified, testing all devices")
-            return all_devices
-
-        # Build index for efficient lookup
-        device_index = self._build_device_index(all_devices)
-
-        # Filter to devices in test inventory
-        devices_to_test: list[dict[str, Any]] = []
-        for inventory_entry in inventory_devices:
-            device_id = self._get_device_id_from_inventory(inventory_entry)
-            if device_id in device_index:
-                # Merge inventory entry data with device data
-                merged = {**device_index[device_id], **inventory_entry}
-                devices_to_test.append(merged)
-                logger.debug(f"Added device {device_id} from test inventory")
-            else:
-                logger.warning(
-                    f"Device '{device_id}' from test_inventory not found in "
-                    f"{self.get_architecture_name()} data model"
-                )
-
-        logger.debug(f"Filtered to {len(devices_to_test)} devices from test inventory")
-        return devices_to_test
-
-    def _build_device_index(
-        self, devices: list[dict[str, Any]]
-    ) -> dict[str, dict[str, Any]]:
-        """Build a lookup index of devices by their ID.
-
-        Args:
-            devices: List of device data dictionaries.
-
-        Returns:
-            Dictionary mapping device ID to device data.
-        """
-        device_index: dict[str, dict[str, Any]] = {}
-        for device_data in devices:
-            device_id = self._safe_extract_device_id(device_data)
-            if device_id:
-                device_index[device_id] = device_data
-        return device_index
-
-    def _get_device_id_from_inventory(self, inventory_entry: dict[str, Any]) -> str:
-        """Extract device ID from a test inventory entry.
-
-        Override this if your inventory uses a different field name.
-
-        Args:
-            inventory_entry: Entry from test_inventory.devices[]
-
-        Returns:
-            Device identifier string.
-        """
-        # Common patterns across architectures
-        for key in ["chassis_id", "device_id", "node_id", "hostname", "name"]:
-            if key in inventory_entry:
-                return str(inventory_entry[key])
-
-        logger.warning(
-            f"Could not extract device ID from inventory entry: {inventory_entry}"
-        )
-        return ""
-
     def _safe_extract_device_id(self, device_data: dict[str, Any]) -> str:
         """Safely extract device ID, returning empty string on failure."""
         try:
@@ -370,7 +277,7 @@ class BaseDeviceResolver(ABC):
     def get_schema_root_key(self) -> str:
         """Return the root key in the data model for this architecture.
 
-        Used when loading test inventory and navigating the schema.
+        Used when navigating the schema.
 
         Returns:
             Root key (e.g., "sdwan", "apic", "cc").
@@ -396,11 +303,14 @@ class BaseDeviceResolver(ABC):
         """
         ...
 
-    @abstractmethod
     def extract_device_id(self, device_data: dict[str, Any]) -> str:
         """Extract unique device identifier from device data.
 
-        This ID is used to match test_inventory entries with data model devices.
+        Default implementation delegates to extract_hostname(), which is
+        appropriate when device_id and hostname are the same field.
+
+        Override this method when your architecture has a distinct device
+        identifier (e.g., SD-WAN uses chassis_id, not hostname).
 
         Args:
             device_data: Device data dict from navigate_to_devices().
@@ -408,11 +318,11 @@ class BaseDeviceResolver(ABC):
         Returns:
             Unique device identifier string.
 
-        Example (SD-WAN):
+        Example (SD-WAN override):
             >>> def extract_device_id(self, device_data):
             ...     return device_data["chassis_id"]
         """
-        ...
+        return self.extract_hostname(device_data)
 
     @abstractmethod
     def extract_hostname(self, device_data: dict[str, Any]) -> str:
@@ -435,6 +345,8 @@ class BaseDeviceResolver(ABC):
         """Extract management IP address from device data.
 
         Should handle any IP formatting (e.g., strip CIDR notation).
+        The returned value will be validated by the base class to ensure
+        it is a valid IPv4 or IPv6 address.
 
         Args:
             device_data: Device data dict from navigate_to_devices().
@@ -444,7 +356,7 @@ class BaseDeviceResolver(ABC):
 
         Example (SD-WAN):
             >>> def extract_host_ip(self, device_data):
-            ...     ip_var = device_data.get("management_ip_variable", "mgmt_ip")
+            ...     ip_var = device_data.get("management_ip_variable")
             ...     ip = device_data["device_variables"].get(ip_var, "")
             ...     return ip.split("/")[0] if "/" in ip else ip
         """
@@ -485,17 +397,3 @@ class BaseDeviceResolver(ABC):
             ...     return ("NXOS_SSH_USERNAME", "NXOS_SSH_PASSWORD")
         """
         ...
-
-    # -------------------------------------------------------------------------
-    # Optional overrides
-    # -------------------------------------------------------------------------
-
-    def get_inventory_filename(self) -> str:
-        """Return the test inventory filename.
-
-        Override to use a different filename.
-
-        Returns:
-            Filename (default: "test_inventory.yaml").
-        """
-        return "test_inventory.yaml"

nac_test_pyats_common/iosxe/test_base.py

@@ -21,6 +21,11 @@ class IOSXETestBase(SSHTestBase):  # type: ignore[misc]
     - IOS-XE (direct device access via IOSXE_URL)
     """
 
+    # Class-level storage for the last resolver instance
+    # This allows nac-test to access skipped_devices after calling
+    # get_ssh_device_inventory()
+    _last_resolver: Any = None
+
     @classmethod
     def get_ssh_device_inventory(
         cls, data_model: dict[str, Any]
@@ -63,6 +68,7 @@ class IOSXETestBase(SSHTestBase):  # type: ignore[misc]
                 f"No device resolver registered for controller type '{controller_type}'"
             )
         resolver = resolver_class(data_model)
+        cls._last_resolver = resolver  # Store for skipped_devices access
 
         # Inline validation: Check data model has expected root key
         expected_keys = {

nac_test_pyats_common/sdwan/device_resolver.py

@@ -25,13 +25,20 @@ class SDWANDeviceResolver(BaseDeviceResolver):
 
     Schema structure:
         sdwan:
+          management_ip_variable: "vpn511_int1_if_ipv4_address"  # Global default
           sites:
             - name: "site1"
               routers:
                 - chassis_id: "abc123"
+                  management_ip_variable: "custom_mgmt_ip"  # Router override
                   device_variables:
                     system_hostname: "router1"
-                    vpn10_mgmt_ip: "10.1.1.100/32"
+                    vpn511_int1_if_ipv4_address: "10.1.1.100/32"
+                    custom_mgmt_ip: "10.2.2.200/32"
+
+    Management IP Resolution Priority:
+        1. Router-level management_ip_variable (highest priority)
+        2. Global sdwan-level management_ip_variable (fallback)
 
     Credentials:
         Uses IOSXE_USERNAME and IOSXE_PASSWORD environment variables
@@ -56,7 +63,7 @@ class SDWANDeviceResolver(BaseDeviceResolver):
         """Return 'sdwan' as the root key in the data model.
 
         Returns:
-            Root key used when loading test inventory and navigating schema.
+            Root key used when navigating the schema.
         """
         return "sdwan"
 
@@ -126,6 +133,10 @@ class SDWANDeviceResolver(BaseDeviceResolver):
         Uses management_ip_variable field to determine which variable
         contains the management IP.
 
+        Resolution priority:
+        1. Router-level management_ip_variable (highest priority)
+        2. Global sdwan-level management_ip_variable (fallback)
+
         Args:
             device_data: Router data dictionary from the data model.
 
@@ -133,27 +144,28 @@ class SDWANDeviceResolver(BaseDeviceResolver):
             IP address string without CIDR notation (e.g., "10.1.1.100").
 
         Raises:
-            ValueError: If no management IP can be found.
+            ValueError: If management_ip_variable is not configured or
+                the referenced variable is not found in device_variables.
         """
         device_vars = device_data.get("device_variables", {})
 
-        # Get the variable name that contains the management IP
+        # Cascading lookup: router-level > global sdwan-level
         ip_var = device_data.get("management_ip_variable")
+        if not ip_var:
+            ip_var = self.data_model.get("sdwan", {}).get("management_ip_variable")
+
+        if not ip_var:
+            raise ValueError(
+                "management_ip_variable not configured. "
+                "Set it at router level or sdwan level in sites.nac.yaml."
+            )
+
+        if ip_var not in device_vars:
+            raise ValueError(
+                f"management_ip_variable '{ip_var}' not found in device_variables."
+            )
 
-        if ip_var and ip_var in device_vars:
-            ip_value = str(device_vars[ip_var])
-        else:
-            # Fallback: try common variable names
-            for fallback_var in ["mgmt_ip", "management_ip", "vpn0_ip"]:
-                if fallback_var in device_vars:
-                    ip_value = str(device_vars[fallback_var])
-                    break
-            else:
-                raise ValueError(
-                    "Could not find management IP for device. "
-                    "Set 'management_ip_variable' in test_inventory or use "
-                    "standard variable names (mgmt_ip, management_ip, vpn0_ip)."
-                )
+        ip_value = str(device_vars[ip_var])
 
         # Strip CIDR notation if present
         if "/" in ip_value:
@@ -162,15 +174,35 @@ class SDWANDeviceResolver(BaseDeviceResolver):
         return ip_value
 
     def extract_os_type(self, device_data: dict[str, Any]) -> str:
-        """Extract OS type, defaulting to 'iosxe' for SD-WAN edges.
+        """Return 'iosxe' as all SD-WAN edge devices are IOS-XE based.
+
+        Args:
+            device_data: Router data dictionary (unused, OS is hardcoded).
+
+        Returns:
+            Always returns 'iosxe'.
+        """
+        return "iosxe"
+
+    def build_device_dict(self, device_data: dict[str, Any]) -> dict[str, Any]:
+        """Build device dictionary with SD-WAN specific defaults.
+
+        Extends the base implementation to add type='router' since
+        all SD-WAN edge devices are routers.
 
         Args:
             device_data: Router data dictionary from the data model.
 
         Returns:
-            OS type string (e.g., "iosxe", "nxos", "iosxr").
+            Device dictionary with hostname, host, os, device_id, and type.
         """
-        return str(device_data.get("os", "iosxe"))
+        # Get base device dict from parent
+        device_dict = super().build_device_dict(device_data)
+
+        # Add type - all SD-WAN edges are routers
+        device_dict["type"] = "router"
+
+        return device_dict
 
     def get_credential_env_vars(self) -> tuple[str, str]:
         """Return IOS-XE credential env vars for SD-WAN edge devices.

nac_test_pyats_common/sdwan/ssh_test_base.py

@@ -48,6 +48,11 @@ class SDWANTestBase(SSHTestBase):  # type: ignore[misc]
                 pass
     """
 
+    # Class-level storage for the last resolver instance
+    # This allows nac-test to access skipped_devices after calling
+    # get_ssh_device_inventory()
+    _last_resolver: "SDWANDeviceResolver | None" = None
+
     @classmethod
     def get_ssh_device_inventory(
         cls, data_model: dict[str, Any]
@@ -57,11 +62,13 @@ class SDWANTestBase(SSHTestBase):  # type: ignore[misc]
         This method is the entry point called by nac-test's orchestrator.
         All device inventory resolution is delegated to SDWANDeviceResolver,
         which handles:
-        - Test inventory loading (test_inventory.yaml)
         - Schema navigation (sites[].routers[])
-        - Variable resolution (hostnames, IPs)
+        - Management IP resolution via management_ip_variable
         - Credential injection (IOSXE_USERNAME, IOSXE_PASSWORD)
 
+        After calling this method, access cls._last_resolver.skipped_devices
+        to get information about devices that failed resolution.
+
         Args:
             data_model: The merged data model from nac-test containing all
                 sites.nac.yaml data with resolved variables.
@@ -80,13 +87,8 @@ class SDWANTestBase(SSHTestBase):  # type: ignore[misc]
         """
         logger.info("SDWANTestBase: Resolving device inventory via SDWANDeviceResolver")
 
-        # Delegate entirely to the resolver
-        # SDWANDeviceResolver handles:
-        # 1. Test inventory loading via BaseDeviceResolver._load_inventory()
-        # 2. Schema navigation via navigate_to_devices()
-        # 3. Credential injection via _inject_credentials() using IOSXE_* env vars
-        resolver = SDWANDeviceResolver(data_model)
-        return resolver.get_resolved_inventory()
+        cls._last_resolver = SDWANDeviceResolver(data_model)
+        return cls._last_resolver.get_resolved_inventory()
 
     def get_device_credentials(self, device: dict[str, Any]) -> dict[str, str | None]:
         """Get SD-WAN edge device SSH credentials from environment variables.

{nac_test_pyats_common-0.1.1.dist-info → nac_test_pyats_common-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nac-test-pyats-common
-Version: 0.1.1
+Version: 0.2.0
 Summary: Architecture adapters for Network as Code (NaC) PyATS testing - auth classes, test base classes, and device resolvers
 Project-URL: Homepage, https://github.com/netascode/nac-test-pyats-common
 Project-URL: Documentation, https://github.com/netascode/nac-test-pyats-common

{nac_test_pyats_common-0.1.1.dist-info → nac_test_pyats_common-0.2.0.dist-info}/RECORD

@@ -1,24 +1,25 @@
-nac_test_pyats_common/__init__.py,sha256=bQ3oB1eajVj8pmMnWCxxQEHUW-FkQX94j-6ocBq9OxA,1623
+nac_test_pyats_common/__init__.py,sha256=4fOaRhzkJJDyW00-wPzEzgWdmLXSLfxkiV-Z39RWmq8,1770
 nac_test_pyats_common/py.typed,sha256=BrP39il8_cNN1K0KDeyBUtySS9oI2_SK5xKx1SxdSoY,59
 nac_test_pyats_common/aci/__init__.py,sha256=Y9VhBZ3_GXLBk3_Wtg1SRG_Dxx134Etf9k-0wvrOMwQ,1335
 nac_test_pyats_common/aci/auth.py,sha256=1Rk2uBGb_CGgkBh9dD3LagIsbJPKRgsSFDYEeyiC50U,7867
 nac_test_pyats_common/aci/test_base.py,sha256=SoPh91AXPvMshJXIyjiZumSgxOAN4xPkpSb3t0B9kdE,6256
-nac_test_pyats_common/catc/__init__.py,sha256=NKIHm6zOiiG8T_wcanPTh8621_RGcVJCMOeQLygTsy8,1319
+nac_test_pyats_common/catc/__init__.py,sha256=ZGOQBvjFvq7h9LtfOyxFEmlir7htpy8sfWoJuDwGjsA,1986
+nac_test_pyats_common/catc/api_test_base.py,sha256=kGp6rZ4S3zP3MW5BD02K5uVxmtE-vRlG2A99kaLgyDo,7507
 nac_test_pyats_common/catc/auth.py,sha256=1oDZr_PEWOz1IZOUm_kyKzIFPQubMo_wemj-Q3D7ALU,9522
-nac_test_pyats_common/catc/test_base.py,sha256=kGp6rZ4S3zP3MW5BD02K5uVxmtE-vRlG2A99kaLgyDo,7507
+nac_test_pyats_common/catc/device_resolver.py,sha256=YgJJn1pXONXCAMnfXA-_Iuo6tkLtD9EekHbPbae6mRg,5363
+nac_test_pyats_common/catc/ssh_test_base.py,sha256=wUldp2T9cmSEALBtbOgUQvQ2txuid3ErJEO27kM-kiI,4482
 nac_test_pyats_common/common/__init__.py,sha256=Y0qrZEKx2g8Zm1CTHJpeLocwMasspP6NQuhyrRiA1wA,1084
-nac_test_pyats_common/common/base_device_resolver.py,sha256=bPZP_dJjBfvaUGg_8F1JhfGAnWzAqI8oIC_JEejDJ4E,18558
+nac_test_pyats_common/common/base_device_resolver.py,sha256=xP4QF-kNp_8rFo9N6wzfJSIpNOgnPkeZmWAbH0k5tGo,15091
 nac_test_pyats_common/iosxe/__init__.py,sha256=GSuLGyxcu8dFouspTjXuQ1Mi27vDluVR8ZCcJrPcIiY,2147
-nac_test_pyats_common/iosxe/catc_resolver.py,sha256=t14Pa6WjrjrbinXTtwc0Wa14Cctcae2yLLgdIpByzoU,2513
 nac_test_pyats_common/iosxe/iosxe_resolver.py,sha256=XzzwRCa1cuQ6HmeUB1Z2vITOwYdhuDlugDD1eVXAoIE,2355
 nac_test_pyats_common/iosxe/registry.py,sha256=djRFzxuEu8IdyTmi1puhIHGZGSMjys0l1v4-uzYCwAU,5723
-nac_test_pyats_common/iosxe/test_base.py,sha256=s-x9hGJ4Yi6313gVamXnHWO7Jzr8tTKXzSOVJ6HcTxU,4306
+nac_test_pyats_common/iosxe/test_base.py,sha256=NjXbf0ZY-CBWhd3jpIAhylL5kyRrHM6FlhGlFtjLSjM,4569
 nac_test_pyats_common/sdwan/__init__.py,sha256=mrziVp5kMgykKnFPvWykuVLuky6xwEv6oEcfrbxFXxY,1777
 nac_test_pyats_common/sdwan/api_test_base.py,sha256=NuqrxODrRw7ZvEIuoc1Bup60thKqJOfiGz96T4QJ8Ng,7632
 nac_test_pyats_common/sdwan/auth.py,sha256=CMgf_AYCalVQNjdUfDlE-0-z5tnhU_Wnscgt5ZW61RY,10322
-nac_test_pyats_common/sdwan/device_resolver.py,sha256=3eKdIpoZsWHL8EzoKma1ZL6cFiMAQRZiMLp_xf9ZcEw,6062
-nac_test_pyats_common/sdwan/ssh_test_base.py,sha256=8ddzOOyrxVF1uYiOOg2v8kXBI628c6hg-P-hiOC-v3Q,4173
-nac_test_pyats_common-0.1.1.dist-info/METADATA,sha256=1vxKpKhdqZbR0N7wFJH_VYcpGB9MiJiumhUvzaP_4Hg,13072
-nac_test_pyats_common-0.1.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nac_test_pyats_common-0.1.1.dist-info/licenses/LICENSE,sha256=zt2sx-c0iEk6-OO0iqRQ4l6fIGazRKW_qLMqfDpLm6M,16295
-nac_test_pyats_common-0.1.1.dist-info/RECORD,,
+nac_test_pyats_common/sdwan/device_resolver.py,sha256=1GdM5QKftj4F5bGmsbH90--VqoFZaDPMerHF1dAceMQ,7169
+nac_test_pyats_common/sdwan/ssh_test_base.py,sha256=rZF7txhu0FGtPtTzGMZFqB9hwClmtggroZwRuX3BGU4,4210
+nac_test_pyats_common-0.2.0.dist-info/METADATA,sha256=9Qbd0AYAGd33wI1iwbynSClOmApEC-Iny0geUrBoIzA,13072
+nac_test_pyats_common-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nac_test_pyats_common-0.2.0.dist-info/licenses/LICENSE,sha256=zt2sx-c0iEk6-OO0iqRQ4l6fIGazRKW_qLMqfDpLm6M,16295
+nac_test_pyats_common-0.2.0.dist-info/RECORD,,

nac_test_pyats_common/iosxe/catc_resolver.py

@@ -1,67 +0,0 @@
-# SPDX-License-Identifier: MPL-2.0
-# Copyright (c) 2025 Daniel Schmidt
-
-"""Catalyst Center device resolver placeholder for D2D testing.
-
-This is a placeholder for the Catalyst Center resolver that will be implemented
-when Catalyst Center D2D testing support is added. This resolver will handle
-IOS-XE devices managed by Catalyst Center.
-
-Expected environment variables:
-    - CC_URL: Catalyst Center controller URL
-    - CC_USERNAME: Catalyst Center username
-    - CC_PASSWORD: Catalyst Center password
-    - IOSXE_USERNAME: SSH username for devices
-    - IOSXE_PASSWORD: SSH password for devices
-
-"""
-
-from typing import Any
-
-from nac_test_pyats_common.common import BaseDeviceResolver
-
-from .registry import register_iosxe_resolver
-
-
-@register_iosxe_resolver("CC")
-class CatalystCenterDeviceResolver(BaseDeviceResolver):
-    """Placeholder resolver for Catalyst Center D2D testing.
-
-    This resolver will be implemented when Catalyst Center D2D testing
-    support is added. Currently a placeholder to reserve the CC registry slot.
-    """
-
-    def get_architecture_name(self) -> str:
-        """Return architecture name."""
-        return "catalyst_center"
-
-    def get_schema_root_key(self) -> str:
-        """Return data model root key."""
-        return "catalyst_center"
-
-    def navigate_to_devices(self) -> list[dict[str, Any]]:
-        """Navigate to devices in data model."""
-        raise NotImplementedError(
-            "CatalystCenterDeviceResolver is not yet implemented. "
-            "This placeholder reserves the CC registry slot for future use."
-        )
-
-    def extract_device_id(self, device_data: dict[str, Any]) -> str:
-        """Extract device ID."""
-        raise NotImplementedError("CatalystCenterDeviceResolver is not yet implemented")
-
-    def extract_hostname(self, device_data: dict[str, Any]) -> str:
-        """Extract hostname."""
-        raise NotImplementedError("CatalystCenterDeviceResolver is not yet implemented")
-
-    def extract_host_ip(self, device_data: dict[str, Any]) -> str:
-        """Extract management IP."""
-        raise NotImplementedError("CatalystCenterDeviceResolver is not yet implemented")
-
-    def extract_os_type(self, device_data: dict[str, Any]) -> str:
-        """Extract OS type."""
-        raise NotImplementedError("CatalystCenterDeviceResolver is not yet implemented")
-
-    def get_credential_env_vars(self) -> tuple[str, str]:
-        """Return credential environment variable names."""
-        return ("IOSXE_USERNAME", "IOSXE_PASSWORD")