nac-test-pyats-common 0.1.0__py3-none-any.whl

nac_test_pyats_common/iosxe/__init__.py

@@ -0,0 +1,58 @@
+"""IOS-XE adapter module for NAC PyATS testing.
+
+This module provides a generic IOS-XE test base class and resolver registry
+for architecture-specific device resolvers. It supports SSH-based device-to-device
+(D2D) testing across multiple architectures that manage IOS-XE devices (SD-WAN,
+Meraki, Catalyst Center, etc.).
+
+The module implements a plugin architecture where each controller type can register
+its own device resolver while sharing common IOS-XE SSH testing capabilities.
+
+Classes:
+    IOSXETestBase: Base class for IOS-XE SSH/D2D tests with common functionality.
+        Provides device iteration, command execution, and result processing.
+
+Registry Functions:
+    register_iosxe_resolver: Decorator for registering architecture-specific resolvers.
+    get_resolver_for_controller: Get the appropriate resolver for a controller type.
+    get_supported_controllers: List all registered controller types.
+
+Example:
+    For registering a new resolver:
+
+    >>> from nac_test_pyats_common.iosxe import register_iosxe_resolver
+    >>> from nac_test_pyats_common.common import BaseDeviceResolver
+    >>>
+    >>> @register_iosxe_resolver("SDWAN")
+    ... class SDWANDeviceResolver(BaseDeviceResolver):
+    ...     def get_architecture_name(self) -> str:
+    ...         return "sdwan"
+    ...     # ... implement other abstract methods
+
+    For using in tests:
+
+    >>> from nac_test_pyats_common.iosxe import IOSXETestBase
+    >>>
+    >>> class VerifyInterfaceStatus(IOSXETestBase):
+    ...     @aetest.test
+    ...     def verify_interfaces(self, steps, device):
+    ...         # SSH-based verification on IOS-XE device
+    ...         output = device.execute("show ip interface brief")
+    ...         # ... process output
+"""
+
+from .registry import (
+    get_resolver_for_controller,
+    get_supported_controllers,
+    register_iosxe_resolver,
+)
+from .test_base import IOSXETestBase
+
+__all__ = [
+    # Test base class
+    "IOSXETestBase",
+    # Registry functions
+    "register_iosxe_resolver",
+    "get_resolver_for_controller",
+    "get_supported_controllers",
+]

nac_test_pyats_common/iosxe/catc_resolver.py

@@ -0,0 +1,64 @@
+"""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")

nac_test_pyats_common/iosxe/iosxe_resolver.py

@@ -0,0 +1,62 @@
+"""IOSXE device resolver placeholder for direct IOS-XE device access.
+
+This is a placeholder for the IOSXE resolver that will be implemented
+when direct IOS-XE device support is added. This resolver will handle
+devices accessed directly via IOSXE_URL without a centralized controller.
+
+Expected environment variables:
+    - IOSXE_URL: URL for direct device access
+    - 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("IOSXE")
+class IOSXEResolver(BaseDeviceResolver):
+    """Placeholder resolver for direct IOS-XE device access.
+
+    This resolver will be implemented when IOSXE_URL-based direct device
+    access is supported. Currently a placeholder to reserve the IOSXE
+    registry slot.
+    """
+
+    def get_architecture_name(self) -> str:
+        """Return architecture name."""
+        return "iosxe"
+
+    def get_schema_root_key(self) -> str:
+        """Return data model root key."""
+        return "devices"
+
+    def navigate_to_devices(self) -> list[dict[str, Any]]:
+        """Navigate to devices in data model."""
+        raise NotImplementedError(
+            "IOSXEResolver is not yet implemented. "
+            "This placeholder reserves the IOSXE registry slot for future use."
+        )
+
+    def extract_device_id(self, device_data: dict[str, Any]) -> str:
+        """Extract device ID."""
+        raise NotImplementedError("IOSXEResolver is not yet implemented")
+
+    def extract_hostname(self, device_data: dict[str, Any]) -> str:
+        """Extract hostname."""
+        raise NotImplementedError("IOSXEResolver is not yet implemented")
+
+    def extract_host_ip(self, device_data: dict[str, Any]) -> str:
+        """Extract management IP."""
+        raise NotImplementedError("IOSXEResolver is not yet implemented")
+
+    def extract_os_type(self, device_data: dict[str, Any]) -> str:
+        """Extract OS type."""
+        raise NotImplementedError("IOSXEResolver is not yet implemented")
+
+    def get_credential_env_vars(self) -> tuple[str, str]:
+        """Return credential environment variable names."""
+        return ("IOSXE_USERNAME", "IOSXE_PASSWORD")

