wire-in new service to the Manager

Author: skrobul

python/understack-workflows/tests/test_netapp_manager.py

@@ -374,3 +374,225 @@ def test_desired_node_number_extraction(self):
             vlan_id=100,
         )
         assert config_n2.desired_node_number == 2
+
+
+class TestNetAppManagerRouteIntegration:
+    """Test NetAppManager route integration functionality."""
+
+    @pytest.fixture
+    def mock_config_file(self):
+        """Create a temporary config file for testing."""
+        config_content = """[netapp_nvme]
+netapp_server_hostname = test-hostname
+netapp_login = test-user
+netapp_password = test-password
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".conf", delete=False) as f:
+            f.write(config_content)
+            f.flush()
+            yield f.name
+        os.unlink(f.name)
+
+    @pytest.fixture
+    def sample_interface_configs(self):
+        """Create sample interface configurations for testing."""
+        return [
+            NetappIPInterfaceConfig(
+                name="N1-lif-A",
+                address=ipaddress.IPv4Address("100.127.0.21"),
+                network=ipaddress.IPv4Network("100.127.0.16/29"),
+                vlan_id=100,
+            ),
+            NetappIPInterfaceConfig(
+                name="N1-lif-B",
+                address=ipaddress.IPv4Address("100.127.128.21"),
+                network=ipaddress.IPv4Network("100.127.128.16/29"),
+                vlan_id=200,
+            ),
+            NetappIPInterfaceConfig(
+                name="N2-lif-A",
+                address=ipaddress.IPv4Address("100.127.0.22"),
+                network=ipaddress.IPv4Network("100.127.0.16/29"),
+                vlan_id=100,
+            ),
+        ]
+
+    @patch("understack_workflows.netapp.manager.config")
+    @patch("understack_workflows.netapp.manager.HostConnection")
+    def test_route_service_initialization(
+        self, mock_host_connection, mock_config, mock_config_file
+    ):
+        """Test that RouteService is properly initialized in NetAppManager."""
+        manager = NetAppManager(mock_config_file)
+
+        # Verify route service is initialized
+        assert hasattr(manager, "_route_service")
+        assert manager._route_service is not None
+
+    @patch("understack_workflows.netapp.manager.config")
+    @patch("understack_workflows.netapp.manager.HostConnection")
+    def test_create_routes_for_project_delegates_to_service(
+        self,
+        mock_host_connection,
+        mock_config,
+        mock_config_file,
+        sample_interface_configs,
+    ):
+        """Test create_routes_for_project delegates to RouteService."""
+        from understack_workflows.netapp.value_objects import RouteResult
+
+        manager = NetAppManager(mock_config_file)
+
+        # Mock route service
+        expected_results = [
+            RouteResult(
+                uuid="route-uuid-1",
+                gateway="100.127.0.17",
+                destination="100.126.0.0/17",
+                svm_name="os-test-project",
+            ),
+            RouteResult(
+                uuid="route-uuid-2",
+                gateway="100.127.128.17",
+                destination="100.126.128.0/17",
+                svm_name="os-test-project",
+            ),
+        ]
+        manager._route_service.create_routes_from_interfaces = MagicMock(
+            return_value=expected_results
+        )
+
+        result = manager.create_routes_for_project(
+            "test-project", sample_interface_configs
+        )
+
+        # Verify delegation with correct parameters
+        manager._route_service.create_routes_from_interfaces.assert_called_once_with(
+            "test-project", sample_interface_configs
+        )
+        assert result == expected_results
+
+    @patch("understack_workflows.netapp.manager.config")
+    @patch("understack_workflows.netapp.manager.HostConnection")
+    def test_create_routes_for_project_error_handling(
+        self,
+        mock_host_connection,
+        mock_config,
+        mock_config_file,
+        sample_interface_configs,
+    ):
+        """Test create_routes_for_project error handling and propagation."""
+        from understack_workflows.netapp.exceptions import NetworkOperationError
+
+        manager = NetAppManager(mock_config_file)
+
+        # Mock route service to raise an error
+        manager._route_service.create_routes_from_interfaces = MagicMock(
+            side_effect=NetworkOperationError("Route creation failed")
+        )
+
+        # Verify error is propagated
+        with pytest.raises(NetworkOperationError, match="Route creation failed"):
+            manager.create_routes_for_project("test-project", sample_interface_configs)
+
+        # Verify service was called
+        manager._route_service.create_routes_from_interfaces.assert_called_once_with(
+            "test-project", sample_interface_configs
+        )
+
+    @patch("understack_workflows.netapp.manager.config")
+    @patch("understack_workflows.netapp.manager.HostConnection")
+    def test_create_routes_for_project_logging(
+        self,
+        mock_host_connection,
+        mock_config,
+        mock_config_file,
+        sample_interface_configs,
+    ):
+        """Test create_routes_for_project logging behavior."""
+        from understack_workflows.netapp.value_objects import RouteResult
+
+        manager = NetAppManager(mock_config_file)
+
+        # Mock route service
+        expected_results = [
+            RouteResult(
+                uuid="route-uuid-1",
+                gateway="100.127.0.17",
+                destination="100.126.0.0/17",
+                svm_name="os-test-project",
+            ),
+        ]
+        manager._route_service.create_routes_from_interfaces = MagicMock(
+            return_value=expected_results
+        )
+
+        with patch("understack_workflows.netapp.manager.logger") as mock_logger:
+            result = manager.create_routes_for_project(
+                "test-project", sample_interface_configs
+            )
+
+            # Verify logging calls
+            mock_logger.info.assert_any_call(
+                "Creating routes for project %(project_id)s with %(count)d interfaces",
+                {"project_id": "test-project", "count": 3},
+            )
+            mock_logger.info.assert_any_call(
+                "Successfully created %(count)d routes for project %(project_id)s",
+                {"count": 1, "project_id": "test-project"},
+            )
+
+        assert result == expected_results
+
+    @patch("understack_workflows.netapp.manager.config")
+    @patch("understack_workflows.netapp.manager.HostConnection")
+    def test_create_routes_for_project_empty_interfaces(
+        self, mock_host_connection, mock_config, mock_config_file
+    ):
+        """Test create_routes_for_project with empty interface list."""
+        manager = NetAppManager(mock_config_file)
+
+        # Mock route service
+        manager._route_service.create_routes_from_interfaces = MagicMock(
+            return_value=[]
+        )
+
+        result = manager.create_routes_for_project("test-project", [])
+
+        # Verify delegation with empty list
+        manager._route_service.create_routes_from_interfaces.assert_called_once_with(
+            "test-project", []
+        )
+        assert result == []
+
+    @patch("understack_workflows.netapp.manager.config")
+    @patch("understack_workflows.netapp.manager.HostConnection")
+    def test_route_service_dependency_injection(
+        self, mock_host_connection, mock_config, mock_config_file
+    ):
+        """Test NetAppManager with injected RouteService dependency."""
+        from understack_workflows.netapp.route_service import RouteService
+
+        # Create mock dependencies
+        mock_client = MagicMock()
+        mock_error_handler = MagicMock()
+        mock_route_service = MagicMock(spec=RouteService)
+
+        manager = NetAppManager(
+            config_path=mock_config_file,
+            netapp_client=mock_client,
+            route_service=mock_route_service,
+            error_handler=mock_error_handler,
+        )
+
+        # Verify injected route service is used
+        assert manager._route_service is mock_route_service
+
+        # Test delegation works with injected service
+        mock_route_service.create_routes_from_interfaces.return_value = []
+        result = manager.create_routes_for_project("test-project", [])
+
+        mock_route_service.create_routes_from_interfaces.assert_called_once_with(
+            "test-project", []
+        )
+        assert result == []

python/understack-workflows/understack_workflows/netapp/manager.py

@@ -10,9 +10,11 @@
 from understack_workflows.netapp.config import NetAppConfig
 from understack_workflows.netapp.error_handler import ErrorHandler
 from understack_workflows.netapp.lif_service import LifService
+from understack_workflows.netapp.route_service import RouteService
 from understack_workflows.netapp.svm_service import SvmService
 from understack_workflows.netapp.value_objects import NetappIPInterfaceConfig
 from understack_workflows.netapp.value_objects import NodeResult
+from understack_workflows.netapp.value_objects import RouteResult
 from understack_workflows.netapp.volume_service import VolumeService
 
 logger = setup_logger(__name__)
@@ -35,6 +37,7 @@ def __init__(
         svm_service=None,
         volume_service=None,
         lif_service=None,
+        route_service=None,
         error_handler=None,
     ):
         """Initialize NetAppManager with dependency injection support.
