Fix issues with mapping values of 0 and AWS::NoValue (#3410)

* Fix issues with mapping values of 0 and AWS::NoValue
* Error when no mapping and no default value in findinmap

Author: kddejong

src/cfnlint/jsonschema/_resolvers_cfn.py

@@ -39,7 +39,7 @@ def find_in_map(validator: Validator, instance: Any) -> ResolutionResult:
     if len(instance) not in [3, 4]:
         return
 
-    default_value = None
+    default_value_found = None
     if len(instance) == 4:
         options = instance[3]
         if validator.is_type(options, "object"):
@@ -52,7 +52,16 @@ def find_in_map(validator: Validator, instance: Any) -> ResolutionResult:
                             )
                         ),
                     ), None
-                    default_value = value
+                default_value_found = True
+
+    if not default_value_found and not validator.context.mappings:
+        yield None, validator, ValidationError(
+            (
+                f"{instance[0]!r} is not one of "
+                f"{list(validator.context.mappings.keys())!r}"
+            ),
+            path=deque([0]),
+        )
 
     if (
         validator.is_type(instance[0], "string")
@@ -63,8 +72,8 @@ def find_in_map(validator: Validator, instance: Any) -> ResolutionResult:
         and validator.is_type(instance[2], "string")
     ):
         map = validator.context.mappings.get(instance[0])
-        if not map:
-            if not default_value:
+        if map is None:
+            if not default_value_found:
                 yield None, validator, ValidationError(
                     (
                         f"{instance[0]!r} is not one of "
@@ -75,8 +84,8 @@ def find_in_map(validator: Validator, instance: Any) -> ResolutionResult:
             return
 
         top_key = map.keys.get(instance[1])
-        if not top_key:
-            if not default_value:
+        if top_key is None:
+            if not default_value_found:
                 yield None, validator, ValidationError(
                     (
                         f"{instance[1]!r} is not one of "
@@ -88,9 +97,9 @@ def find_in_map(validator: Validator, instance: Any) -> ResolutionResult:
             return
 
         value = top_key.keys.get(instance[2])
-        if not value:
-            if not default_value:
-                yield default_value, validator, ValidationError(
+        if value is None:
+            if not default_value_found:
+                yield value, validator, ValidationError(
                     (
                         f"{instance[2]!r} is not one of "
                         f"{list(top_key.keys.keys())!r} for mapping "

test/unit/module/jsonschema/test_resolvers_cfn.py

@@ -182,7 +182,10 @@ def test_resolvers_ref(name, instance, response):
     ],
 )
 def test_invalid_functions(name, instance, response):
-    _resolve(name, instance, response)
+    context = Context()
+    context.mappings["foo"] = Map({"first": {"second": "bar"}})
+
+    _resolve(name, instance, response, context=context)
 
 
 @pytest.mark.parametrize(
@@ -221,6 +224,14 @@ def test_invalid_functions(name, instance, response):
             {"Fn::FindInMap": ["foo", "bar", "value", {"DefaultValue": "default"}]},
             [("default", deque([4, "DefaultValue"]), None)],
         ),
+        (
+            "Valid FindInMap with a default value",
+            {"Fn::FindInMap": ["foo", "first", "second", {"DefaultValue": "default"}]},
+            [
+                ("default", deque([4, "DefaultValue"]), None),
+                ("bar", deque([2]), None),
+            ],
+        ),
         (
             "Valid FindInMap with a bad mapping",
             {"Fn::FindInMap": ["bar", "first", "second"]},
@@ -240,6 +251,18 @@ def test_invalid_functions(name, instance, response):
             {"Fn::FindInMap": ["bar", "first", "second", {"DefaultValue": "default"}]},
             [("default", deque([4, "DefaultValue"]), None)],
         ),
+        (
+            "Valid FindInMap with a bad mapping and aws no value",
+            {
+                "Fn::FindInMap": [
+                    "bar",
+                    "first",
+                    "second",
+                    {"DefaultValue": {"Ref": "AWS::NoValue"}},
+                ]
+            },
+            [],
+        ),
         (
             "Valid FindInMap with a bad top key",
             {"Fn::FindInMap": ["foo", "second", "first"]},
@@ -298,3 +321,31 @@ def test_valid_functions(name, instance, response):
     context.mappings["foo"] = Map({"first": {"second": "bar"}})
 
     _resolve(name, instance, response, context=context)
+
+
+@pytest.mark.parametrize(
+    "name,instance,response",
+    [
+        (
+            "Invalid FindInMap with no mappings",
+            {"Fn::FindInMap": [{"Ref": "MyParameter"}, "B", "C"]},
+            [
+                (
+                    None,
+                    deque([]),
+                    ValidationError(
+                        ("{'Ref': 'MyParameter'} is not one of []"),
+                        path=deque(["Fn::FindInMap", 0]),
+                    ),
+                )
+            ],
+        ),
+        (
+            "Invalid FindInMap with no mappings and default value",
+            {"Fn::FindInMap": ["A", "B", "C", {"DefaultValue": "default"}]},
+            [("default", deque([4, "DefaultValue"]), None)],
+        ),
+    ],
+)
+def test_no_mapping(name, instance, response):
+    _resolve(name, instance, response)