Return resolution errors (#3402)

* Return resolution errors back to functions
* Don't skip pseudo parameters in satisfaction
* Update testing for validator resolution

Author: kddejong

src/cfnlint/conditions/conditions.py

@@ -19,7 +19,6 @@
 from cfnlint.conditions._equals import Equal, EqualParameter
 from cfnlint.conditions._errors import UnknownSatisfisfaction
 from cfnlint.conditions._utils import get_hash
-from cfnlint.helpers import PSEUDOPARAMS
 
 LOGGER = logging.getLogger(__name__)
 
@@ -371,20 +370,20 @@ def satisfiable(
 
         cnf = self._cnf.copy()
         at_least_one_param_found = False
+
         for condition_name, opt in conditions.items():
             for c_equals in self._conditions[condition_name].equals:
                 found_params = {}
                 for param, value in parameter_values.items():
-                    if param in PSEUDOPARAMS:
-                        continue
-
                     ref_hash = get_hash({"Ref": param})
+
                     for c_equal_param in c_equals.parameters:
                         if isinstance(c_equal_param, EqualParameter):
                             if c_equal_param.satisfiable is False:
                                 raise UnknownSatisfisfaction(
                                     f"Can't resolve satisfaction for {condition_name!r}"
                                 )
+
                     if ref_hash in c_equals.parameters:
                         found_params = {ref_hash: value}
 

src/cfnlint/jsonschema/validators.py

@@ -180,6 +180,8 @@ def resolve_value(self, instance: Any) -> ResolutionResult:
                         except UnknownSatisfisfaction as err:
                             LOGGER.debug(err)
                             return
+                    else:
+                        yield None, self, r_errs  # type: ignore
                 return
 
             # The return type is a Protocol and we are returning an instance

test/unit/module/jsonschema/test_validator_resolver.py

@@ -0,0 +1,56 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from collections import deque
+from typing import Any
+
+import pytest
+
+from cfnlint.jsonschema._resolvers_cfn import ResolutionResult, Validator
+from cfnlint.jsonschema.exceptions import ValidationError
+from cfnlint.jsonschema.validators import CfnTemplateValidator
+
+
+def _resolver(validator: Validator, instance: Any) -> ResolutionResult:
+    if instance == "fail":
+        yield None, validator, ValidationError("Foo")
+        return
+
+    yield "foo", validator, None
+
+
+@pytest.fixture
+def validator():
+    validator = CfnTemplateValidator({})
+    validator.fn_resolvers = {
+        "Ref": _resolver,
+    }
+    validator.context = validator.context.evolve(functions=["Ref"])
+    return validator
+
+
+@pytest.mark.parametrize(
+    "name,instance,expected",
+    [
+        (
+            "Valid with function",
+            {"Ref": "fail"},
+            [(None, ValidationError("Foo", path=deque(["Ref"])))],
+        ),
+        ("Valid string", "foo", [("foo", None)]),
+        ("Valid with function", {"Ref": "pass"}, [("foo", None)]),
+    ],
+)
+def test_validator_resolver(name, instance, expected, validator):
+    results = list(validator.resolve_value(instance))
+
+    if len(results) > len(expected):
+        for result, expected_result in zip(results, expected):
+            assert result[0] == expected_result[0]
+            assert result[2] == expected_result[1]
+    else:
+        for expected_result, result in zip(expected, results):
+            assert result[0] == expected_result[0]
+            assert result[2] == expected_result[1]

test/unit/rules/functions/test_find_in_map.py

@@ -147,6 +147,20 @@ def context(cfn):
                 ),
             ],
         ),
+        (
+            "Invalid Fn::FindInMap with a bad map key",
+            {"Fn::FindInMap": ["A", "C", "B"]},
+            {"type": "string"},
+            {"transforms": Transforms(["AWS::LanguageExtensions"])},
+            [ValidationError("Foo")],
+            [
+                ValidationError(
+                    "'C' is not one of ['B']",
+                    path=deque(["Fn::FindInMap", 1]),
+                    schema_path=deque([]),
+                ),
+            ],
+        ),
         (
             "Valid Fn::FindInMap with a Ref to AWS::NoValue",
             {