nac_test_pyats_common/iosxe/registry.py

@@ -0,0 +1,153 @@
+"""Registry for IOS-XE device resolvers.
+
+This module implements a plugin architecture for registering and retrieving
+device resolvers for different controller types that manage IOS-XE devices.
+Each architecture (SD-WAN, Meraki, Catalyst Center, etc.) can register its
+own resolver while sharing common IOS-XE functionality.
+
+The registry pattern allows for:
+- Decoupled architecture implementations
+- Runtime discovery of available resolvers
+- Easy extension with new controller types
+- Type-safe resolver registration and retrieval
+
+Global Variables:
+    _IOSXE_RESOLVER_REGISTRY: Dictionary mapping controller types to resolver classes.
+
+Functions:
+    register_iosxe_resolver: Decorator for registering a resolver class.
+    get_resolver_for_controller: Retrieve a resolver for a specific controller type.
+    get_supported_controllers: List all registered controller types.
+"""
+
+import logging
+from collections.abc import Callable
+from typing import TypeVar
+
+from nac_test_pyats_common.common import BaseDeviceResolver
+
+# Type variable for the resolver class type
+T = TypeVar("T", bound=BaseDeviceResolver)
+
+logger = logging.getLogger(__name__)
+
+# Global registry for IOS-XE device resolvers
+_IOSXE_RESOLVER_REGISTRY: dict[str, type[BaseDeviceResolver]] = {}
+
+
+def register_iosxe_resolver(controller_type: str) -> Callable[[type[T]], type[T]]:
+    """Decorator to register an IOS-XE device resolver for a controller type.
+
+    This decorator registers a device resolver class with the global registry,
+    associating it with a specific controller type. The resolver must extend
+    BaseDeviceResolver and implement all required abstract methods.
+
+    Args:
+        controller_type: The controller type identifier (e.g., "SDWAN", "MERAKI",
+            "CATALYST_CENTER"). Should be uppercase by convention.
+
+    Returns:
+        A decorator function that registers the class and returns it unchanged.
+
+    Raises:
+        ValueError: If a resolver is already registered for the controller type.
+        TypeError: If the class doesn't extend BaseDeviceResolver.
+
+    Example:
+        >>> @register_iosxe_resolver("SDWAN")
+        ... class SDWANDeviceResolver(BaseDeviceResolver):
+        ...     def get_architecture_name(self) -> str:
+        ...         return "sdwan"
+        ...     # ... implement other abstract methods
+        >>>
+        >>> # The resolver is now registered and can be retrieved
+        >>> resolver_class = get_resolver_for_controller("SDWAN")
+    """
+
+    def decorator(cls: type[T]) -> type[T]:
+        """Register the resolver class and return it unchanged.
+
+        Args:
+            cls: The resolver class to register.
+
+        Returns:
+            The same class, unchanged.
+
+        Raises:
+            ValueError: If a resolver is already registered for the controller type.
+            TypeError: If the class doesn't extend BaseDeviceResolver.
+        """
+        # Validate the class extends BaseDeviceResolver
+        if not issubclass(cls, BaseDeviceResolver):
+            raise TypeError(f"Resolver class {cls.__name__} must extend BaseDeviceResolver")
+
+        # Check for duplicate registration
+        if controller_type in _IOSXE_RESOLVER_REGISTRY:
+            existing_class = _IOSXE_RESOLVER_REGISTRY[controller_type]
+            raise ValueError(
+                f"A resolver is already registered for controller type '{controller_type}': "
+                f"{existing_class.__module__}.{existing_class.__name__}"
+            )
+
+        # Register the resolver
+        _IOSXE_RESOLVER_REGISTRY[controller_type] = cls
+        logger.debug(
+            f"Registered IOS-XE resolver {cls.__name__} for controller type '{controller_type}'"
+        )
+
+        return cls
+
+    return decorator
+
+
+def get_resolver_for_controller(controller_type: str) -> type[BaseDeviceResolver] | None:
+    """Get the device resolver class for a specific controller type.
+
+    Retrieves the registered resolver class for the specified controller type.
+    Returns None if no resolver is registered for that type.
+
+    Args:
+        controller_type: The controller type identifier (e.g., "SDWAN", "MERAKI").
+
+    Returns:
+        The resolver class if registered, None otherwise.
+
+    Example:
+        >>> resolver_class = get_resolver_for_controller("SDWAN")
+        >>> if resolver_class:
+        ...     resolver = resolver_class(data_model)
+        ...     devices = resolver.get_resolved_inventory()
+        ... else:
+        ...     print("No resolver found for SDWAN")
+    """
+    resolver_class = _IOSXE_RESOLVER_REGISTRY.get(controller_type)
+
+    if resolver_class:
+        logger.debug(
+            f"Found resolver {resolver_class.__name__} for controller type '{controller_type}'"
+        )
+    else:
+        logger.debug(
+            f"No resolver registered for controller type '{controller_type}'. "
+            f"Available types: {', '.join(get_supported_controllers())}"
+        )
+
+    return resolver_class
+
+
+def get_supported_controllers() -> list[str]:
+    """Get a list of all registered controller types.
+
+    Returns a sorted list of controller type identifiers for which
+    resolvers have been registered. This is useful for validation,
+    documentation, and user feedback.
+
+    Returns:
+        Sorted list of registered controller type strings.
+
+    Example:
+        >>> controllers = get_supported_controllers()
+        >>> print(f"Supported controllers: {', '.join(controllers)}")
+        Supported controllers: CATALYST_CENTER, MERAKI, SDWAN
+    """
+    return sorted(_IOSXE_RESOLVER_REGISTRY.keys())