@@ -46,6 +49,7 @@ def __init__(
             svm_service: SvmService instance (optional, for dependency injection)
             volume_service: VolumeService instance (optional, for dependency injection)
             lif_service: LifService instance (optional, for dependency injection)
+            route_service: RouteService instance (optional, for dependency injection)
             error_handler: ErrorHandler instance (optional, for dependency injection)
         """
         # Set up dependencies with dependency injection or create defaults
@@ -56,6 +60,7 @@ def __init__(
             svm_service,
             volume_service,
             lif_service,
+            route_service,
             error_handler,
         )
 
@@ -67,6 +72,7 @@ def _setup_dependencies(
         svm_service,
         volume_service,
         lif_service,
+        route_service,
         error_handler,
     ):
         """Set up all service dependencies with dependency injection."""
@@ -96,6 +102,7 @@ def _setup_dependencies(
             and svm_service is None
             and volume_service is None
             and lif_service is None
+            and route_service is None
         ):
             # Traditional constructor usage - set up connection directly
             # Check if connection needs to be established (handle both real and
@@ -145,6 +152,11 @@ def _setup_dependencies(
         else:
             self._lif_service = LifService(self._client, self._error_handler)
 
+        if route_service is not None:
+            self._route_service = route_service
+        else:
+            self._route_service = RouteService(self._client, self._error_handler)
+
     def create_svm(self, project_id: str, aggregate_name: str):
         """Creates a new Storage Virtual Machine (SVM)."""
         return self._svm_service.create_svm(project_id, aggregate_name)
@@ -447,6 +459,49 @@ def identify_home_node(self, config: NetappIPInterfaceConfig) -> NodeResult | No
         """
         return self._lif_service.identify_home_node(config)
 
+    def create_routes_for_project(
+        self,
+        project_id: str,
+        interface_configs: list[NetappIPInterfaceConfig],
+    ) -> list[RouteResult]:
+        """Create routes for a project based on interface configurations.
+
+        Args:
+            project_id: The project identifier
+            interface_configs: List of network interface configurations
+
+        Returns:
+            list[RouteResult]: List of created route results
+
+        Raises:
+            NetworkOperationError: If route creation fails
+        """
+        logger.info(
+            "Creating routes for project %(project_id)s with %(count)d interfaces",
+            {"project_id": project_id, "count": len(interface_configs)},
+        )
+
+        try:
+            results = self._route_service.create_routes_from_interfaces(
+                project_id, interface_configs
+            )
+
+            logger.info(
+                "Successfully created %(count)d routes for project %(project_id)s",
+                {"count": len(results), "project_id": project_id},
+            )
+
+            return results
+
+        except Exception as e:
+            logger.error(
+                "Failed to create routes for project %(project_id)s: %(error)s",
+                {"project_id": project_id, "error": str(e)},
+            )
+            # Re-raise the exception to ensure it propagates up the call stack
+            # This ensures route creation failures terminate script execution
+            raise
+
     def _svm_by_project(self, project_id):
         try:
             svm_name = self._svm_name(project_id)