Gracefully exit of a override schema patch fails (#4134)

Author: kddejong

src/cfnlint/schema/manager.py

@@ -13,6 +13,7 @@
 import os
 import re
 import shutil
+import sys
 import zipfile
 from copy import copy
 from functools import lru_cache
@@ -562,7 +563,11 @@ def patch(self, patch: SchemaPatch, region: str) -> None:
             except ResourceNotFoundError:
                 # Resource type doesn't exist in this region
                 continue
-            schema.patch(patches=patches)
+            try:
+                schema.patch(patches=patches)
+            except Exception as e:
+                print(f"Error applying patch {patches} for {resource_type}: {e}")
+                sys.exit(1)
 
     @lru_cache(maxsize=None)
     def get_type_getatts(self, resource_type: str, region: str) -> AttributeDict:

src/cfnlint/schema/other_schema_manager.py

@@ -9,6 +9,7 @@
 import json
 import logging
 import os
+import sys
 from functools import lru_cache
 from typing import TYPE_CHECKING, Any
 
@@ -116,9 +117,13 @@ def patch(self, patch: SchemaPatch, region: str) -> None:
             except SchemaNotFoundError:
                 # Resource type doesn't exist in this region
                 continue
-            jsonpatch.JsonPatch(patches).apply(
-                self._schemas[schema_path], in_place=True
-            )
+            try:
+                jsonpatch.JsonPatch(patches).apply(
+                    self._schemas[schema_path], in_place=True
+                )
+            except Exception as e:
+                print(f"Error applying patch {patches} for {schema_path}: {e}")
+                sys.exit(1)
 
 
 OTHER_SCHEMA_MANAGER: OtherSchemaManager = OtherSchemaManager()

test/unit/module/schema/test_manager.py

@@ -289,3 +289,41 @@ def test_type_normalization(self):
         self.manager._registry_schemas[rt] = True
         schema = self.manager.get_resource_schema("us-east-1", rt)
         assert schema is True
+
+
+class TestManagerPatch(BaseTestCase):
+    """Test patching schemas"""
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.manager = ProviderSchemaManager()
+        self.schema_patch = [{"op": "add", "path": "/cfnSchema", "value": ["test"]}]
+
+    @patch("cfnlint.schema.manager.print")
+    @patch("cfnlint.schema.manager.sys.exit")
+    def test_patch_failure(self, mock_exit, mock_print):
+        """Test when patching a schema fails"""
+        # Create a mock schema that will raise an exception when patch is called
+        mock_schema = MagicMock()
+        mock_schema.patch.side_effect = Exception("Invalid patch operation")
+
+        # Mock get_resource_schema to return our mocked schema
+        self.manager.get_resource_schema = MagicMock(return_value=mock_schema)
+
+        # Create a patch
+        resource_type = "AWS::EC2::Instance"
+        patch = SchemaPatch([], [], {resource_type: self.schema_patch})
+
+        # Apply the patch
+        self.manager.patch(patch, "us-east-1")
+
+        # Verify that print was called with the error message
+        mock_print.assert_called_with(
+            (
+                f"Error applying patch {self.schema_patch} for "
+                f"{resource_type}: Invalid patch operation"
+            )
+        )
+
+        # Verify that sys.exit was called with exit code 1
+        mock_exit.assert_called_with(1)

test/unit/module/schema/test_other_schema_manager.py

@@ -107,6 +107,40 @@ def test_patch_schema_not_found(self, mock_json_patch, mock_load_resource):
         # Verify patch was not applied
         mock_patch.apply.assert_not_called()
 
+    @patch("cfnlint.schema.other_schema_manager.load_resource")
+    @patch("cfnlint.schema.other_schema_manager.jsonpatch.JsonPatch")
+    @patch("cfnlint.schema.other_schema_manager.sys.exit")
+    @patch("cfnlint.schema.other_schema_manager.print")
+    def test_patch_failure(
+        self, mock_print, mock_exit, mock_json_patch, mock_load_resource
+    ):
+        """Test when patching a schema fails"""
+        # Setup the schema to be loaded successfully
+        mock_load_resource.return_value = self.test_schema
+
+        # Setup the JsonPatch to raise an exception when apply is called
+        mock_patch = MagicMock()
+        mock_patch.apply.side_effect = Exception("Invalid patch operation")
+        mock_json_patch.return_value = mock_patch
+
+        # Create a patch
+        schema_path = "other.functions.join"
+        patch = SchemaPatch([], [], {schema_path: self.schema_patch})
+
+        # Apply the patch
+        self.manager.patch(patch, "us-east-1")
+
+        # Verify that print was called with the error message
+        mock_print.assert_called_with(
+            (
+                f"Error applying patch {self.schema_patch} for "
+                f"{schema_path}: Invalid patch operation"
+            )
+        )
+
+        # Verify that sys.exit was called with exit code 1
+        mock_exit.assert_called_with(1)
+
     @patch("cfnlint.schema.other_schema_manager.open", new_callable=mock_open)
     @patch("cfnlint.schema.other_schema_manager.os.walk")
     @patch("cfnlint.schema.other_schema_manager.os.path.join")