nac_test_pyats_common/iosxe/test_base.py

@@ -0,0 +1,116 @@
+"""IOS-XE test base class for SSH/D2D testing."""
+
+import os
+from typing import Any
+
+from nac_test.pyats_core.common.ssh_base_test import SSHTestBase
+from nac_test.utils.controller import detect_controller_type
+
+from .registry import get_resolver_for_controller
+
+
+class IOSXETestBase(SSHTestBase):  # type: ignore[misc]
+    """Base class for IOS-XE device testing via SSH.
+
+    Provides device inventory resolution for multiple architectures:
+    - SD-WAN (via vManage)
+    - Catalyst Center
+    - IOS-XE (direct device access via IOSXE_URL)
+    """
+
+    @classmethod
+    def get_ssh_device_inventory(cls, data_model: dict[str, Any]) -> list[dict[str, Any]]:
+        """Get the SSH device inventory for IOS-XE devices.
+
+        Main entry point that detects the architecture and returns
+        the resolved device inventory. Performs inline validation
+        of controller type and data model structure.
+
+        Args:
+            data_model: The merged data model from nac-test containing all
+                configuration data with resolved variables.
+
+        Returns:
+            List of device dictionaries with connection details.
+
+        Raises:
+            ValueError: If controller type is unsupported or data validation fails.
+        """
+        # Try to detect controller type from environment
+        controller_type = detect_controller_type()
+
+        # If no controller detected, infer from data model
+        if controller_type == "UNKNOWN":
+            controller_type = cls._infer_architecture_from_data_model(data_model)
+
+        # Inline validation: Check if controller supports IOS-XE
+        supported_controllers = {"SDWAN", "CC", "IOSXE"}
+        if controller_type not in supported_controllers:
+            raise ValueError(
+                f"Controller type '{controller_type}' does not support IOS-XE devices. "
+                f"Supported types: {', '.join(sorted(supported_controllers))}"
+            )
+
+        # Get resolver from registry
+        resolver_class = get_resolver_for_controller(controller_type)
+        if resolver_class is None:
+            raise ValueError(
+                f"No device resolver registered for controller type '{controller_type}'"
+            )
+        resolver = resolver_class(data_model)
+
+        # Inline validation: Check data model has expected root key
+        expected_keys = {
+            "SDWAN": "sdwan",
+            "CC": "catalyst_center",
+            "IOSXE": "devices",
+        }
+        expected_key = expected_keys.get(controller_type)
+        if expected_key and expected_key not in data_model:
+            raise ValueError(
+                f"Data model missing expected root key '{expected_key}' "
+                f"for {controller_type} architecture"
+            )
+
+        # Return resolved inventory
+        return resolver.get_resolved_inventory()
+
+    @classmethod
+    def _infer_architecture_from_data_model(cls, data_model: dict[str, Any]) -> str:
+        """Infer architecture from data model structure when no controller is present.
+
+        Examines the root keys in the data model to determine which
+        architecture is being used.
+
+        Args:
+            data_model: The merged data model to examine.
+
+        Returns:
+            Inferred controller type string.
+        """
+        # Check for architecture-specific root keys
+        if "sdwan" in data_model:
+            return "SDWAN"
+        elif "catalyst_center" in data_model:
+            return "CC"
+        elif "devices" in data_model:
+            return "IOSXE"
+        else:
+            # Default to IOS-XE if no recognized structure
+            return "IOSXE"
+
+    def get_device_credentials(self, device: dict[str, Any]) -> dict[str, str | None]:
+        """Get IOS-XE device credentials from environment.
+
+        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/py.typed

@@ -0,0 +1 @@
+# PEP 561 marker file - this package supports type checking

nac_test_pyats_common/sdwan/__init__.py

@@ -0,0 +1,47 @@
+"""SD-WAN (SDWAN Manager) adapter module for NAC PyATS testing.
+
+This module provides SD-WAN-specific authentication, test base classes, and device
+resolver implementations for use with the nac-test framework. It includes support
+for both SDWAN Manager API testing and SSH-based device-to-device (D2D) testing.
+
+Classes:
+    SDWANManagerAuth: SDWAN Manager authentication with JSESSIONID and XSRF token management.
+    SDWANManagerTestBase: Base class for SDWAN Manager API tests with tracking.
+    SDWANTestBase: Base class for SD-WAN SSH/D2D tests with device inventory.
+    SDWANDeviceResolver: Resolves device information from the SD-WAN data model.
+
+Example:
+    For SDWAN Manager API testing:
+
+    >>> from nac_test_pyats_common.sdwan import SDWANManagerTestBase
+    >>>
+    >>> class VerifyDeviceList(SDWANManagerTestBase):
+    ...     async def get_items_to_verify(self):
+    ...         return ['device1', 'device2']
+    ...
+    ...     async def verify_item(self, item):
+    ...         response = await self.client.get(f"/dataservice/device/{item}")
+    ...         return response.status_code == 200
+
+    For SSH/D2D testing:
+
+    >>> from nac_test_pyats_common.sdwan import SDWANTestBase
+    >>>
+    >>> class VerifyInterfaceStatus(SDWANTestBase):
+    ...     @aetest.test
+    ...     def verify_interfaces(self, steps, device):
+    ...         # SSH-based verification
+    ...         pass
+"""
+
+from .api_test_base import SDWANManagerTestBase
+from .auth import SDWANManagerAuth
+from .device_resolver import SDWANDeviceResolver
+from .ssh_test_base import SDWANTestBase
+
+__all__ = [
+    "SDWANManagerAuth",
+    "SDWANManagerTestBase",
+    "SDWANTestBase",
+    "SDWANDeviceResolver",
+]

nac_test_pyats_common/sdwan/api_test_base.py

@@ -0,0 +1,164 @@
+"""SDWAN Manager-specific base test class for SD-WAN API testing.
+
+This module provides the SDWANManagerTestBase class, which extends the generic NACTestBase
+to add SDWAN Manager-specific functionality for testing SD-WAN controllers. It handles
+session management (JSESSIONID and XSRF token), client configuration, and provides
+a standardized interface for running asynchronous verification tests against SDWAN Manager.
+
+The class integrates with PyATS/Genie test frameworks and provides automatic
+API call tracking for enhanced HTML reporting.
+"""
+
+import asyncio
+from typing import Any
+
+import httpx
+from nac_test.pyats_core.common.base_test import NACTestBase  # type: ignore[import-untyped]
+from pyats import aetest  # type: ignore[import-untyped]
+
+from .auth import SDWANManagerAuth
+
+
+class SDWANManagerTestBase(NACTestBase):  # type: ignore[misc]
+    """Base class for SDWAN Manager API tests with enhanced reporting.
+
+    This class extends the generic NACTestBase to provide SDWAN Manager-specific
+    functionality including session management (JSESSIONID and optional XSRF token),
+    API call tracking for HTML reports, and wrapped HTTP client for automatic
+    response capture. It serves as the foundation for all SD-WAN controller-specific
+    API test classes.
+
+    The class follows the same pattern as APICTestBase for consistency across
+    NAC architecture adapters. Token refresh is handled automatically by the
+    AuthCache TTL mechanism.
+
+    Attributes:
+        auth_data (dict): SDWAN Manager authentication data containing jsessionid and
+            optional xsrf_token obtained during setup.
+        client (httpx.AsyncClient | None): Wrapped async HTTP client configured for
+            SDWAN Manager. Initialized to None, set during setup().
+        controller_url (str): Base URL of the SDWAN Manager (inherited).
+        username (str): SDWAN Manager username for authentication (inherited).
+        password (str): SDWAN Manager password for authentication (inherited).
+
+    Methods:
+        setup(): Initialize SDWAN Manager authentication and client.
+        get_sdwan_manager_client(): Create and configure an SDWAN Manager-specific HTTP client.
+        run_async_verification_test(): Execute async verification tests with PyATS.
+
+    Example:
+        class MySDWANManagerTest(SDWANManagerTestBase):
+            async def get_items_to_verify(self):
+                return ['device1', 'device2']
+
+            async def verify_item(self, item):
+                # Custom verification logic here
+                pass
+
+            @aetest.test
+            def verify_devices(self, steps):
+                self.run_async_verification_test(steps)
+    """
+
+    client: httpx.AsyncClient | None = None  # MUST declare at class level
+
+    @aetest.setup  # type: ignore[misc, untyped-decorator]
+    def setup(self) -> None:
+        """Setup method that extends the generic base class setup.
+
+        Initializes the SDWAN Manager test environment by:
+        1. Calling the parent class setup method
+        2. Obtaining SDWAN Manager session data (jsessionid, xsrf_token) using cached auth
+        3. Creating and storing an SDWAN Manager client for use in verification methods
+
+        The session data is obtained through the SDWANManagerAuth utility which
+        manages session lifecycle and prevents duplicate authentication requests
+        across parallel test execution.
+        """
+        super().setup()
+
+        # Get shared SDWAN Manager auth data (jsessionid, xsrf_token)
+        self.auth_data = SDWANManagerAuth.get_auth()
+
+        # Store the SDWAN Manager client for use in verification methods
+        self.client = self.get_sdwan_manager_client()
+
+    def get_sdwan_manager_client(self) -> httpx.AsyncClient:
+        """Get an httpx async client configured for SDWAN Manager with response tracking.
+
+        Creates an HTTP client specifically configured for SDWAN Manager API communication
+        with session headers, base URL, and automatic response tracking for HTML
+        report generation. The client is wrapped to capture all API interactions
+        for detailed test reporting.
+
+        The client includes:
+        - JSESSIONID cookie in all requests (via Cookie header)
+        - X-XSRF-TOKEN header when available (19.2+)
+        - Content-Type: application/json header
+        - Automatic API call tracking for reporting
+
+        Returns:
+            httpx.AsyncClient: Configured client with SDWAN Manager session data, base URL,
+                and wrapped for automatic API call tracking. The client has SSL
+                verification disabled for lab environment compatibility.
+
+        Note:
+            SSL verification is disabled (verify=False) to support lab environments
+            with self-signed certificates. For production environments, consider
+            enabling SSL verification with proper certificate management.
+        """
+        # Build headers with Cookie header (following APIC pattern for consistency)
+        headers = {
+            "Cookie": f"JSESSIONID={self.auth_data['jsessionid']}",
+            "Content-Type": "application/json",
+        }
+
+        # Add XSRF token if available (19.2+ requires this for CSRF protection)
+        if self.auth_data.get("xsrf_token"):
+            headers["X-XSRF-TOKEN"] = self.auth_data["xsrf_token"]
+
+        # Get base client from pool with SSL verification disabled for lab compatibility
+        base_client = self.pool.get_client(
+            base_url=self.controller_url, headers=headers, verify=False
+        )
+
+        # Use the generic tracking wrapper from base class
+        return self.wrap_client_for_tracking(base_client, device_name="SDWAN Manager")  # type: ignore[no-any-return]
+
+    def run_async_verification_test(self, steps: Any) -> None:
+        """Execute asynchronous verification tests with PyATS step tracking.
+
+        Simple entry point that uses base class orchestration to run async
+        verification tests. This thin wrapper:
+        1. Creates and manages an event loop for async operations
+        2. Calls NACTestBase.run_verification_async() to execute tests
+        3. Passes results to NACTestBase.process_results_smart() for reporting
+        4. Ensures proper cleanup of async resources
+
+        The actual verification logic is handled by:
+        - get_items_to_verify() - must be implemented by the test class
+        - verify_item() - must be implemented by the test class
+
+        Args:
+            steps: PyATS steps object for test reporting and step management.
+                Each verification item will be executed as a separate step
+                with automatic pass/fail tracking.
+
+        Note:
+            This method creates its own event loop to ensure compatibility
+            with PyATS synchronous test execution model. The loop and client
+            connections are properly closed after test completion.
+        """
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            # Call the base class generic orchestration
+            results = loop.run_until_complete(self.run_verification_async())
+
+            # Process results using smart configuration-driven processing
+            self.process_results_smart(results, steps)
+        finally:
+            # Clean up the SDWAN Manager client connection
+            if self.client is not None:  # MANDATORY: never use hasattr()
+                loop.run_until_complete(self.client.aclose())
+            loop.close()