Add files using upload-large-folder tool

testbed/aws-cloudformation__cfn-lint/.git-blame-ignore-revs

@@ -0,0 +1,3 @@
+# Add in isort and ran on src/ and test/
+# Run black with double quotes on all files
+dfdc6f924628f74de71182d25a629f568ebccb0f

testbed/aws-cloudformation__cfn-lint/.gitignore

@@ -0,0 +1,123 @@
+# Auto generated files for testing
+test/fixtures/templates/bad/limit_numbers.yaml
+test/fixtures/templates/bad/limit_size.yaml
+
+# Local files for Build and Release
+Dockerfile.local
+create-release.sh
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+.pytest_cache/
+.ruff_cache/
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+.static_storage/
+.media/
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# vscode
+.vscode/
+
+# osx
+.DS_Store
+
+# Pycharm
+.idea/

testbed/aws-cloudformation__cfn-lint/src/cfnlint/__init__.py

@@ -0,0 +1,14 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import logging
+
+from cfnlint.api import lint, lint_all
+from cfnlint.config import ConfigMixIn, ManualArgs
+from cfnlint.rules import Rules
+from cfnlint.template import Template
+from cfnlint.template.transforms import Transform
+
+LOGGER = logging.getLogger(__name__)

testbed/aws-cloudformation__cfn-lint/src/cfnlint/_typing.py

@@ -0,0 +1,16 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from typing import TYPE_CHECKING, Any, List, Protocol, Union
+
+if TYPE_CHECKING:
+    from cfnlint.rules import RuleMatch
+
+RuleMatches = List["RuleMatch"]
+Path = List[Union[str, int]]
+
+
+class CheckValueFn(Protocol):
+    def __call__(self, value: Any, path: Path, **kwargs: Any) -> List["RuleMatch"]: ...

testbed/aws-cloudformation__cfn-lint/src/cfnlint/api.py

@@ -0,0 +1,84 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+from typing import List
+
+from cfnlint.config import ConfigMixIn, ManualArgs
+from cfnlint.decode.decode import decode_str
+from cfnlint.helpers import REGION_PRIMARY, REGIONS
+from cfnlint.rules import Match, RulesCollection
+from cfnlint.runner import Runner, TemplateRunner
+
+Matches = List[Match]
+
+
+def lint(
+    s: str,
+    rules: RulesCollection | None = None,
+    regions: list[str] | None = None,
+    config: ManualArgs | None = None,
+) -> list[Match]:
+    """Validate a string template using the specified rules and regions.
+
+    Parameters
+    ----------
+    s : str
+        the template string
+    rules : RulesCollection
+        The rules to run against s
+    regions : list[str]
+        The regions to test against s
+
+    Returns
+    -------
+    list
+        a list of errors if any were found, else an empty list
+    """
+    template, errors = decode_str(s)
+    if errors:
+        return errors
+
+    if template is None:
+        return []
+
+    if not regions:
+        regions = [REGION_PRIMARY]
+
+    if not config:
+        config_mixin = ConfigMixIn(
+            regions=regions,
+        )
+    else:
+        config_mixin = ConfigMixIn(**config)
+
+    if isinstance(rules, RulesCollection):
+        template_runner = TemplateRunner(None, template, config_mixin, rules)  # type: ignore # noqa: E501
+        return list(template_runner.run())
+
+    runner = Runner(config_mixin)
+    return list(runner.validate_template(None, template))
+
+
+def lint_all(s: str) -> list[Match]:
+    """Validate a string template against all regions and rules.
+
+    Parameters
+    ----------
+    s : str
+        the template string
+
+    Returns
+    -------
+    list
+        a list of errors if any were found, else an empty list
+    """
+    return lint(
+        s=s,
+        config=ManualArgs(
+            include_checks=["I"], include_experimental=True, regions=REGIONS
+        ),
+    )

testbed/aws-cloudformation__cfn-lint/src/cfnlint/conditions/__init__.py

@@ -0,0 +1,9 @@
+"""
+Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+__all__ = ["Conditions"]
+
+from cfnlint.conditions._errors import UnknownSatisfisfaction
+from cfnlint.conditions.conditions import Conditions

testbed/aws-cloudformation__cfn-lint/src/cfnlint/conditions/_condition.py

@@ -0,0 +1,250 @@
+"""
+Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Mapping, Sequence, Union
+
+from sympy import And, Not, Or, Symbol
+from sympy.logic.boolalg import BooleanFunction, BooleanTrue
+
+from cfnlint.conditions._equals import Equal
+from cfnlint.helpers import FUNCTION_CONDITIONS
+
+# we leave the type hinting here
+_CONDITION = Dict[str, Union[str, Sequence["_CONDITION"]]]
+
+
+class Condition:
+    """The generic class to represent any type of Condition"""
+
+    def __init__(self) -> None:
+        self._fn_equals: Equal | None = None
+        self._condition: ConditionList | ConditionNamed | None = None
+
+    def _init_condition(
+        self,
+        condition: _CONDITION,
+        all_conditions: dict[str, dict],
+    ) -> None:
+        if len(condition) == 1:
+            for k, v in condition.items():
+                if k in FUNCTION_CONDITIONS:
+                    if not isinstance(v, list):
+                        raise ValueError(f"{k} value should be an array")
+                    if k == "Fn::Equals":
+                        self._fn_equals = Equal(v)
+                    elif k == "Fn::And":
+                        self._condition = ConditionAnd(v, all_conditions)
+                    elif k == "Fn::Or":
+                        self._condition = ConditionOr(v, all_conditions)
+                    elif k == "Fn::Not":
+                        self._condition = ConditionNot(v, all_conditions)
+                elif k == "Condition":
+                    if not isinstance(v, str):
+                        raise ValueError(f"Condition value {v!r} must be a string")
+                    self._condition = ConditionNamed(v, all_conditions)
+                else:
+                    raise ValueError(f"Unknown key ({k}) in condition")
+        else:
+            raise ValueError("Condition value must be an object of length 1")
+
+    @property
+    def equals(self) -> list[Equal]:
+        """Returns a Sequence of the Equals that make up the Condition
+
+        Args: None
+
+        Returns:
+            Sequence[EqualParameter] | Sequence[Equal] | None:
+                The Equal that are part of the condition
+        """
+        if self._fn_equals:
+            return [self._fn_equals]
+        if self._condition:
+            return self._condition.equals
+        return []
+
+    def build_cnf(self, params: dict[str, Symbol]) -> BooleanFunction | Symbol | None:
+        """Build a SymPy CNF based on the provided params
+
+        Args:
+            params dict[str, Symbol]: params is a dict that represents
+                    the hash of an Equal and the SymPy Symbols
+
+        Returns:
+            Any: Any number of different SymPy CNF clauses
+        """
+        if self._condition:
+            return self._condition.build_cnf(params)
+        if self._fn_equals:
+            return self._fn_equals.build_cnf(params)
+        return BooleanTrue()
+
+    def _test(self, scenarios: Mapping[str, str]) -> bool:
+        if self._fn_equals:
+            return self._fn_equals.test(scenarios)
+        if self._condition:
+            # pylint: disable=W0212
+            return self._condition._test(scenarios)
+        return False
+
+
+class ConditionList(Condition):
+    """The generic class to represent any type of List condition
+    List conditions are And, Or, Not
+    """
+
+    def __init__(
+        self, conditions: Sequence[_CONDITION], all_conditions: dict[str, dict]
+    ) -> None:
+        super().__init__()
+        self._conditions: list[ConditionUnnammed] = []
+        self._prefix_path: str = ""
+        for condition in conditions:
+            self._conditions.append(ConditionUnnammed(condition, all_conditions))
+
+    @property
+    def equals(self) -> list[Equal]:
+        """Returns a List of the Equals that make up the Condition
+
+        Args: None
+
+        Returns:
+            list[Equal]: The Equal that are part of the condition
+        """
+        equals: list[Equal] = []
+        for condition in self._conditions:
+            equals.extend(condition.equals)
+        return equals
+
+
+class ConditionAnd(ConditionList):
+    """Represents the logic specific to an And Condition"""
+
+    def __init__(
+        self, conditions: Sequence[_CONDITION], all_conditions: dict[str, dict]
+    ) -> None:
+        super().__init__(conditions, all_conditions)
+        self._prefix_path = "Fn::And"
+
+    def build_cnf(self, params: dict[str, Symbol]) -> BooleanFunction:
+        """Build a SymPy CNF solver based on the provided params
+        Args:
+            params dict[str, Symbol]: params is a dict that represents
+                    the hash of an Equal and the SymPy Symbols
+        Returns:
+            BooleanFunction: An And SymPy BooleanFunction
+        """
+        conditions: list[Any] = []
+        for child in self._conditions:
+            conditions.append(child.build_cnf(params))
+
+        return And(*conditions)
+
+    def _test(self, scenarios: Mapping[str, str]) -> bool:
+        # pylint: disable=W0212
+        return all(condition._test(scenarios) for condition in self._conditions)
+
+
+class ConditionNot(ConditionList):
+    """Represents the logic specific to an Not Condition"""
+
+    def __init__(
+        self, conditions: Sequence[_CONDITION], all_conditions: dict[str, dict]
+    ) -> None:
+        super().__init__(conditions, all_conditions)
+        self._prefix_path = "Fn::Not"
+        if len(conditions) != 1:
+            raise ValueError("Condition length must be 1")
+
+    def build_cnf(self, params: dict[str, Symbol]) -> BooleanFunction:
+        """Build a SymPy CNF solver based on the provided params
+        Args:
+            params dict[str, Symbol]: params is a dict that represents
+                    the hash of an Equal and the SymPy Symbol
+        Returns:
+            BooleanFunction: A Not SymPy BooleanFunction
+        """
+        return Not(self._conditions[0].build_cnf(params))
+
+    def _test(self, scenarios: Mapping[str, str]) -> bool:
+        # pylint: disable=W0212
+        return not any(condition._test(scenarios) for condition in self._conditions)
+
+
+class ConditionOr(ConditionList):
+    """Represents the logic specific to an Or Condition"""
+
+    def __init__(
+        self, conditions: Sequence[_CONDITION], all_conditions: dict[str, dict]
+    ) -> None:
+        super().__init__(conditions, all_conditions)
+        self._prefix_path = "Fn::Or"
+
+    def build_cnf(self, params: dict[str, Symbol]) -> BooleanFunction:
+        """Build a SymPy CNF solver based on the provided params
+        Args:
+            params dict[str, Symbol]: params is a dict that represents
+                    the hash of an Equal and the SymPy Symbols
+        Returns:
+            BooleanFunction: An Or SymPy BooleanFunction
+        """
+        conditions: list[Any] = []
+        for child in self._conditions:
+            conditions.append(child.build_cnf(params))
+        return Or(*conditions)
+
+    def _test(self, scenarios: Mapping[str, str]) -> bool:
+        # pylint: disable=W0212
+        return any(condition._test(scenarios) for condition in self._conditions)
+
+
+class ConditionUnnammed(Condition):
+    """Represents an unnamed condition which is basically a nested Equals"""
+
+    def __init__(self, condition: Any, all_conditions: dict[str, dict]) -> None:
+        super().__init__()
+        if isinstance(condition, dict):
+            self._init_condition(condition, all_conditions)
+        else:
+            raise ValueError("Condition must have a value that is an object")
+
+
+class ConditionNamed(Condition):
+    """The parent condition that directly represents a named condition in a template"""
+
+    def __init__(self, name: str, all_conditions: dict[str, dict]) -> None:
+        super().__init__()
+        condition = all_conditions.get(name)
+        if isinstance(condition, dict):
+            self._name = name
+            self._init_condition(condition, all_conditions)
+        else:
+            raise ValueError(f"Condition {name} must have a value that is an object")
+
+    def build_true_cnf(self, params: dict[str, Symbol]) -> Any:
+        """Build a SymPy CNF for a True based scenario
+        Args:
+            params dict[str, Symbol]: params is a dict that represents
+                    the hash of an Equal and the SymPy Symbols
+        Returns:
+            Any: A SymPy CNF clause
+        """
+        return self.build_cnf(params)
+
+    def build_false_cnf(self, params: dict[str, Symbol]) -> Any:
+        """Build a SymPy CNF for a False based scenario
+        Args:
+            params dict[str, Symbol]: params is a dict that represents
+                    the hash of an Equal and the SymPy CNF Symbols
+        Returns:
+            Any: A Not SymPy CNF clause
+        """
+        return Not(self.build_true_cnf(params))
+
+    def test(self, scenarios: Mapping[str, str]) -> bool:
+        """Test a condition based on a scenario"""
+        return self._test(scenarios)

testbed/aws-cloudformation__cfn-lint/src/cfnlint/conditions/_equals.py

@@ -0,0 +1,177 @@
+"""
+Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, Mapping, Tuple
+
+from sympy import Symbol
+from sympy.logic.boolalg import BooleanFalse, BooleanTrue
+
+from cfnlint.conditions._utils import get_hash
+from cfnlint.helpers import is_function
+
+LOGGER = logging.getLogger(__name__)
+REF_REGION = get_hash({"Ref": "AWS::Region"})
+
+
+class EqualParameter:
+    hash: str = ""
+
+    def __init__(self, value: dict):
+        self._value = value
+        k, _ = is_function(value)
+
+        # we can only do satisfaction validation
+        # on Refs currently
+        if k not in ["Ref"]:
+            self._satisfiable = False
+        else:
+            self._satisfiable = True
+
+        self.hash: str = get_hash(value)
+
+    def __eq__(self, __o: Any):
+        if isinstance(__o, str):
+            return self.hash == __o
+        return self.hash == __o.hash
+
+    @property
+    def satisfiable(self) -> bool:
+        """Returns a boolean value if the parameter can be True or False
+
+        Args: None
+
+        Returns:
+            bool: True if the parameter can be True or False, False otherwise
+        """
+        return self._satisfiable
+
+
+class Equal:
+    hash: str
+    _left: EqualParameter | str
+    _right: EqualParameter | str
+    _is_static: bool | None
+    _is_region: Tuple[bool, str]
+
+    def __init__(self, equal: list[str | dict]) -> None:
+        self._is_static = None
+        if isinstance(equal, list) and len(equal) == 2:
+            # sort to keep consistancy from random ordering
+            # pylint: disable=unnecessary-lambda
+            equal_s = sorted(equal, key=lambda value: json.dumps(value))
+
+            self._left = self._init_parameter(equal_s[0])
+            self._right = self._init_parameter(equal_s[1])
+
+            self.hash = get_hash([self._left, self._right])
+            if isinstance(self._left, str) and isinstance(self._right, str):
+                self._is_static = self._left == self._right
+            elif isinstance(self._left, EqualParameter) and isinstance(
+                self._right, EqualParameter
+            ):
+                if self._left == self._right:
+                    self._is_static = True
+
+            self._is_region = (False, "")
+            if isinstance(self._left, EqualParameter):
+                if self._left.hash == REF_REGION and isinstance(self._right, str):
+                    self._is_region = (True, self._right)
+            if isinstance(self._right, EqualParameter):
+                if self._right.hash == REF_REGION and isinstance(self._left, str):
+                    self._is_region = (True, self._left)
+
+            return
+        raise ValueError("Equals has to be a list of two values")
+
+    def _init_parameter(self, parameter: dict[str, Any] | str) -> EqualParameter | str:
+        if isinstance(parameter, dict):
+            return EqualParameter(parameter)
+        return str(parameter)
+
+    @property
+    def is_static(self) -> bool | None:
+        """Returns a boolean value if the result is always True or False or None if
+            it isn't a static boolean
+
+        Args: None
+
+        Returns:
+            bool | None: None if the equals can be True or False or True/False if
+            the equals will always return the same result
+        """
+        return self._is_static
+
+    @property
+    def parameters(self) -> list[EqualParameter]:
+        """Returns a List of the EqualParameter that make up the Condition
+
+        Args: None
+
+        Returns:
+            list[Equal]: A list of the left and right equal parameters if they are
+                         of type EqualParameter
+        """
+        params = []
+        if isinstance(self._left, EqualParameter):
+            params.append(self._left)
+        if isinstance(self._right, EqualParameter):
+            params.append(self._right)
+        return params
+
+    @property
+    def is_region(self) -> Tuple[bool, str]:
+        """Returns a Tuple if the condition is comparing a region to a string
+
+        Args: None
+
+        Returns:
+            Tuple[bool, str]: Tuple where the boolean is True if the condition
+              is using Ref: AWS::Region and the second element is for the region
+              being compared
+        """
+        return self._is_region
+
+    @property
+    def left(self):
+        return self._left
+
+    @property
+    def right(self):
+        return self._right
+
+    def build_cnf(
+        self, params: dict[str, Symbol]
+    ) -> BooleanTrue | BooleanFalse | Symbol:
+        """Build a SymPy CNF solver based on the provided params
+        Args:
+            params dict[str, Symbol]: params is a dict that represents
+                    the hash of an Equal and the SymPy Symbol
+        Returns:
+            BooleanFunction: A Not SymPy BooleanFunction
+        """
+        if self._is_static is not None:
+            if self._is_static:
+                return BooleanTrue()
+            return BooleanFalse()
+
+        return params.get(self.hash, Symbol(self.hash))
+
+    def test(self, scenarios: Mapping[str, str]) -> bool:
+        """Do an equals based on the provided scenario"""
+        if self._is_static in [True, False]:
+            return self._is_static
+        for scenario, value in scenarios.items():
+            if isinstance(self._left, EqualParameter):
+                if scenario == self._left:
+                    return value == self._right
+            if isinstance(self._right, EqualParameter):
+                if scenario == self._right:
+                    return value == self._left
+
+        raise ValueError("An appropriate scenario was not found")

testbed/aws-cloudformation__cfn-lint/src/cfnlint/conditions/_errors.py

@@ -0,0 +1,13 @@
+"""
+Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from typing import Any
+
+
+class UnknownSatisfisfaction(Exception):
+    """Unknown Satisfisfaction Exception"""
+
+    def __init__(self, message: str, **kwargs: Any):
+        super().__init__(message, **kwargs)

testbed/aws-cloudformation__cfn-lint/src/cfnlint/conditions/_rule.py

@@ -0,0 +1,148 @@
+"""
+Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict
+
+from sympy import And, Implies, Symbol
+from sympy.logic.boolalg import BooleanFunction, BooleanTrue
+
+from cfnlint.conditions._condition import (
+    ConditionAnd,
+    ConditionList,
+    ConditionNamed,
+    ConditionNot,
+    ConditionOr,
+)
+from cfnlint.conditions._equals import Equal
+from cfnlint.helpers import FUNCTION_CONDITIONS
+
+LOGGER = logging.getLogger(__name__)
+
+# we leave the type hinting here
+_RULE = Dict[str, Any]
+
+
+class _Assertion:
+    def __init__(self, condition: Any, all_conditions: dict[str, dict]) -> None:
+        self._fn_equals: Equal | None = None
+        self._condition: ConditionList | ConditionNamed | None = None
+
+        if len(condition) == 1:
+            for k, v in condition.items():
+                if k in FUNCTION_CONDITIONS:
+                    if not isinstance(v, list):
+                        raise ValueError(f"{k} value should be an array")
+                    if k == "Fn::Equals":
+                        self._fn_equals = Equal(v)
+                    elif k == "Fn::And":
+                        self._condition = ConditionAnd(v, all_conditions)
+                    elif k == "Fn::Or":
+                        self._condition = ConditionOr(v, all_conditions)
+                    elif k == "Fn::Not":
+                        self._condition = ConditionNot(v, all_conditions)
+                elif k == "Condition":
+                    if not isinstance(v, str):
+                        raise ValueError(f"Condition value {v!r} must be a string")
+                    self._condition = ConditionNamed(v, all_conditions)
+                else:
+                    raise ValueError(f"Unknown key ({k}) in condition")
+        else:
+            raise ValueError("Condition value must be an object of length 1")
+
+    def build_cnf(self, params: dict[str, Symbol]) -> BooleanFunction | Symbol | None:
+        if self._fn_equals:
+            try:
+                return self._fn_equals.build_cnf(params)
+            except Exception as e:
+                LOGGER.debug(f"Error building condition: {e}")
+
+        if self._condition:
+            try:
+                return self._condition.build_cnf(params)
+            except Exception as e:
+                LOGGER.debug(f"Error building condition: {e}")
+
+        return BooleanTrue()
+
+    @property
+    def equals(self) -> list[Equal]:
+        if self._fn_equals:
+            return [self._fn_equals]
+        if self._condition:
+            return self._condition.equals
+        return []
+
+
+class _Assertions:
+    def __init__(self, assertions: list[dict], all_conditions: dict[str, dict]) -> None:
+        self._assertions: list[_Assertion] = []
+        for assertion in assertions:
+            assert_ = assertion.get("Assert", {})
+            self._assertions.append(_Assertion(assert_, all_conditions))
+
+    def build_cnf(self, params: dict[str, Symbol]) -> BooleanFunction | Symbol | None:
+
+        assertions = []
+        for assertion in self._assertions:
+            assertions.append(assertion.build_cnf(params))
+
+        try:
+            return And(*assertions)
+        except Exception as e:
+            LOGGER.debug(f"Error building conditions: {e}")
+            return BooleanTrue()
+
+    @property
+    def equals(self) -> list[Equal]:
+
+        results = []
+        for assertion in self._assertions:
+            results.extend(assertion.equals)
+        return results
+
+
+class Rule:
+
+    def __init__(self, rule: _RULE, all_conditions: dict[str, dict]) -> None:
+        self._condition: _Assertion | None = None
+        self._assertions: _Assertions | None = None
+        self._init_rule(rule, all_conditions)
+
+    def _init_rule(
+        self,
+        rule: _RULE,
+        all_conditions: dict[str, dict],
+    ) -> None:
+        condition = rule.get("RuleCondition")
+        if condition:
+            self._condition = _Assertion(condition, all_conditions)
+
+        assertions = rule.get("Assertions")
+        if not assertions:
+            raise ValueError("Rule must have Assertions")
+        self._assertions = _Assertions(assertions, all_conditions)
+
+    @property
+    def equals(self) -> list[Equal]:
+        result = []
+        if self._condition:
+            result.extend(self._condition.equals)
+        if self._assertions:
+            result.extend(self._assertions.equals)
+        return result
+
+    def build_cnf(self, params: dict[str, Symbol]) -> BooleanFunction | Symbol | None:
+
+        if self._assertions:
+            if self._condition:
+                return Implies(
+                    self._condition.build_cnf(params),
+                    self._assertions.build_cnf(params),
+                )
+            return self._assertions.build_cnf(params)
+        return None

testbed/aws-cloudformation__cfn-lint/src/cfnlint/conditions/_utils.py

@@ -0,0 +1,22 @@
+"""
+Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import hashlib
+import json
+
+
+class ObjectEncoder(json.JSONEncoder):
+    def default(self, o):
+        if hasattr(o, "_value"):
+            # pylint: disable=protected-access
+            return o._value
+        return o
+
+
+def get_hash(o):
+    """Return a hash of an object"""
+    return hashlib.sha1(
+        json.dumps(o, sort_keys=True, cls=ObjectEncoder).encode("utf-8")
+    ).hexdigest()

testbed/aws-cloudformation__cfn-lint/src/cfnlint/conditions/conditions.py

@@ -0,0 +1,460 @@
+"""
+Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import itertools
+import logging
+import traceback
+from functools import lru_cache
+from typing import Any, Iterator, Set, Tuple
+
+from sympy import And, Implies, Not, Symbol
+from sympy.assumptions.cnf import EncodedCNF
+from sympy.logic.boolalg import BooleanFalse, BooleanTrue
+from sympy.logic.inference import satisfiable
+
+from cfnlint.conditions._condition import ConditionNamed
+from cfnlint.conditions._equals import Equal, EqualParameter
+from cfnlint.conditions._errors import UnknownSatisfisfaction
+from cfnlint.conditions._rule import Rule
+from cfnlint.conditions._utils import get_hash
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Conditions:
+    """Conditions provides the logic for relating individual condition together"""
+
+    _max_scenarios: int = 128  # equivalent to 2^7
+
+    def __init__(self, cfn) -> None:
+        self._conditions: dict[str, ConditionNamed] = {}
+        self._parameters: dict[str, list[str]] = {}
+        self._rules: list[Rule] = []
+        self._init_conditions(cfn=cfn)
+        self._init_parameters(cfn=cfn)
+        self._init_rules(cfn=cfn)
+        self._cnf, self._solver_params = self._build_cnf(list(self._conditions.keys()))
+
+    def _init_conditions(self, cfn):
+        conditions = cfn.template.get("Conditions")
+        if isinstance(conditions, dict):
+            for k, _ in conditions.items():
+                try:
+                    self._conditions[k] = ConditionNamed(k, conditions)
+                except ValueError as e:
+                    LOGGER.debug(
+                        "Captured error while building condition %s: %s", k, str(e)
+                    )
+                except Exception as e:  # pylint: disable=broad-exception-caught
+                    if LOGGER.getEffectiveLevel() == logging.DEBUG:
+                        error_message = traceback.format_exc()
+                    else:
+                        error_message = str(e)
+                    LOGGER.debug(
+                        "Captured unknown error while building condition %s: %s",
+                        k,
+                        error_message,
+                    )
+
+    def _init_parameters(self, cfn: Any) -> None:
+        parameters = cfn.template.get("Parameters")
+        if not isinstance(parameters, dict):
+            return
+        for parameter_name, parameter in parameters.items():
+            if not isinstance(parameter, dict):
+                continue
+            allowed_values = parameter.get("AllowedValues")
+            if not allowed_values or not isinstance(allowed_values, list):
+                continue
+
+            param_hash = get_hash({"Ref": parameter_name})
+            self._parameters[param_hash] = []
+            for allowed_value in allowed_values:
+                if isinstance(allowed_value, (str, int, float, bool)):
+                    self._parameters[param_hash].append(get_hash(str(allowed_value)))
+
+    def _init_rules(self, cfn: Any) -> None:
+        rules = cfn.template.get("Rules")
+        conditions = cfn.template.get("Conditions", {})
+        if not isinstance(rules, dict) or not isinstance(conditions, dict):
+            return
+        for k, v in rules.items():
+            if not isinstance(v, dict):
+                continue
+            try:
+                self._rules.append(Rule(v, conditions))
+            except ValueError as e:
+                LOGGER.debug("Captured error while building rule %s: %s", k, str(e))
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                if LOGGER.getEffectiveLevel() == logging.DEBUG:
+                    error_message = traceback.format_exc()
+                else:
+                    error_message = str(e)
+                LOGGER.debug(
+                    "Captured unknown error while building rule %s: %s",
+                    k,
+                    error_message,
+                )
+
+    def get(self, name: str, default: Any = None) -> ConditionNamed:
+        """Return the conditions"""
+        return self._conditions.get(name, default)
+
+    def _build_cnf(
+        self, condition_names: list[str]
+    ) -> Tuple[EncodedCNF, dict[str, Any]]:
+        cnf = EncodedCNF()
+
+        # build parameters and equals into solver
+        equal_vars: dict[str, Symbol | BooleanFalse | BooleanTrue] = {}
+
+        equals: dict[str, Equal] = {}
+
+        def _build_equal_vars(c_equals: list[Equal]):
+            for c_equal in c_equals:
+                if c_equal.hash in equal_vars:
+                    continue
+
+                if c_equal.is_static is not None:
+                    if c_equal.is_static:
+                        equal_vars[c_equal.hash] = BooleanTrue()
+                    else:
+                        equal_vars[c_equal.hash] = BooleanFalse()
+                else:
+                    equal_vars[c_equal.hash] = Symbol(c_equal.hash)
+                    # See if parameter in this equals is the same as another equals
+                    for param in c_equal.parameters:
+                        for e_hash, e_equals in equals.items():
+                            if param in e_equals.parameters:
+                                # equivalent to NAND logic. We want to make
+                                # sure that both equals are not both True
+                                # at the same time
+                                cnf.add_prop(
+                                    ~(equal_vars[c_equal.hash] & equal_vars[e_hash])
+                                )
+                equals[c_equal.hash] = c_equal
+
+        for rule in self._rules:
+            _build_equal_vars(rule.equals)
+
+        for condition_name in condition_names:
+            _build_equal_vars(self._conditions[condition_name].equals)
+
+        # Determine if a set of conditions can never be all false
+        allowed_values = self._parameters.copy()
+        if allowed_values:
+            # iteration 1 cleans up all the hash values
+            # from allowed_values to know if we
+            # used them all
+            for _, equal_1 in equals.items():
+                for param in equal_1.parameters:
+                    if param.hash not in allowed_values:
+                        continue
+                    if isinstance(equal_1.left, str):
+                        if get_hash(equal_1.left) in allowed_values[param.hash]:
+                            allowed_values[param.hash].remove(get_hash(equal_1.left))
+                        else:
+                            equal_vars[equal_1.hash] = BooleanFalse()
+                    if isinstance(equal_1.right, str):
+                        if get_hash(equal_1.right) in allowed_values[param.hash]:
+                            allowed_values[param.hash].remove(get_hash(equal_1.right))
+                        else:
+                            equal_vars[equal_1.hash] = BooleanFalse()
+
+            # iteration 2 builds the cnf formulas to make sure any empty lists
+            # are now full not equals
+            for allowed_hash, allowed_value in allowed_values.items():
+                # means the list is empty and all allowed values are validated
+                # so not all equals can be false
+                if not allowed_value:
+                    prop = None
+                    for _, equal_1 in equals.items():
+                        for param in equal_1.parameters:
+                            if allowed_hash == param.hash:
+                                if prop is None:
+                                    prop = Not(equal_vars[equal_1.hash])
+                                else:
+                                    prop = prop & Not(equal_vars[equal_1.hash])
+                    # Need to make sure they aren't all False
+                    # So Not(Not(Equal1) & Not(Equal2))
+                    # When Equal1 False and Equal2 False
+                    # Not(True & True) = False allowing this not to happen
+                    if prop is not None:
+                        cnf.add_prop(Not(prop))
+
+        for rule in self._rules:
+            cnf.add_prop(rule.build_cnf(equal_vars))
+
+        return (cnf, equal_vars)
+
+    def build_scenarios(
+        self, conditions: dict[str, Set[bool]], region: str | None = None
+    ) -> Iterator[dict[str, bool]]:
+        """Given a list of condition names this function will
+        yield scenarios that represent those conditions and
+        there result (True/False)
+
+        Args:
+            condition_names (list[str]): A list of condition names
+
+        Returns:
+            Iterator[dict[str, bool]]: yield dict objects of {ConditionName: True/False}
+        """
+        # nothing to yield if there are no conditions
+        if len(conditions) == 0:
+            return
+
+        c_cnf = self._cnf.copy()
+        condition_names = []
+        conditions_set = {}
+        for condition_name, values in conditions.items():
+            if condition_name in self._conditions:
+                if values == {True}:
+                    c_cnf.add_prop(
+                        self._conditions[condition_name].build_true_cnf(
+                            self._solver_params
+                        )
+                    )
+                    conditions_set[condition_name] = True
+                    continue
+                if values == {False}:
+                    c_cnf.add_prop(
+                        self._conditions[condition_name].build_false_cnf(
+                            self._solver_params
+                        )
+                    )
+                    conditions_set[condition_name] = False
+                    continue
+            condition_names.append(condition_name)
+
+        try:
+            # build a large matric of True/False options
+            # based on the provided conditions
+            scenarios_attempted = 0
+            if region:
+                products = itertools.starmap(
+                    self.build_scenerios_on_region,
+                    itertools.product(condition_names, [region]),
+                )
+            else:
+                products = itertools.product([True, False], repeat=len(condition_names))  # type: ignore
+
+            for p in products:
+                cnf = c_cnf.copy()
+                params = dict(zip(condition_names, p))
+                for condition_name, opt in params.items():
+                    if opt:
+                        cnf.add_prop(
+                            self._conditions[condition_name].build_true_cnf(
+                                self._solver_params
+                            )
+                        )
+                    else:
+                        cnf.add_prop(
+                            self._conditions[condition_name].build_false_cnf(
+                                self._solver_params
+                            )
+                        )
+
+                # if the scenario can be satisfied then return it
+                if satisfiable(cnf):
+                    yield {**params, **conditions_set}
+
+                scenarios_attempted += 1
+                # On occassions people will use a lot of non-related conditions
+                # this is fail safe to limit the maximum number of responses
+                if scenarios_attempted >= self._max_scenarios:
+                    return
+        except KeyError:
+            # KeyError is because the listed condition doesn't exist because of bad
+            #  formatting or just the wrong condition name
+            return
+
+    def _build_cfn_implies(self, scenarios) -> And:
+        conditions = []
+        for condition_name, opt in scenarios.items():
+            if opt:
+                conditions.append(
+                    self._conditions[condition_name].build_true_cnf(self._solver_params)
+                )
+            else:
+                conditions.append(
+                    self._conditions[condition_name].build_false_cnf(
+                        self._solver_params
+                    )
+                )
+
+        return And(*conditions)
+
+    def check_implies(self, scenarios: dict[str, bool], implies: str) -> bool:
+        """Based on a bunch of scenario conditions and their Truth/False value
+        determine if implies condition is True any time the scenarios are satisfied
+        solver, solver_params = self._build_solver(list(scenarios.keys()) + [implies])
+
+        Args:
+            scenarios (dict[str, bool]): A list of condition names
+            and if they are True or False implies: the condition name that
+            we are implying will also be True
+
+        Returns:
+            bool: if the implied condition will be True if the scenario is True
+        """
+        try:
+            cnf = self._cnf.copy()
+            # if the implies condition has to be false in the scenarios we
+            # know it can never be true
+            if not scenarios.get(implies, True):
+                return False
+
+            and_condition = self._build_cfn_implies(scenarios)
+            cnf.add_prop(and_condition)
+            implies_condition = self._conditions[implies].build_true_cnf(
+                self._solver_params
+            )
+            cnf.add_prop(Not(Implies(and_condition, implies_condition)))
+
+            results = satisfiable(cnf)
+            if results:
+                return False
+
+            return True
+        except KeyError:
+            # KeyError is because the listed condition doesn't exist because of bad
+            #  formatting or just the wrong condition name
+            return True
+
+    @lru_cache
+    def build_scenerios_on_region(self, condition_name: str, region: str) -> list[bool]:
+        """Based on a region validate if the condition_name could be true
+
+        Args:
+            condition_name (str): The name of the condition we are validating against
+            region (str): the name of the region
+
+        Returns:
+            list[bool]: Returns True, False, or True and False depending on if the
+               condition could be True, False or both based on the region parameter
+        """
+        cnf_region = self._cnf.copy()
+        found_region = False
+
+        # validate the condition name exists
+        # return True/False if it doesn't
+        if condition_name not in self._conditions:
+            return [True, False]
+
+        for eql in self._conditions[condition_name].equals:
+            is_region, equal_region = eql.is_region
+            if is_region:
+                found_region = True
+                if equal_region == region:
+                    cnf_region.add_prop(And(self._solver_params[eql.hash]))
+                else:
+                    cnf_region.add_prop(Not(self._solver_params[eql.hash]))
+
+        # The condition doesn't use a region parameter so it can be True or False
+        # Note: It is possible its a hard coded condition but
+        # for now we will return True and False
+        if not found_region:
+            return [True, False]
+
+        results = []
+        cnf_test = cnf_region.copy()
+        cnf_test.add_prop(
+            self._conditions[condition_name].build_true_cnf(self._solver_params)
+        )
+        if satisfiable(cnf_test):
+            results.append(True)
+
+        cnf_test = cnf_region.copy()
+        cnf_test.add_prop(
+            self._conditions[condition_name].build_false_cnf(self._solver_params)
+        )
+        if satisfiable(cnf_test):
+            results.append(False)
+
+        return results
+
+    def satisfiable(
+        self, conditions: dict[str, bool], parameter_values: dict[str, str]
+    ) -> bool:
+        """Given a list of condition names this function will
+        determine if the conditions are satisfied
+
+        Args:
+            condition_names (dict[str, bool]): A list of condition names with if
+              they are True or False
+
+        Returns:
+            bool: True if the conditions are satisfied
+
+        Raises:
+            UnknownSatisfisfaction: If we don't know how to satisfy a condition
+        """
+        if not conditions:
+            if self._rules:
+                satisfied = satisfiable(self._cnf, all_models=False)
+                if satisfied is False:
+                    return satisfied
+                return True
+            else:
+                return True
+
+        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():
+                    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}
+
+                if not found_params:
+                    continue
+
+                at_least_one_param_found = True
+                if c_equals.test(found_params):
+                    cnf.add_prop(Symbol(c_equals.hash))
+                else:
+                    cnf.add_prop(Not(Symbol(c_equals.hash)))
+
+                if opt:
+                    cnf.add_prop(
+                        self._conditions[condition_name].build_true_cnf(
+                            self._solver_params
+                        )
+                    )
+                else:
+                    cnf.add_prop(
+                        self._conditions[condition_name].build_false_cnf(
+                            self._solver_params
+                        )
+                    )
+
+        if at_least_one_param_found is False:
+            if self._rules:
+                satisfied = satisfiable(self._cnf, all_models=False)
+                if satisfied is False:
+                    return satisfied
+                return True
+            else:
+                return True
+
+        satisfied = satisfiable(cnf, all_models=False)
+        if satisfied is False:
+            return satisfied
+        return True

testbed/aws-cloudformation__cfn-lint/src/cfnlint/config.py

@@ -0,0 +1,879 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import glob
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, Sequence, TypedDict
+
+from typing_extensions import Unpack
+
+import cfnlint.decode.cfn_yaml
+from cfnlint.helpers import REGIONS, format_json_string
+from cfnlint.jsonschema import StandardValidator
+from cfnlint.version import __version__
+
+# pylint: disable=too-many-public-methods
+LOGGER = logging.getLogger("cfnlint")
+
+_DEFAULT_RULESDIR = os.path.join(os.path.dirname(__file__), "rules")
+
+
+def configure_logging(debug_logging, info_logging):
+    ch = logging.StreamHandler()
+
+    if debug_logging:
+        LOGGER.setLevel(logging.DEBUG)
+    elif info_logging:
+        LOGGER.setLevel(logging.INFO)
+    else:
+        LOGGER.setLevel(logging.WARNING)
+    log_formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    ch.setFormatter(log_formatter)
+
+    # make sure all other log handlers are removed before adding it back
+    for handler in LOGGER.handlers:
+        LOGGER.removeHandler(handler)
+    LOGGER.addHandler(ch)
+
+
+class ConfigFileArgs:
+    """
+    Config File arguments.
+    Parses .cfnlintrc OR .cfnlintrc.yaml OR .cfnlintrc.yml
+    in the Home and Project folder.
+    """
+
+    file_args: Dict = {}
+    _user_config_file = None
+    _project_config_file = None
+    _custom_config_file = None
+
+    def __init__(self, schema=None, config_file=None):
+        # self.file_args = self.get_config_file_defaults()
+        self.file_args = {}
+        self.default_schema_file = Path(__file__).parent.joinpath(
+            "data/CfnLintCli/config/schema.json"
+        )
+        with self.default_schema_file.open(encoding="utf-8") as f:
+            self.default_schema = json.load(f)
+        self.schema = self.default_schema if not schema else schema
+
+        if config_file:
+            self._custom_config_file = config_file
+        else:
+            LOGGER.debug("Looking for CFLINTRC before attempting to load")
+            self._user_config_file, self._project_config_file = self._find_config()
+
+        self.load()
+
+    def _find_config(self):
+        """Looks up for user and project level config
+        Returns
+        -------
+        Tuple
+            (Path, Path)
+            Tuple with both configs and whether they were found
+        Example
+        -------
+            > user_config, project_config = self._find_config()
+        """
+        config_file_name = ".cfnlintrc"
+
+        user_config_path = ""
+        home_path = Path.home()
+        for path in [
+            home_path.joinpath(config_file_name),
+            home_path.joinpath(f"{config_file_name}.yaml"),
+            home_path.joinpath(f"{config_file_name}.yml"),
+        ]:
+            if self._has_file(path):
+                user_config_path = path
+                break
+
+        project_config_path = ""
+        cwd_path = Path.cwd()
+        for path in [
+            cwd_path.joinpath(config_file_name),
+            cwd_path.joinpath(f"{config_file_name}.yaml"),
+            cwd_path.joinpath(f"{config_file_name}.yml"),
+        ]:
+            if self._has_file(path):
+                project_config_path = path
+                break
+
+        return user_config_path, project_config_path
+
+    def _has_file(self, filename):
+        """Confirm whether file exists
+        Parameters
+        ----------
+        filename : str
+            Path to a file
+        Returns
+        -------
+        Boolean
+        """
+
+        return Path(filename).is_file()
+
+    def load(self):
+        """Load configuration file and expose as a dictionary
+        Returns
+        -------
+        Dict
+            CFLINTRC configuration
+        """
+
+        if self._custom_config_file:
+            custom_config = self._read_config(self._custom_config_file)
+            LOGGER.debug("Validating Custom CFNLINTRC")
+            self.validate_config(custom_config, self.schema)
+            LOGGER.debug("Custom configuration loaded as")
+            LOGGER.debug("%s", custom_config)
+
+            self.file_args = custom_config
+        else:
+            user_config = self._read_config(self._user_config_file)
+            LOGGER.debug("Validating User CFNLINTRC")
+            self.validate_config(user_config, self.schema)
+
+            project_config = self._read_config(self._project_config_file)
+            LOGGER.debug("Validating Project CFNLINTRC")
+            self.validate_config(project_config, self.schema)
+
+            LOGGER.debug("User configuration loaded as")
+            LOGGER.debug("%s", user_config)
+            LOGGER.debug("Project configuration loaded as")
+            LOGGER.debug("%s", project_config)
+
+            LOGGER.debug("Merging configurations...")
+            self.file_args = self.merge_config(user_config, project_config)
+
+    def validate_config(self, config, schema):
+        """Validate configuration against schema
+        Parameters
+        ----------
+        config : dict
+            CFNLINTRC configuration
+        schema : dict
+            JSONSchema to validate against
+        Raises
+        -------
+        jsonschema.exceptions.ValidationError
+            Returned when cfnlintrc doesn't match schema provided
+        """
+        LOGGER.debug("Validating CFNLINTRC config with given JSONSchema")
+        LOGGER.debug("Schema used: %s", schema)
+        LOGGER.debug("Config used: %s", config)
+
+        validator = StandardValidator(schema=schema)
+        validator.validate(config)
+        LOGGER.debug("CFNLINTRC looks valid!")
+
+    def merge_config(self, user_config, project_config):
+        """Merge project and user configuration into a single dictionary
+        Creates a new configuration with both configuration merged
+        it favours project level over user configuration if keys are duplicated
+        NOTE
+        ----
+            It takes any number of nested dicts
+            It overrides lists found in user_config with project_config
+        Parameters
+        ----------
+        user_config : Dict
+            User configuration (~/.cfnlintrc) found at user's home directory
+        project_config : Dict
+            Project configuration (.cfnlintrc) found at current directory
+        Returns
+        -------
+        Dict
+            Merged configuration
+        """
+        # Recursively override User config with Project config
+        for key in user_config:
+            if key in project_config:
+                # If both keys are the same, let's check whether they have nested keys
+                if isinstance(user_config[key], dict) and isinstance(
+                    project_config[key], dict
+                ):
+                    self.merge_config(user_config[key], project_config[key])
+                else:
+                    user_config[key] = project_config[key]
+                    LOGGER.debug(
+                        "Overriding User's key %s with Project's specific value %s.",
+                        key,
+                        project_config[key],
+                    )
+
+        # Project may have unique config we need to copy over too
+        # so that we can have user+project config available as one
+        for key in project_config:
+            if key not in user_config:
+                user_config[key] = project_config[key]
+
+        return user_config
+
+    def _read_config(self, config):
+        """Parse given YAML configuration
+        Returns
+        -------
+        Dict
+            Parsed YAML configuration as dictionary
+        """
+        config = Path(config)
+        config_template = None
+
+        if self._has_file(config):
+            LOGGER.debug("Parsing CFNLINTRC")
+            config_template = cfnlint.decode.cfn_yaml.load(str(config))
+
+        if not config_template:
+            config_template = {}
+
+        return config_template
+
+
+def comma_separated_arg(string):
+    """Split a comma separated string"""
+    return string.split(",")
+
+
+def _ensure_value(namespace, name, value):
+    if getattr(namespace, name, None) is None:
+        setattr(namespace, name, value)
+    return getattr(namespace, name)
+
+
+class RuleConfigurationAction(argparse.Action):
+    """Override the default Action"""
+
+    def __init__(
+        self,
+        option_strings,
+        dest,
+        nargs=None,
+        const=None,
+        default=None,
+        type=None,
+        choices=None,
+        required=False,
+        help=None,
+        metavar=None,
+    ):  # pylint: disable=W0622
+        super().__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=nargs,
+            const=const,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar,
+        )
+
+    def _parse_rule_configuration(self, string):
+        """Parse the config rule structure"""
+        configs = comma_separated_arg(string)
+        results = {}
+        for config in configs:
+            rule_id = config.split(":")[0]
+            config_name = config.split(":")[1].split("=")[0]
+            config_value = config.split(":")[1].split("=")[1]
+            if rule_id not in results:
+                results[rule_id] = {}
+            results[rule_id][config_name] = config_value
+
+        return results
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = copy.copy(_ensure_value(namespace, self.dest, {}))
+        try:
+            for value in values:
+                new_value = self._parse_rule_configuration(value)
+                for v_k, v_vs in new_value.items():
+                    if v_k in items:
+                        for s_k, s_v in v_vs.items():
+                            items[v_k][s_k] = s_v
+                    else:
+                        items[v_k] = v_vs
+            setattr(namespace, self.dest, items)
+        except Exception:  # pylint: disable=W0703
+            parser.print_help()
+            parser.exit()
+
+
+class CliArgs:
+    """Base Args class"""
+
+    def __init__(self, cli_args: Sequence[str] | None):
+        self.parser = self.create_parser()
+        self.cli_args = self.parser.parse_args(cli_args or [])
+
+    def create_parser(self):
+        """Do first round of parsing parameters to set options"""
+
+        class ArgumentParser(argparse.ArgumentParser):
+            """Override Argument Parser so we can control the exit code"""
+
+            def error(self, message):
+                self.print_help(sys.stderr)
+                self.exit(32, f"{self.prog}: error: {message}\n")
+
+        class ExtendAction(argparse.Action):
+            """Support argument types that are lists and can
+            be specified multiple times.
+            """
+
+            def __call__(self, parser, namespace, values, option_string=None):
+                items = getattr(namespace, self.dest)
+                items = [] if items is None else items
+                for value in values:
+                    if isinstance(value, list):
+                        items.extend(value)
+                    else:
+                        items.append(value)
+                setattr(namespace, self.dest, items)
+
+        usage = (
+            "\nBasic: cfn-lint test.yaml\n"
+            "Ignore a rule: cfn-lint -i E3012 -- test.yaml\n"
+            "Configure a rule: cfn-lint -x E3012:strict=true -t test.yaml\n"
+            "Lint all yaml files in a folder: cfn-lint dir/**/*.yaml"
+        )
+
+        parser = ArgumentParser(description="CloudFormation Linter", usage=usage)
+        parser.register("action", "extend", ExtendAction)
+
+        standard = parser.add_argument_group("Standard")
+        advanced = parser.add_argument_group("Advanced / Debugging")
+
+        # Allow the template to be passes as an optional or a positional argument
+        standard.add_argument(
+            "templates",
+            metavar="TEMPLATE",
+            nargs="*",
+            help="The CloudFormation template to be linted",
+        )
+        standard.add_argument(
+            "-t",
+            "--template",
+            metavar="TEMPLATE",
+            dest="template_alt",
+            help="The CloudFormation template to be linted",
+            nargs="+",
+            default=[],
+            action="extend",
+        )
+        standard.add_argument(
+            "-b",
+            "--ignore-bad-template",
+            help="Ignore failures with Bad template",
+            action="store_true",
+        )
+        standard.add_argument(
+            "--ignore-templates",
+            dest="ignore_templates",
+            help="Ignore templates",
+            nargs="+",
+            default=[],
+            action="extend",
+        )
+        advanced.add_argument(
+            "-D", "--debug", help="Enable debug logging", action="store_true"
+        )
+        advanced.add_argument(
+            "-I", "--info", help="Enable information logging", action="store_true"
+        )
+        standard.add_argument(
+            "-f",
+            "--format",
+            help="Output Format",
+            choices=["quiet", "parseable", "json", "junit", "pretty", "sarif"],
+        )
+        standard.add_argument(
+            "-l",
+            "--list-rules",
+            dest="listrules",
+            default=False,
+            action="store_true",
+            help="list all the rules",
+        )
+        standard.add_argument(
+            "-r",
+            "--regions",
+            dest="regions",
+            nargs="+",
+            default=[],
+            type=comma_separated_arg,
+            action="extend",
+            help="list the regions to validate against.",
+        )
+        advanced.add_argument(
+            "-a",
+            "--append-rules",
+            dest="append_rules",
+            nargs="+",
+            default=[],
+            type=comma_separated_arg,
+            action="extend",
+            help=(
+                "specify one or more rules directories using "
+                "one or more --append-rules arguments. "
+            ),
+        )
+        standard.add_argument(
+            "-i",
+            "--ignore-checks",
+            dest="ignore_checks",
+            nargs="+",
+            default=[],
+            type=comma_separated_arg,
+            action="extend",
+            help="only check rules whose id do not match these values",
+        )
+        standard.add_argument(
+            "-c",
+            "--include-checks",
+            dest="include_checks",
+            nargs="+",
+            default=[],
+            type=comma_separated_arg,
+            action="extend",
+            help="include rules whose id match these values",
+        )
+        standard.add_argument(
+            "-m",
+            "--mandatory-checks",
+            dest="mandatory_checks",
+            nargs="+",
+            default=[],
+            type=comma_separated_arg,
+            action="extend",
+            help=(
+                "always check rules whose id match these values, regardless of template"
+                " exclusions"
+            ),
+        )
+        standard.add_argument(
+            "-e",
+            "--include-experimental",
+            help="Include experimental rules",
+            action="store_true",
+        )
+        standard.add_argument(
+            "-x",
+            "--configure-rule",
+            dest="configure_rules",
+            nargs="+",
+            default={},
+            action=RuleConfigurationAction,
+            help=(
+                "Provide configuration for a rule. Format RuleId:key=value. Example:"
+                " E3012:strict=true"
+            ),
+        )
+        standard.add_argument(
+            "--config-file",
+            dest="config_file",
+            help="Specify the cfnlintrc file to use",
+        )
+        standard.add_argument(
+            "-z",
+            "--custom-rules",
+            dest="custom_rules",
+            help="Allows specification of a custom rule file.",
+        )
+        advanced.add_argument(
+            "-o",
+            "--override-spec",
+            dest="override_spec",
+            help="A CloudFormation Spec override file that allows customization",
+        )
+        advanced.add_argument(
+            "-g",
+            "--build-graph",
+            help=(
+                "Creates a file in the same directory as the template that models the"
+                " template's resources in DOT format"
+            ),
+            action="store_true",
+        )
+        advanced.add_argument(
+            "-s",
+            "--registry-schemas",
+            help="one or more directories of CloudFormation Registry Schemas",
+            action="extend",
+            type=comma_separated_arg,
+            nargs="+",
+        )
+        standard.add_argument(
+            "-v",
+            "--version",
+            help="Version of cfn-lint",
+            action="version",
+            version=f"%(prog)s {__version__}",
+        )
+        advanced.add_argument(
+            "-u",
+            "--update-specs",
+            help="Update the CloudFormation Specs",
+            action="store_true",
+        )
+        advanced.add_argument(
+            "-p",
+            "--patch-specs",
+            help="Patch the CloudFormation Specs in place",
+            action="store_true",
+        )
+        advanced.add_argument(
+            "--update-documentation", help=argparse.SUPPRESS, action="store_true"
+        )
+        advanced.add_argument(
+            "--update-iam-policies", help=argparse.SUPPRESS, action="store_true"
+        )
+        standard.add_argument(
+            "--output-file",
+            type=str,
+            default=None,
+            help="Writes the output to the specified file, ideal for producing reports",
+        )
+        standard.add_argument(
+            "--merge-configs",
+            default=False,
+            action="store_true",
+            help="Merges lists between configuration layers",
+        )
+        standard.add_argument(
+            "--non-zero-exit-code",
+            type=str,
+            default="informational",
+            choices=["informational", "warning", "error", "none"],
+            help="Exit code will be non zero from the specified rule class and higher",
+        )
+        advanced.add_argument("--force", help=argparse.SUPPRESS, action="store_true")
+
+        return parser
+
+
+class TemplateArgs:
+    """Per Template Args"""
+
+    def __init__(self, template_args):
+        self.set_template_args(template_args)
+
+    def get_template_args(self):
+        return self._template_args
+
+    def set_template_args(self, template):
+        defaults = {}
+        if isinstance(template, dict):
+            configs = template.get("Metadata", {}).get("cfn-lint", {}).get("config", {})
+
+            if isinstance(configs, dict):
+                for key, value in {
+                    "ignore_checks": (list),
+                    "regions": (list),
+                    "append_rules": (list),
+                    "override_spec": (str),
+                    "custom_rules": (str),
+                    "ignore_bad_template": (bool),
+                    "include_checks": (list),
+                    "configure_rules": (dict),
+                    "include_experimental": (bool),
+                }.items():
+                    if key in configs:
+                        if isinstance(configs[key], value):
+                            defaults[key] = configs[key]
+
+        self._template_args = defaults
+
+    template_args = property(get_template_args, set_template_args)
+
+
+class ManualArgs(TypedDict, total=False):
+    configure_rules: dict[str, dict[str, Any]]
+    include_checks: list[str]
+    ignore_checks: list[str]
+    mandatory_checks: list[str]
+    include_experimental: bool
+    ignore_bad_template: bool
+    ignore_templates: list
+    merge_configs: bool
+    non_zero_exit_code: str
+    output_file: str
+    regions: list
+
+
+# pylint: disable=too-many-public-methods
+class ConfigMixIn(TemplateArgs, CliArgs, ConfigFileArgs):
+    """Mixin for the Configs"""
+
+    def __init__(self, cli_args: list[str] | None = None, **kwargs: Unpack[ManualArgs]):
+        self._manual_args = kwargs or ManualArgs()
+        self._templates_to_process = False
+        CliArgs.__init__(self, cli_args)
+        # configure debug as soon as we can
+        TemplateArgs.__init__(self, {})
+        ConfigFileArgs.__init__(
+            self, config_file=self._get_argument_value("config_file", False, False)
+        )
+
+    def __repr__(self):
+        return format_json_string(
+            {
+                "ignore_checks": self.ignore_checks,
+                "include_checks": self.include_checks,
+                "mandatory_checks": self.mandatory_checks,
+                "include_experimental": self.include_experimental,
+                "configure_rules": self.configure_rules,
+                "regions": self.regions,
+                "ignore_bad_template": self.ignore_bad_template,
+                "debug": self.debug,
+                "info": self.info,
+                "format": self.format,
+                "templates": self.templates,
+                "append_rules": self.append_rules,
+                "override_spec": self.override_spec,
+                "custom_rules": self.custom_rules,
+                "config_file": self.config_file,
+                "merge_configs": self.merge_configs,
+                "non_zero_exit_code": self.non_zero_exit_code,
+            }
+        )
+
+    def _get_argument_value(self, arg_name, is_template, is_config_file):
+        cli_value = getattr(self.cli_args, arg_name)
+        template_value = self.template_args.get(arg_name)
+        file_value = self.file_args.get(arg_name)
+
+        # merge list configurations
+        # make sure we don't do an infinite loop so skip this check for merge_configs
+        if arg_name != "merge_configs":
+            if self.merge_configs:
+                # the CLI will always have an empty list when the item is a list
+                # we will use that to evaluate if we need to merge the lists
+                if isinstance(cli_value, list):
+                    # Use a copy here, otherwise we will
+                    # accumulate template level config
+                    # into the cli_value which will persist between template files
+                    result = cli_value.copy()
+                    if isinstance(template_value, list):
+                        result.extend(template_value)
+                    if isinstance(file_value, list):
+                        result.extend(file_value)
+                    return result
+
+        # return individual items
+        if arg_name in self._manual_args:
+            return self._manual_args[arg_name]
+        if cli_value:
+            return cli_value
+        if template_value and is_template:
+            return template_value
+        if file_value and is_config_file:
+            return file_value
+        return cli_value
+
+    @property
+    def ignore_checks(self):
+        return self._get_argument_value("ignore_checks", True, True)
+
+    @property
+    def include_checks(self):
+        results = self._get_argument_value("include_checks", True, True)
+        return ["W", "E"] + results
+
+    @property
+    def mandatory_checks(self):
+        return self._get_argument_value("mandatory_checks", False, True)
+
+    @property
+    def include_experimental(self):
+        return self._get_argument_value("include_experimental", True, True)
+
+    @property
+    def regions(self):
+        results = self._get_argument_value("regions", True, True)
+        if not results:
+            default_region_env = os.environ.get("AWS_DEFAULT_REGION", "us-east-1")
+            return [os.environ.get("AWS_REGION", default_region_env)]
+        if "ALL_REGIONS" in results:
+            return REGIONS
+        return results
+
+    @property
+    def ignore_bad_template(self):
+        return self._get_argument_value("ignore_bad_template", True, True)
+
+    @property
+    def debug(self):
+        return self._get_argument_value("debug", False, False)
+
+    @property
+    def info(self):
+        return self._get_argument_value("info", False, False)
+
+    @property
+    def format(self):
+        return self._get_argument_value("format", False, True)
+
+    @property
+    def templates(self):
+        """
+
+        Returns a list of Cloudformation templates to lint.
+
+        Order of precedence:
+        - Filenames provided via `-t` CLI
+        - Filenames specified in the config file.
+        - Arguments provided via `cfn-lint` CLI.
+        """
+
+        all_filenames = []
+
+        cli_alt_args = self._get_argument_value("template_alt", False, False)
+        file_args = self._get_argument_value("templates", False, True)
+        cli_args = self._get_argument_value("templates", False, False)
+
+        if cli_alt_args:
+            filenames = cli_alt_args
+        elif file_args:
+            filenames = file_args
+        elif cli_args:
+            filenames = cli_args
+        else:
+            # No filenames found, could be piped in or be using the api.
+            return None
+
+        # If we're still haven't returned, we've got templates to lint.
+        # Build up list of templates to lint.
+        self.templates_to_process = True
+
+        if isinstance(filenames, str):
+            filenames = [filenames]
+
+        ignore_templates = self._ignore_templates()
+        all_filenames.extend(self._glob_filenames(filenames))
+
+        found_files = [i for i in all_filenames if i not in ignore_templates]
+        LOGGER.debug(
+            f"List of Cloudformation Templates to lint: {found_files} from {filenames}"
+        )
+        return found_files
+
+    def _ignore_templates(self):
+        ignore_template_args = self._get_argument_value("ignore_templates", False, True)
+        if ignore_template_args:
+            filenames = ignore_template_args
+        else:
+            return []
+
+        # if only one is specified convert it to array
+        if isinstance(filenames, str):
+            filenames = [filenames]
+
+        return self._glob_filenames(filenames)
+
+    def _glob_filenames(self, filenames: Sequence[str]) -> list[str]:
+        # handle different shells and Config files
+        # some shells don't expand * and configparser won't expand wildcards
+        all_filenames = []
+
+        for filename in filenames:
+            add_filenames = glob.glob(filename, recursive=True)
+
+            if isinstance(add_filenames, list):
+                all_filenames.extend(add_filenames)
+            else:
+                LOGGER.error(f"{filename} could not be processed by glob.glob")
+
+        return sorted(list(map(str, map(Path, all_filenames))))
+
+    @property
+    def append_rules(self):
+        return [_DEFAULT_RULESDIR] + self._get_argument_value(
+            "append_rules", False, True
+        )
+
+    @property
+    def override_spec(self):
+        return self._get_argument_value("override_spec", False, True)
+
+    @property
+    def custom_rules(self):
+        """custom_rules_spec"""
+        return self._get_argument_value("custom_rules", False, True)
+
+    @property
+    def update_specs(self):
+        return self._get_argument_value("update_specs", False, False)
+
+    @property
+    def patch_specs(self):
+        return self._get_argument_value("patch_specs", False, False)
+
+    @property
+    def update_documentation(self):
+        return self._get_argument_value("update_documentation", False, False)
+
+    @property
+    def update_iam_policies(self):
+        return self._get_argument_value("update_iam_policies", False, False)
+
+    @property
+    def listrules(self):
+        return self._get_argument_value("listrules", False, False)
+
+    @property
+    def configure_rules(self):
+        return self._get_argument_value("configure_rules", True, True)
+
+    @property
+    def config_file(self):
+        return self._get_argument_value("config_file", False, False)
+
+    @property
+    def build_graph(self):
+        return self._get_argument_value("build_graph", False, False)
+
+    @property
+    def output_file(self):
+        return self._get_argument_value("output_file", False, True)
+
+    @property
+    def registry_schemas(self):
+        return self._get_argument_value("registry_schemas", False, True)
+
+    @property
+    def merge_configs(self):
+        return self._get_argument_value("merge_configs", True, True)
+
+    @property
+    def non_zero_exit_code(self):
+        return self._get_argument_value("non_zero_exit_code", False, False)
+
+    @property
+    def force(self):
+        return self._get_argument_value("force", False, False)
+
+    @property
+    def templates_to_process(self):
+        return self._templates_to_process
+
+    @templates_to_process.setter
+    def templates_to_process(self, value: bool):
+        self._templates_to_process = value

testbed/aws-cloudformation__cfn-lint/src/cfnlint/context/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["Context", "create_context_for_template"]
+
+from cfnlint.context.context import Context, Path, create_context_for_template

testbed/aws-cloudformation__cfn-lint/src/cfnlint/context/_mappings.py

@@ -0,0 +1,98 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Iterator
+
+LOGGER = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class Mappings:
+    """
+    This class holds a mapping
+    """
+
+    maps: dict[str, Map] = field(init=True, default_factory=dict)
+    is_transform: bool = field(init=True, default=False)
+
+    @classmethod
+    def create_from_dict(cls, instance: Any) -> Mappings:
+
+        if not isinstance(instance, dict):
+            return cls({})
+        try:
+            result = {}
+            is_transform = False
+            for k, v in instance.items():
+                if k == "Fn::Transform":
+                    is_transform = True
+                elif isinstance(k, str):
+                    result[k] = Map.create_from_dict(v)
+            return cls(result, is_transform)
+        except (ValueError, AttributeError) as e:
+            LOGGER.debug(e, exc_info=True)
+            return cls({})
+
+
+@dataclass(frozen=True)
+class _MappingSecondaryKey:
+    """
+    This class holds a mapping value
+    """
+
+    keys: dict[str, list[Any] | str | int | float] = field(
+        init=True, default_factory=dict
+    )
+    is_transform: bool = field(init=True, default=False)
+
+    def value(self, secondary_key: str):
+        if secondary_key not in self.keys:
+            raise KeyError(secondary_key)
+        return self.keys[secondary_key]
+
+    @classmethod
+    def create_from_dict(cls, instance: Any) -> _MappingSecondaryKey:
+        if not isinstance(instance, dict):
+            return cls({})
+        is_transform = False
+        keys = {}
+        for k, v in instance.items():
+            if k == "Fn::Transform":
+                is_transform = True
+            elif isinstance(k, str) and isinstance(v, (str, list, int, float)):
+                keys[k] = v
+        return cls(keys, is_transform)
+
+
+@dataclass(frozen=True)
+class Map:
+    """
+    This class holds a mapping
+    """
+
+    keys: dict[str, _MappingSecondaryKey] = field(init=True, default_factory=dict)
+    is_transform: bool = field(init=True, default=False)
+
+    def find_in_map(self, top_key: str, secondary_key: str) -> Iterator[Any]:
+        if top_key not in self.keys:
+            raise KeyError(top_key)
+        yield self.keys[top_key].value(secondary_key)
+
+    @classmethod
+    def create_from_dict(cls, instance: Any) -> Map:
+        if not isinstance(instance, dict):
+            return cls({})
+        is_transform = False
+        keys = {}
+        for k, v in instance.items():
+            if k == "Fn::Transform":
+                is_transform = True
+            elif isinstance(k, str):
+                keys[k] = _MappingSecondaryKey.create_from_dict(v)
+        return cls(keys, is_transform)

testbed/aws-cloudformation__cfn-lint/src/cfnlint/context/conditions/__init__.py

@@ -0,0 +1,4 @@
+__all__ = ["Conditions", "Unsatisfiable"]
+
+from cfnlint.context.conditions._conditions import Conditions
+from cfnlint.context.conditions.exceptions import Unsatisfiable

testbed/aws-cloudformation__cfn-lint/src/cfnlint/context/conditions/_condition.py

@@ -0,0 +1,133 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from sympy import And, Not, Or
+from sympy.logic.boolalg import BooleanFunction
+
+from cfnlint.conditions._utils import get_hash
+from cfnlint.context.conditions._equals import Equal
+from cfnlint.helpers import FUNCTION_CONDITIONS, is_function
+
+
+@dataclass(frozen=True)
+class Condition:
+    instance: Any = field(init=True)
+    status: bool | None = field(init=True, default=None)
+    hash: str = field(init=False)
+
+    fn_equals: Equal | None = field(init=True, default=None)
+    condition: list["Condition"] | "Condition" | None = field(init=True, default=None)
+    cnf: BooleanFunction = field(init=True, default_factory=BooleanFunction)
+
+    def __post_init__(self):
+        object.__setattr__(self, "hash", get_hash(self.instance))
+
+    @classmethod
+    def create_from_instance(
+        cls, instance: Any, all_conditions: dict[str, Any]
+    ) -> "Condition":
+        fn_k, fn_v = is_function(instance)
+        if fn_k is None:
+            raise ValueError("Condition value must be an object of length 1")
+        if fn_k in FUNCTION_CONDITIONS:
+            if not isinstance(fn_v, list):
+                raise ValueError(f"{fn_v!r} value should be an array")
+            if fn_k == "Fn::Equals":
+                equal = Equal.create_from_instance(fn_v)
+                return cls(instance=instance, fn_equals=equal, cnf=equal.cnf)
+
+            condition = []
+            for v in fn_v:
+                condition.append(Condition.create_from_instance(v, all_conditions))
+
+            cnf = None
+            if fn_k == "Fn::And":
+                cnf = And(*[c.cnf for c in condition])
+            elif fn_k == "Fn::Or":
+                cnf = Or(*[c.cnf for c in condition])
+            elif fn_k == "Fn::Not":
+                if len(condition) != 1:
+                    raise ValueError(
+                        f"Fn::Not expects only one condition, got {len(condition)}"
+                    )
+                cnf = Not(condition[0].cnf)
+
+            return cls(instance=instance, condition=condition, cnf=cnf)
+
+        if fn_k == "Condition":
+            if not isinstance(fn_v, str):
+                raise ValueError(f"Condition value {fn_v!r} must be a string")
+            sub_condition = all_conditions.get(fn_v)
+            try:
+                sub_all_conditions = all_conditions.copy()
+                del sub_all_conditions[fn_v]
+                c = Condition.create_from_instance(sub_condition, sub_all_conditions)
+            except Exception:
+                c = Condition.create_from_instance(
+                    {"Fn::Equals": [None, None]}, all_conditions
+                )
+            return cls(instance=instance, condition=c, cnf=c.cnf)
+
+        raise ValueError(f"Unknown key {fn_k!r} in condition")
+
+    def evolve(self, status: bool | None) -> "Condition":
+        cls = self.__class__
+
+        if self.status is not None:
+            if status != self.status:
+                raise ValueError(f"Resetting status to {status} from {self.status}")
+
+        return cls(
+            instance=self.instance,
+            status=status,
+            cnf=self.cnf,
+        )
+
+    @property
+    def is_region(self) -> bool:
+        """Returns True or False if the condition is based on region
+
+        Args: None
+
+        Returns:
+            bool
+                Returns True or False if the condition is based on region
+        """
+        if self.fn_equals:
+            return self.fn_equals.is_region
+        if isinstance(self.condition, list):
+            for c in self.condition:
+                if c.is_region:
+                    return True
+            return False
+        if self.condition:
+            return self.condition.is_region
+        return False
+
+    @property
+    def equals(self) -> list[Equal]:
+        """Returns a Sequence of the Equals that make up the Condition
+
+        Args: None
+
+        Returns:
+            Sequence[EqualParameter] | Sequence[Equal] | None:
+                The Equal that are part of the condition
+        """
+        if self.fn_equals:
+            return [self.fn_equals]
+        if isinstance(self.condition, list):
+            equals = []
+            for c in self.condition:
+                equals.extend(c.equals)
+            return equals
+        if self.condition:
+            return self.condition.equals
+        return []

testbed/aws-cloudformation__cfn-lint/src/cfnlint/context/conditions/_conditions.py

@@ -0,0 +1,153 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import itertools
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Iterator
+
+from sympy import Not, Or
+from sympy.logic.boolalg import BooleanFunction
+from sympy.logic.inference import satisfiable
+
+from cfnlint.conditions._utils import get_hash
+from cfnlint.context.conditions._condition import Condition
+from cfnlint.context.conditions._utils import (
+    build_instance_from_scenario,
+    get_conditions_from_property,
+)
+from cfnlint.context.conditions.exceptions import Unsatisfiable
+
+if TYPE_CHECKING:
+    from cfnlint.context.context import Context, Parameter
+
+
+@dataclass(frozen=True)
+class Conditions:
+    # Template level condition management
+    conditions: dict[str, Condition] = field(init=True, default_factory=dict)
+    cnf: BooleanFunction | None = field(init=True, default=None)
+    _max_scenarios: int = field(init=False, default=128)
+
+    @classmethod
+    def create_from_instance(
+        cls, conditions: Any, rules: dict[str, dict], parameters: dict[str, "Parameter"]
+    ) -> "Conditions":
+        obj: dict[str, Condition] = {}
+        if not isinstance(conditions, dict):
+            raise ValueError("Conditions must be a object")
+        for k, v in conditions.items():
+            try:
+                other_conditions = conditions.copy()
+                del other_conditions[k]
+                obj[k] = Condition.create_from_instance(v, other_conditions)
+            except ValueError:
+                # this is a default condition so we can keep the name but it will
+                # not associate with another condition and will always be true/false
+                obj[k] = Condition.create_from_instance(
+                    {"Fn::Equals": [None, None]}, conditions
+                )
+
+        cnf = None
+        for p_k, p_v in parameters.items():
+
+            if not p_v.allowed_values:
+                continue
+            allowed_values = p_v.allowed_values.copy()
+            equals_cnfs = []
+            for _, c_v in obj.items():
+                for i in c_v.equals:
+                    if i.right.hash == get_hash({"Ref": p_k}):
+                        if not isinstance(i.left.instance, str):
+                            continue
+                        equals_cnfs.append(i.cnf)
+                        if i.left.instance in allowed_values:
+                            allowed_values.remove(i.left.instance)
+
+            if not allowed_values:
+                if cnf is None:
+                    cnf = Or(*equals_cnfs)
+                else:
+                    cnf = cnf & Or(*equals_cnfs)
+
+        return cls(conditions=obj, cnf=cnf)
+
+    def evolve(self, status: dict[str, bool]) -> "Conditions":
+        cls = self.__class__
+
+        conditions: dict[str, Condition] = {}
+        cnf = self.cnf
+        for condition, value in self.conditions.items():
+            s = status.get(condition, value.status)
+            try:
+                conditions[condition] = value.evolve(status=s)
+                if s is not None:
+                    if cnf:
+                        cnf = (
+                            cnf & conditions[condition].cnf
+                            if s
+                            else cnf & Not(conditions[condition].cnf)
+                        )
+                    else:
+                        cnf = (
+                            conditions[condition].cnf
+                            if s
+                            else Not(conditions[condition].cnf)
+                        )
+            except ValueError as e:
+                raise Unsatisfiable(
+                    new_status=status,
+                    current_status=self.status,
+                ) from e
+
+        if not satisfiable(cnf):
+            raise Unsatisfiable(
+                new_status=status,
+                current_status=self.status,
+            )
+
+        return cls(
+            conditions=conditions,
+            cnf=cnf,
+        )
+
+    def _build_conditions(self, conditions: set[str]) -> Iterator["Conditions"]:
+        scenarios_attempted = 0
+        for product in itertools.product([True, False], repeat=len(conditions)):
+            params = dict(zip(conditions, product))
+            try:
+                yield self.evolve(params)
+            except Unsatisfiable:
+                pass
+
+            scenarios_attempted += 1
+            # On occassions people will use a lot of non-related conditions
+            # this is fail safe to limit the maximum number of responses
+            if scenarios_attempted >= self._max_scenarios:
+                return
+
+    def evolve_from_instance(
+        self, instance: Any, context: "Context"
+    ) -> Iterator[tuple[Any, "Conditions"]]:
+
+        conditions = get_conditions_from_property(instance)
+
+        for scenario in self._build_conditions(conditions):
+            yield build_instance_from_scenario(
+                instance,
+                scenario.status,
+                is_root=True,
+                context=context,
+            ), scenario
+
+    @property
+    def status(self) -> dict[str, bool]:
+        obj = {}
+        for name, c in self.conditions.items():
+            if c.status is not None:
+                obj[name] = c.status
+
+        return obj

testbed/aws-cloudformation__cfn-lint/src/cfnlint/context/conditions/_equals.py

@@ -0,0 +1,129 @@
+"""
+Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from functools import cmp_to_key
+from typing import Any
+
+from sympy import Symbol
+
+from cfnlint.conditions._utils import get_hash
+from cfnlint.helpers import is_function
+
+LOGGER = logging.getLogger(__name__)
+REF_REGION = get_hash({"Ref": "AWS::Region"})
+
+
+def _sorted(a: dict[str, str] | str, b: dict[str, str] | str) -> int:
+    if isinstance(a, dict) and isinstance(b, dict):
+        a_k, a_v = is_function(a)
+        b_k, b_v = is_function(b)
+        if a_k is None or b_k is None:
+            if a_k is None and b_k is not None:
+                return 1
+            if a_k is not None and b_k is None:
+                return -1
+            return 0
+
+        if a_k == "Ref" and isinstance(a_v, str):
+            if b_k == "Ref" and isinstance(b_v, str):
+                return -1 if a_v <= b_v else 1
+
+        return -1 if a_k <= b_k else 1
+
+    return -1 if str(a) <= str(b) else 1
+
+
+_equals_cmp_key = cmp_to_key(_sorted)
+
+
+@dataclass(frozen=True)
+class EqualParameter:
+    instance: dict[str, str] | str | None = field(init=True)
+    hash: str = field(init=False)
+    is_region: bool = field(init=False, default=False)
+
+    def __post_init__(self):
+        object.__setattr__(self, "hash", get_hash(self.instance))
+        object.__setattr__(self, "is_region", self.hash == REF_REGION)
+
+    @classmethod
+    def create_from_instance(cls, instance: Any) -> "EqualParameter":
+        if isinstance(instance, (str, bool, int, float)):
+            return cls(instance=str(instance))
+
+        if isinstance(instance, dict):
+            return cls(instance=instance)
+
+        # escape version
+        if instance is None:
+            return cls(instance=None)
+
+        raise ValueError("EqualParameter has to be a string or a dict")
+
+    def __eq__(self, __o: Any):
+        if isinstance(__o, EqualParameter):
+            return self.hash == __o.hash
+        return False
+
+
+@dataclass(frozen=True)
+class Equal:
+    instance: list[str | dict] = field(init=True)
+    hash: str = field(init=False)
+
+    left: EqualParameter = field(init=True)
+    right: EqualParameter = field(init=True)
+
+    is_static: bool | None = field(init=False, default=None)
+
+    cnf: Symbol = field(init=False)
+
+    @classmethod
+    def create_from_instance(cls, instance: Any) -> "Equal":
+        if not (isinstance(instance, list) and len(instance) == 2):
+            raise ValueError("Equals has to be a list of two values")
+
+        instance.sort(key=_equals_cmp_key)
+        left = EqualParameter.create_from_instance(instance[0])
+        right = EqualParameter.create_from_instance(instance[1])
+        return cls(instance=instance, left=left, right=right)
+
+    def __post_init__(self):
+        object.__setattr__(self, "hash", get_hash(self.instance))
+        if isinstance(self.left.instance, (str, int, bool, float)) and isinstance(
+            self.right.instance, (str, int, bool, float)
+        ):
+            object.__setattr__(
+                self, "is_static", self.left.instance == self.right.instance
+            )
+        object.__setattr__(self, "cnf", Symbol(self.hash))
+
+    @property
+    def parameters(self) -> list[EqualParameter]:
+        """Returns a List of the EqualParameter that make up the Condition
+
+        Args: None
+
+        Returns:
+            list[Equal]: A list of the left and right equal parameters if they are
+                         of type EqualParameter
+        """
+        return [self.left, self.right]
+
+    @property
+    def is_region(self) -> bool:
+        """
+         Returns a bool if the condition is comparing a region to a string
+
+        Args: None
+
+        Returns:
+            bool: If a parameter in the equals has {"Ref": "AWS::Region}
+        """
+        return (self.left.is_region or self.right.is_region) and not self.is_static

testbed/aws-cloudformation__cfn-lint/src/cfnlint/context/conditions/_utils.py

@@ -0,0 +1,131 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from cfnlint.decode.node import Mark, dict_node, list_node
+from cfnlint.helpers import is_function
+
+if TYPE_CHECKING:
+    from cfnlint.context.context import Context
+
+
+def get_conditions_from_property(instance: Any, is_root: bool = True) -> set[str]:
+    """
+    Gets the name of the conditions used directly inside the object.
+
+    We do not look at nested objects for conditions.
+
+    Args:
+        instance (Any): The object or listto process.
+        is_root (bool): If we are at the root of the object. Default: True.
+
+    Returns:
+        set[str]: The set of conditions used in the object or list.
+    """
+    results: set[str] = set()
+    if isinstance(instance, list):
+        for v in instance:
+            results = results.union(get_conditions_from_property(v, is_root=False))
+        return results
+
+    fn_k, fn_v = is_function(instance)
+    if fn_k == "Fn::If":
+        if isinstance(fn_v, list) and len(fn_v) == 3:
+            if isinstance(fn_v[0], str):
+                results.add(fn_v[0])
+                results = results.union(
+                    get_conditions_from_property(fn_v[1], is_root=is_root)
+                )
+                results = results.union(
+                    get_conditions_from_property(fn_v[2], is_root=is_root)
+                )
+        return results
+    if is_root:
+        if isinstance(instance, dict):
+            for k, v in instance.items():
+                results = results.union(get_conditions_from_property(v, is_root=False))
+    return results
+
+
+def build_instance_from_scenario(
+    instance: Any,
+    scenario: dict[str, bool],
+    is_root: bool,
+    context: "Context",
+) -> Any:
+    """
+    Get object values from a provided scenario.
+
+    This function recursively processes the provided object, resolving any
+    conditional logic (such as Fn::If) based on the given scenario.
+
+    Args:
+        instance (Any): The object or listto process.
+        scenario (dict): The scenario to use when resolving conditional logic.
+        is_root (bool): If we are at the root of the object. Default: True.
+
+    Returns:
+        dict or list or any: The processed object, with conditional logic resolved.
+        The return type can be a dictionary, list, or any other data type,
+        depending on the structure of the input object.
+    """
+
+    if isinstance(instance, list):
+        new_list: list[Any] = list_node(
+            [],
+            getattr(instance, "start_mark", Mark(0, 0)),
+            getattr(instance, "end_mark", Mark(0, 0)),
+        )
+        for v in instance:
+            new_value = build_instance_from_scenario(
+                v,
+                scenario,
+                is_root=False,
+                context=context,
+            )
+            if new_value is not None:
+                new_list.append(new_value)
+        return new_list
+
+    if isinstance(instance, dict):
+        fn_k, fn_v = is_function(instance)
+        if fn_k == "Fn::If" and "Fn::If" in context.functions:
+            if isinstance(fn_v, list) and len(fn_v) == 3:
+                if isinstance(fn_v[0], str):
+                    if_path = scenario.get(fn_v[0], None)
+                    if if_path is not None:
+                        new_value = build_instance_from_scenario(
+                            fn_v[1] if if_path else fn_v[2],
+                            scenario,
+                            is_root,
+                            context=context,
+                        )
+                        if new_value is not None:
+                            return new_value
+                        return None
+            return instance
+        if fn_k == "Ref" and fn_v == "AWS::NoValue" and "Ref" in context.functions:
+            return None
+        if is_root:
+            new_obj: dict[str, Any] = dict_node(
+                {},
+                getattr(instance, "start_mark", Mark(0, 0)),
+                getattr(instance, "end_mark", Mark(0, 0)),
+            )
+            for k, v in instance.items():
+                new_value = build_instance_from_scenario(
+                    v,
+                    scenario,
+                    is_root=False,
+                    context=context,
+                )
+                if new_value is not None:
+                    new_obj[k] = new_value
+            return new_obj
+
+    return instance

testbed/aws-cloudformation__cfn-lint/src/cfnlint/context/conditions/exceptions.py

@@ -0,0 +1,60 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+from typing import Iterator
+
+
+def _get_new_status_message(
+    current_status: dict[str, bool], new_status: dict[str, bool]
+) -> Iterator[str]:
+    for k, v in new_status.items():
+        if v is not None:
+            if current_status.get(k) is not None and current_status.get(k) != v:
+                yield (
+                    f"condition {k!r} to {v!r} from current "
+                    f"status {current_status.get(k)!r}"
+                )
+            else:
+                yield f"condition {k!r} to {v!r}"
+
+
+def _get_current_status_message(
+    current_status: dict[str, bool], new_status: dict[str, bool]
+) -> Iterator[str]:
+    for k, v in current_status.items():
+        if v is not None and k not in new_status:
+            yield f"condition {k!r} is {v!r}"
+
+
+def _build_message(current_status: dict[str, bool], new_status: dict[str, bool]) -> str:
+    message = ", and ".join(_get_new_status_message(current_status, new_status))
+
+    current_message = " and ".join(
+        _get_current_status_message(current_status, new_status)
+    )
+
+    if current_message:
+        message += f". Where existing status for {current_message}"
+
+    return f"When setting {message}"
+
+
+class Unsatisfiable(ValueError):
+
+    def __init__(
+        self,
+        new_status: dict[str, bool],
+        current_status: dict[str, bool],
+    ) -> None:
+        message = _build_message(current_status, new_status)
+        super().__init__(message)
+        self.message = message
+        self.current_status = current_status
+        self.new_status = new_status
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: {self.message!r}>"

testbed/aws-cloudformation__cfn-lint/src/cfnlint/context/context.py

@@ -0,0 +1,475 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections import deque
+from dataclasses import InitVar, dataclass, field, fields
+from functools import lru_cache
+from typing import Any, Deque, Iterator, Sequence, Set, Tuple
+
+from cfnlint.context._mappings import Mappings
+from cfnlint.context.conditions._conditions import Conditions
+from cfnlint.helpers import (
+    BOOLEAN_STRINGS_TRUE,
+    FUNCTIONS,
+    PSEUDOPARAMS,
+    REGION_PRIMARY,
+    TRANSFORM_SAM,
+)
+from cfnlint.schema import PROVIDER_SCHEMA_MANAGER, AttributeDict
+
+_PSEUDOPARAMS_NON_REGION = ["AWS::AccountId", "AWS::NoValue", "AWS::StackName"]
+
+
+@dataclass
+class Transforms:
+    # Template level parameters
+    transforms: InitVar[str | list[str] | None]
+    _transforms: list[str] = field(init=False, default_factory=list)
+
+    def __post_init__(self, transforms) -> None:
+        if transforms is None:
+            return
+        if not isinstance(transforms, list):
+            transforms = [transforms]
+
+        for transform in transforms:
+            if not isinstance(transform, str):
+                continue
+            self._transforms.append(transform)
+
+        self.has_sam_transform = lru_cache()(self.has_sam_transform)  # type: ignore
+        self.has_language_extensions_transform = lru_cache()(  # type: ignore
+            self.has_language_extensions_transform
+        )
+
+    def has_language_extensions_transform(self):
+        lang_extensions_transform = "AWS::LanguageExtensions"
+        return bool(lang_extensions_transform in self._transforms)
+
+    def has_sam_transform(self):
+        return bool(TRANSFORM_SAM in self._transforms)
+
+
+@dataclass(frozen=True)
+class Path:
+    """
+    A `Path` keeps track of the different Path values
+    """
+
+    # path keeps track of the path as we move down the template
+    # Example: Resources, MyResource, Properties, Name, ...
+    path: Deque[str | int] = field(init=True, default_factory=deque)
+
+    # value_path is an override of the value if we got it from another place
+    # like a Parameter default value
+    # Example: Parameters, MyParameter, Default, ...
+    value_path: Deque[str | int] = field(init=True, default_factory=deque)
+
+    # cfn_path is a generic path used by cfn-lint to help make
+    # writing rules easier.  The resource name is replaced by the type
+    # lists are replaced with a *
+    # Example: Resources, AWS::S3::Bucket, Properties, Name, ...
+    # Example: Resources, *, Type
+    cfn_path: Deque[str] = field(init=True, default_factory=deque)
+
+    def descend(self, **kwargs) -> "Path":
+        """
+        Create a new Path by appending values
+        """
+        cls = self.__class__
+
+        if kwargs.get("cfn_path") in FUNCTIONS:
+            raise ValueError(f"{kwargs['cfn_path']!r} cannot be in 'cfn_path'")
+        elif isinstance(kwargs.get("cfn_path"), int):
+            raise ValueError(f"{kwargs['cfn_path']!r} cannot be an integer")
+
+        for f in fields(Path):
+            if kwargs.get(f.name) is not None:
+                kwargs[f.name] = getattr(self, f.name) + deque([kwargs[f.name]])
+            else:
+                kwargs[f.name] = getattr(self, f.name)
+
+        return cls(**kwargs)
+
+    def evolve(self, **kwargs):
+        """
+        Create a new path without appending values
+        """
+        cls = self.__class__
+
+        for f in fields(Path):
+            kwargs.setdefault(f.name, getattr(self, f.name))
+
+        return cls(**kwargs)
+
+    @property
+    def path_string(self):
+        return "/".join(str(p) for p in self.path)
+
+    @property
+    def cfn_path_string(self):
+        return "/".join(self.cfn_path)
+
+
+@dataclass(frozen=True)
+class Context:
+    """
+    A `Context` keeps track of the current context that we are evaluating against
+    Arguments:
+
+        region:
+
+            The region being evaluated against.
+
+        conditions:
+
+            The conditions being used and their current state
+    """
+
+    # what regions we are processing
+    regions: Sequence[str] = field(
+        init=True, default_factory=lambda: list([REGION_PRIMARY])
+    )
+
+    # supported functions at this point in the template
+    functions: Sequence[str] = field(init=True, default_factory=list)
+
+    path: Path = field(init=True, default_factory=Path)
+
+    # cfn-lint Template class
+    parameters: dict[str, "Parameter"] = field(init=True, default_factory=dict)
+    resources: dict[str, "Resource"] = field(init=True, default_factory=dict)
+    conditions: Conditions = field(init=True, default_factory=Conditions)
+    mappings: Mappings = field(init=True, default_factory=Mappings)
+
+    strict_types: bool = field(init=True, default=True)
+
+    pseudo_parameters: Set[str] = field(
+        init=True, default_factory=lambda: set(PSEUDOPARAMS)
+    )
+
+    # Combiniation of storing any resolved ref
+    # and adds in any Refs available from things like Fn::Sub
+    ref_values: dict[str, Any] = field(init=True, default_factory=dict)
+
+    transforms: Transforms = field(init=True, default_factory=lambda: Transforms([]))
+
+    # is the value a resolved value
+    is_resolved_value: bool = field(init=True, default=False)
+
+    def evolve(self, **kwargs) -> "Context":
+        """
+        Create a new context without merging together attributes
+        """
+        cls = self.__class__
+
+        if "ref_values" in kwargs:
+            new_ref_values = self.ref_values.copy()
+            new_ref_values.update(kwargs["ref_values"])
+            kwargs["ref_values"] = new_ref_values
+
+        for f in fields(Context):
+            if f.init:
+                kwargs.setdefault(f.name, getattr(self, f.name))
+
+        return cls(**kwargs)
+
+    def ref_value(self, instance: str) -> Iterator[Tuple[str | list[str], "Context"]]:
+        if instance in PSEUDOPARAMS and instance not in self.pseudo_parameters:
+            return
+
+        if instance in self.ref_values:
+            yield self.ref_values[instance], self
+            return
+
+        # Non regionalized items first
+        if instance in _PSEUDOPARAMS_NON_REGION and instance in self.pseudo_parameters:
+            pseudo_value = _get_pseudo_value(instance)
+            if pseudo_value is not None:
+                yield pseudo_value, self.evolve(ref_values={instance: pseudo_value})
+            return
+        if instance in self.parameters:
+            for v, path in self.parameters[instance].ref(self):
+
+                # validate that ref is possible with path
+                # need to evaluate if Fn::If would be not true if value is
+                # what it is
+                yield v, self.evolve(
+                    path=self.path.evolve(
+                        value_path=deque(["Parameters", instance]) + path
+                    ),
+                    ref_values={instance: v},
+                )
+            return
+
+        # Regionalized values second
+        if instance in PSEUDOPARAMS and instance in self.pseudo_parameters:
+            for region in self.regions:
+                # We can resolve all region based pseudo values
+                # as we are now deciding on a region.
+                yield _get_pseudo_value_by_region(instance, region), self.evolve(
+                    regions=[region],
+                    ref_values={
+                        p: _get_pseudo_value_by_region(p, region)
+                        for p in PSEUDOPARAMS
+                        if p not in _PSEUDOPARAMS_NON_REGION
+                    },
+                )
+
+    @property
+    def refs(self):
+        pseudo_params = list(self.pseudo_parameters)
+        pseudo_params.sort()
+        return (
+            list(self.parameters.keys())
+            + list(self.resources.keys())
+            + pseudo_params
+            + list(self.ref_values.keys())
+        )
+
+
+def _get_pseudo_value(parameter: str) -> str | list[str] | None:
+    if parameter == "AWS::AccountId":
+        return "123456789012"
+    if parameter == "AWS::StackName":
+        return "teststack"
+    return None
+
+
+def _get_pseudo_value_by_region(parameter: str, region: str) -> str | list[str]:
+    if parameter == "AWS::NotificationARNs":
+        return [f"arn:{_get_partition(region)}:sns:{region}:123456789012:notification"]
+    if parameter == "AWS::Partition":
+        return _get_partition(region)
+    if parameter == "AWS::Region":
+        return region
+    if parameter == "AWS::StackId":
+        return (
+            f"arn:{_get_partition(region)}:cloudformation:{region}"
+            ":123456789012:stack/teststack/51af3dc0-da77-11e4-872e-1234567db123"
+        )
+    if region in ("cn-north-1", "cn-northwest-1"):
+        return "amazonaws.com.cn"
+    else:
+        return "amazonaws.com"
+
+
+def _get_partition(region) -> str:
+    if region in ("us-gov-east-1", "us-gov-west-1"):
+        return "aws-us-gov"
+    if region in ("cn-north-1", "cn-northwest-1"):
+        return "aws-cn"
+    else:
+        return "aws"
+
+
+class _Ref(ABC):
+    """
+    Abstract class for all ref types
+    """
+
+    @abstractmethod
+    def ref(self, context: Context) -> Iterator[Any]:
+        pass
+
+
+def _strip(value: Any) -> Any:
+    if isinstance(value, str):
+        return value.strip()
+    return value
+
+
+@dataclass
+class Parameter(_Ref):
+    """
+    This class holds a parameter and its attributes
+    """
+
+    type: str = field(init=False)
+    default: Any = field(init=False)
+    allowed_values: Any = field(init=False)
+    description: str | None = field(init=False)
+    ssm_path: str | None = field(init=False, default=None)
+
+    parameter: InitVar[Any]
+
+    def __post_init__(self, parameter) -> None:
+        if not isinstance(parameter, dict):
+            raise ValueError("Parameter must be a object")
+
+        self.is_ssm_parameter = lru_cache()(self.is_ssm_parameter)  # type: ignore
+
+        self.default = None
+        self.allowed_values = []
+        self.min_value = None
+        self.max_value = None
+        self.no_echo = False
+
+        t = parameter.get("Type")
+        if not isinstance(t, str):
+            raise ValueError("Type must be a string")
+        self.type = t
+
+        self.description = parameter.get("Description")
+
+        # SSM Parameter defaults and allowed values point to
+        # SSM paths not to the actual values
+        if self.is_ssm_parameter():
+            self.ssm_path = parameter.get("Default", "")
+            return
+
+        if self.type == "CommaDelimitedList" or self.type.startswith("List<"):
+            if "Default" in parameter:
+                default = parameter.get("Default", "")
+                if isinstance(default, str):
+                    self.default = [_strip(value) for value in default.split(",")]
+                else:
+                    self.default = [_strip(default)]
+
+            for allowed_value in parameter.get("AllowedValues", []):
+                if isinstance(allowed_value, str):
+                    self.allowed_values.append(
+                        [_strip(value) for value in allowed_value.split(",")]
+                    )
+                else:
+                    self.allowed_values.append([_strip(allowed_value)])
+        else:
+            self.default = parameter.get("Default")
+            self.allowed_values = parameter.get("AllowedValues")
+
+        self.min_value = parameter.get("MinValue")
+        self.max_value = parameter.get("MaxValue")
+        if parameter.get("NoEcho") in list(BOOLEAN_STRINGS_TRUE) + [True]:
+            self.no_echo = True
+
+    def ref(self, context: Context) -> Iterator[Tuple[Any, deque]]:
+        if self.allowed_values:
+            for i, allowed_value in enumerate(self.allowed_values):
+                if isinstance(allowed_value, list):
+                    yield [str(x) for x in allowed_value], deque(["AllowedValues", i])
+                else:
+                    yield str(allowed_value), deque(["AllowedValues", i])
+            # assume default is an allowed value so we skip it
+            return
+
+        if self.default is not None:
+            if isinstance(self.default, list):
+                yield [str(x) for x in self.default], deque(["Default"])
+            else:
+                yield str(self.default), deque(["Default"])
+
+        if self.min_value is not None:
+            yield str(self.min_value), deque(["MinValue"])
+
+        if self.max_value is not None:
+            yield str(self.max_value), deque(["MaxValue"])
+
+    def is_ssm_parameter(self) -> bool:
+        return self.type.startswith("AWS::SSM::Parameter::")
+
+
+@dataclass
+class Resource(_Ref):
+    """
+    This class holds a resources and its type
+    """
+
+    type: str = field(init=False)
+    condition: str | None = field(init=False, default=None)
+    resource: InitVar[Any]
+
+    def __post_init__(self, resource) -> None:
+        if not isinstance(resource, dict):
+            raise ValueError("Resource must be a object")
+        t = resource.get("Type")
+        if not isinstance(t, str):
+            raise ValueError("Type must be a string")
+        self.type = t
+        if self.type.startswith("Custom::"):
+            self.type = "AWS::CloudFormation::CustomResource"
+
+        c = resource.get("Condition")
+        if not isinstance(t, str):
+            raise ValueError("Condition must be a string")
+        self.condition = c
+
+    def get_atts(self, region: str = "us-east-1") -> AttributeDict:
+        return PROVIDER_SCHEMA_MANAGER.get_type_getatts(self.type, region)
+
+    def ref(self, context: Context) -> Iterator[Any]:
+        return
+        yield
+
+
+def _init_parameters(parameters: Any) -> dict[str, Parameter]:
+    obj = {}
+    if not isinstance(parameters, dict):
+        raise ValueError("Parameters must be a object")
+    for k, v in parameters.items():
+        try:
+            obj[k] = Parameter(v)
+        except ValueError:
+            pass
+
+    return obj
+
+
+def _init_resources(resources: Any) -> dict[str, Resource]:
+    obj = {}
+    if not isinstance(resources, dict):
+        raise ValueError("Resource must be a object")
+    for k, v in resources.items():
+        try:
+            obj[k] = Resource(v)
+        except ValueError:
+            pass
+    return obj
+
+
+def _init_transforms(transforms: Any) -> Transforms:
+    if isinstance(transforms, (str, list)):
+        return Transforms(transforms)
+    return Transforms([])
+
+
+def create_context_for_template(cfn):
+    parameters = {}
+    try:
+        parameters = _init_parameters(cfn.template.get("Parameters", {}))
+    except (ValueError, AttributeError):
+        pass
+
+    resources = {}
+    try:
+        resources = _init_resources(cfn.template.get("Resources", {}))
+    except (ValueError, AttributeError):
+        pass
+
+    transforms = _init_transforms(cfn.template.get("Transform", []))
+
+    try:
+        conditions = Conditions.create_from_instance(
+            cfn.template.get("Conditions", {}),
+            cfn.template.get("Rules", {}),
+            parameters,
+        )
+    except (ValueError, AttributeError):
+        conditions = Conditions.create_from_instance({}, {}, {})
+
+    mappings = Mappings.create_from_dict(cfn.template.get("Mappings", {}))
+
+    return Context(
+        parameters=parameters,
+        resources=resources,
+        conditions=conditions,
+        transforms=transforms,
+        mappings=mappings,
+        regions=cfn.regions,
+        path=Path(),
+        functions=["Fn::Transform"],
+    )

testbed/aws-cloudformation__cfn-lint/src/cfnlint/core.py

@@ -0,0 +1,78 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Sequence
+
+from cfnlint.config import _DEFAULT_RULESDIR, ConfigMixIn, ManualArgs
+from cfnlint.match import Match
+from cfnlint.rules import RulesCollection
+from cfnlint.runner import TemplateRunner, UnexpectedRuleException
+
+
+def get_rules(
+    append_rules: list[str],
+    ignore_rules: list[str],
+    include_rules: list[str],
+    configure_rules=None,
+    include_experimental: bool = False,
+    mandatory_rules: list[str] | None = None,
+    custom_rules: str | None = None,
+) -> RulesCollection:
+    rules = RulesCollection(
+        ignore_rules,
+        include_rules,
+        configure_rules,
+        include_experimental,
+        mandatory_rules,
+    )
+    rules_paths: list[str] = [_DEFAULT_RULESDIR] + append_rules
+    try:
+        for rules_path in rules_paths:
+            if rules_path and os.path.isdir(os.path.expanduser(rules_path)):
+                rules.create_from_directory(rules_path)
+            else:
+                rules.create_from_module(rules_path)
+
+        rules.create_from_custom_rules_file(custom_rules)
+    except (OSError, ImportError) as e:
+        raise UnexpectedRuleException(
+            f"Tried to append rules but got an error: {str(e)}", 1
+        ) from e
+    return rules
+
+
+def run_checks(
+    filename: str,
+    template: dict,
+    rules: RulesCollection | None,
+    regions: Sequence[str],
+    mandatory_rules: Sequence[str] | None = None,
+) -> list[Match]:
+    """Run Checks and Custom Rules against the template"""
+
+    config: ManualArgs = ManualArgs(
+        regions=list(regions),
+        mandatory_checks=list(mandatory_rules or []),
+    )
+
+    if not rules:
+        return []
+
+    config_mixin = ConfigMixIn(
+        [],
+        **config,
+    )
+
+    runner = TemplateRunner(
+        filename=filename,
+        template=template,
+        rules=rules,  # type: ignore
+        config=config_mixin,
+    )
+
+    return list(runner.run())

testbed/aws-cloudformation__cfn-lint/src/cfnlint/custom_rules.txt

@@ -0,0 +1,4 @@
+#Comments can be made with a '#' symbol at the start of the line
+#Syntax: <Resource Type> <Property[*]> <Operator> <Value>
+#Example: AWS::EC2::Instance InstanceType EQUALS "p3.2xlarge"
+AWS::EC2::Instance ImageId EQUALS "SomethingItIsNotEqualTo"

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/__init__.py

@@ -0,0 +1,4 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/__init__.py

@@ -0,0 +1,3 @@
+"""
+Storage of all JSON schema files and their patches
+"""

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_east_2/aws-quicksight-datasource.json

@@ -0,0 +1,951 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/AwsAccountId",
+  "/properties/DataSourceId",
+  "/properties/Type"
+ ],
+ "definitions": {
+  "AmazonElasticsearchParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Domain": {
+     "maxLength": 64,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "required": [
+    "Domain"
+   ],
+   "type": "object"
+  },
+  "AmazonOpenSearchParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Domain": {
+     "maxLength": 64,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "required": [
+    "Domain"
+   ],
+   "type": "object"
+  },
+  "AthenaParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "RoleArn": {
+     "maxLength": 2048,
+     "minLength": 20,
+     "type": "string"
+    },
+    "WorkGroup": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "AuroraParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Database",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "AuroraPostgreSqlParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Database",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "AwsIotAnalyticsParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "DataSetName": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "required": [
+    "DataSetName"
+   ],
+   "type": "object"
+  },
+  "CredentialPair": {
+   "additionalProperties": false,
+   "properties": {
+    "AlternateDataSourceParameters": {
+     "items": {
+      "$ref": "#/definitions/DataSourceParameters"
+     },
+     "maxItems": 50,
+     "minItems": 1,
+     "type": "array"
+    },
+    "Password": {
+     "maxLength": 1024,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Username": {
+     "maxLength": 64,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "required": [
+    "Password",
+    "Username"
+   ],
+   "type": "object"
+  },
+  "DataSourceCredentials": {
+   "additionalProperties": false,
+   "properties": {
+    "CopySourceArn": {
+     "pattern": "^arn:[-a-z0-9]*:quicksight:[-a-z0-9]*:[0-9]{12}:datasource/.+$",
+     "type": "string"
+    },
+    "CredentialPair": {
+     "$ref": "#/definitions/CredentialPair"
+    },
+    "SecretArn": {
+     "maxLength": 2048,
+     "minLength": 1,
+     "pattern": "^arn:[-a-z0-9]*:secretsmanager:[-a-z0-9]*:[0-9]{12}:secret:.+$",
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "DataSourceErrorInfo": {
+   "additionalProperties": false,
+   "properties": {
+    "Message": {
+     "type": "string"
+    },
+    "Type": {
+     "$ref": "#/definitions/DataSourceErrorInfoType"
+    }
+   },
+   "type": "object"
+  },
+  "DataSourceErrorInfoType": {
+   "enum": [
+    "ACCESS_DENIED",
+    "COPY_SOURCE_NOT_FOUND",
+    "TIMEOUT",
+    "ENGINE_VERSION_NOT_SUPPORTED",
+    "UNKNOWN_HOST",
+    "GENERIC_SQL_FAILURE",
+    "CONFLICT",
+    "UNKNOWN"
+   ],
+   "type": "string"
+  },
+  "DataSourceParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "AmazonElasticsearchParameters": {
+     "$ref": "#/definitions/AmazonElasticsearchParameters"
+    },
+    "AmazonOpenSearchParameters": {
+     "$ref": "#/definitions/AmazonOpenSearchParameters"
+    },
+    "AthenaParameters": {
+     "$ref": "#/definitions/AthenaParameters"
+    },
+    "AuroraParameters": {
+     "$ref": "#/definitions/AuroraParameters"
+    },
+    "AuroraPostgreSqlParameters": {
+     "$ref": "#/definitions/AuroraPostgreSqlParameters"
+    },
+    "DatabricksParameters": {
+     "$ref": "#/definitions/DatabricksParameters"
+    },
+    "MariaDbParameters": {
+     "$ref": "#/definitions/MariaDbParameters"
+    },
+    "MySqlParameters": {
+     "$ref": "#/definitions/MySqlParameters"
+    },
+    "OracleParameters": {
+     "$ref": "#/definitions/OracleParameters"
+    },
+    "PostgreSqlParameters": {
+     "$ref": "#/definitions/PostgreSqlParameters"
+    },
+    "PrestoParameters": {
+     "$ref": "#/definitions/PrestoParameters"
+    },
+    "RdsParameters": {
+     "$ref": "#/definitions/RdsParameters"
+    },
+    "RedshiftParameters": {
+     "$ref": "#/definitions/RedshiftParameters"
+    },
+    "S3Parameters": {
+     "$ref": "#/definitions/S3Parameters"
+    },
+    "SnowflakeParameters": {
+     "$ref": "#/definitions/SnowflakeParameters"
+    },
+    "SparkParameters": {
+     "$ref": "#/definitions/SparkParameters"
+    },
+    "SqlServerParameters": {
+     "$ref": "#/definitions/SqlServerParameters"
+    },
+    "StarburstParameters": {
+     "$ref": "#/definitions/StarburstParameters"
+    },
+    "TeradataParameters": {
+     "$ref": "#/definitions/TeradataParameters"
+    },
+    "TrinoParameters": {
+     "$ref": "#/definitions/TrinoParameters"
+    }
+   },
+   "type": "object"
+  },
+  "DataSourceType": {
+   "enum": [
+    "ADOBE_ANALYTICS",
+    "AMAZON_ELASTICSEARCH",
+    "AMAZON_OPENSEARCH",
+    "ATHENA",
+    "AURORA",
+    "AURORA_POSTGRESQL",
+    "AWS_IOT_ANALYTICS",
+    "DATABRICKS",
+    "DENODO",
+    "DREMIO",
+    "DYNAMODB",
+    "SAPHANA",
+    "DB2_AS400",
+    "EXASOL",
+    "FILE",
+    "GITHUB",
+    "JIRA",
+    "MARIADB",
+    "MYSQL",
+    "ORACLE",
+    "POSTGRESQL",
+    "PRESTO",
+    "REDSHIFT",
+    "S3",
+    "S3_TABLES",
+    "SALESFORCE",
+    "SERVICENOW",
+    "SNOWFLAKE",
+    "SPARK",
+    "SQLSERVER",
+    "TERADATA",
+    "TIMESTREAM",
+    "TWITTER",
+    "BIGQUERY",
+    "GOOGLE_ANALYTICS",
+    "TRINO",
+    "STARBURST",
+    "MONGO",
+    "MONGO_ATLAS",
+    "DOCUMENTDB",
+    "APPFLOW",
+    "IMPALA",
+    "GLUE"
+   ],
+   "type": "string"
+  },
+  "DatabricksParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    },
+    "SqlEndpointPath": {
+     "maxLength": 4096,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "required": [
+    "Host",
+    "Port",
+    "SqlEndpointPath"
+   ],
+   "type": "object"
+  },
+  "IdentityCenterConfiguration": {
+   "additionalProperties": false,
+   "properties": {
+    "EnableIdentityPropagation": {
+     "default": null,
+     "type": "boolean"
+    }
+   },
+   "type": "object"
+  },
+  "ManifestFileLocation": {
+   "additionalProperties": false,
+   "properties": {
+    "Bucket": {
+     "maxLength": 1024,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Key": {
+     "maxLength": 1024,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "required": [
+    "Bucket",
+    "Key"
+   ],
+   "type": "object"
+  },
+  "MariaDbParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Database",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "MySqlParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Database",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "OracleParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Database",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "PostgreSqlParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Database",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "PrestoParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Catalog": {
+     "maxLength": 128,
+     "minLength": 0,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Catalog",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "RdsParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "InstanceId": {
+     "maxLength": 64,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "required": [
+    "Database",
+    "InstanceId"
+   ],
+   "type": "object"
+  },
+  "RedshiftIAMParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "AutoCreateDatabaseUser": {
+     "default": false,
+     "type": "boolean"
+    },
+    "DatabaseGroups": {
+     "items": {
+      "maxLength": 64,
+      "minLength": 1,
+      "type": "string"
+     },
+     "maxItems": 50,
+     "minItems": 1,
+     "type": "array"
+    },
+    "DatabaseUser": {
+     "maxLength": 64,
+     "minLength": 1,
+     "type": "string"
+    },
+    "RoleArn": {
+     "maxLength": 2048,
+     "minLength": 20,
+     "type": "string"
+    }
+   },
+   "required": [
+    "RoleArn"
+   ],
+   "type": "object"
+  },
+  "RedshiftParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "ClusterId": {
+     "maxLength": 64,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "IAMParameters": {
+     "$ref": "#/definitions/RedshiftIAMParameters"
+    },
+    "IdentityCenterConfiguration": {
+     "$ref": "#/definitions/IdentityCenterConfiguration"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 0,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Database"
+   ],
+   "type": "object"
+  },
+  "ResourcePermission": {
+   "additionalProperties": false,
+   "properties": {
+    "Actions": {
+     "items": {
+      "type": "string"
+     },
+     "maxItems": 20,
+     "minItems": 1,
+     "type": "array"
+    },
+    "Principal": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Resource": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Actions",
+    "Principal"
+   ],
+   "type": "object"
+  },
+  "ResourceStatus": {
+   "enum": [
+    "CREATION_IN_PROGRESS",
+    "CREATION_SUCCESSFUL",
+    "CREATION_FAILED",
+    "UPDATE_IN_PROGRESS",
+    "UPDATE_SUCCESSFUL",
+    "UPDATE_FAILED",
+    "DELETED"
+   ],
+   "type": "string"
+  },
+  "S3Parameters": {
+   "additionalProperties": false,
+   "properties": {
+    "ManifestFileLocation": {
+     "$ref": "#/definitions/ManifestFileLocation"
+    },
+    "RoleArn": {
+     "maxLength": 2048,
+     "minLength": 20,
+     "type": "string"
+    }
+   },
+   "required": [
+    "ManifestFileLocation"
+   ],
+   "type": "object"
+  },
+  "SnowflakeParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Warehouse": {
+     "maxLength": 128,
+     "minLength": 0,
+     "type": "string"
+    }
+   },
+   "required": [
+    "Database",
+    "Host",
+    "Warehouse"
+   ],
+   "type": "object"
+  },
+  "SparkParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "SqlServerParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Database",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "SslProperties": {
+   "additionalProperties": false,
+   "properties": {
+    "DisableSsl": {
+     "default": false,
+     "type": "boolean"
+    }
+   },
+   "type": "object"
+  },
+  "StarburstParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Catalog": {
+     "maxLength": 128,
+     "minLength": 0,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    },
+    "ProductType": {
+     "$ref": "#/definitions/StarburstProductType"
+    }
+   },
+   "required": [
+    "Catalog",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "StarburstProductType": {
+   "enum": [
+    "GALAXY",
+    "ENTERPRISE"
+   ],
+   "type": "string"
+  },
+  "Tag": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Value": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "required": [
+    "Key",
+    "Value"
+   ],
+   "type": "object"
+  },
+  "TeradataParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Database": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Database",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "TrinoParameters": {
+   "additionalProperties": false,
+   "properties": {
+    "Catalog": {
+     "maxLength": 128,
+     "minLength": 0,
+     "type": "string"
+    },
+    "Host": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Port": {
+     "default": 0,
+     "maximum": 65535,
+     "minimum": 1,
+     "type": "number"
+    }
+   },
+   "required": [
+    "Catalog",
+    "Host",
+    "Port"
+   ],
+   "type": "object"
+  },
+  "VpcConnectionProperties": {
+   "additionalProperties": false,
+   "properties": {
+    "VpcConnectionArn": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "VpcConnectionArn"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/AwsAccountId",
+  "/properties/DataSourceId"
+ ],
+ "properties": {
+  "AlternateDataSourceParameters": {
+   "items": {
+    "$ref": "#/definitions/DataSourceParameters"
+   },
+   "maxItems": 50,
+   "minItems": 1,
+   "type": "array"
+  },
+  "Arn": {
+   "type": "string"
+  },
+  "AwsAccountId": {
+   "maxLength": 12,
+   "minLength": 12,
+   "pattern": "^[0-9]{12}$",
+   "type": "string"
+  },
+  "CreatedTime": {
+   "format": "date-time",
+   "type": "string"
+  },
+  "Credentials": {
+   "$ref": "#/definitions/DataSourceCredentials"
+  },
+  "DataSourceId": {
+   "type": "string"
+  },
+  "DataSourceParameters": {
+   "$ref": "#/definitions/DataSourceParameters"
+  },
+  "ErrorInfo": {
+   "$ref": "#/definitions/DataSourceErrorInfo"
+  },
+  "FolderArns": {
+   "items": {
+    "type": "string"
+   },
+   "maxItems": 10,
+   "minItems": 0,
+   "type": "array"
+  },
+  "LastUpdatedTime": {
+   "format": "date-time",
+   "type": "string"
+  },
+  "Name": {
+   "maxLength": 128,
+   "minLength": 1,
+   "type": "string"
+  },
+  "Permissions": {
+   "items": {
+    "$ref": "#/definitions/ResourcePermission"
+   },
+   "maxItems": 64,
+   "minItems": 1,
+   "type": "array"
+  },
+  "SslProperties": {
+   "$ref": "#/definitions/SslProperties"
+  },
+  "Status": {
+   "$ref": "#/definitions/ResourceStatus"
+  },
+  "Tags": {
+   "items": {
+    "$ref": "#/definitions/Tag"
+   },
+   "maxItems": 200,
+   "minItems": 1,
+   "type": "array"
+  },
+  "Type": {
+   "$ref": "#/definitions/DataSourceType"
+  },
+  "VpcConnectionProperties": {
+   "$ref": "#/definitions/VpcConnectionProperties"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Arn",
+  "/properties/CreatedTime",
+  "/properties/LastUpdatedTime",
+  "/properties/Status"
+ ],
+ "required": [
+  "Name",
+  "Type"
+ ],
+ "sourceUrl": "https://github.com/aws-cloudformation/aws-cloudformation-resource-providers-quicksight",
+ "typeName": "AWS::QuickSight::DataSource",
+ "writeOnlyProperties": [
+  "/properties/Credentials",
+  "/properties/FolderArns"
+ ]
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-amazonmq-configuration.json

@@ -0,0 +1,85 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/EngineType",
+  "/properties/Name",
+  "/properties/AuthenticationStrategy",
+  "/properties/EngineVersion"
+ ],
+ "definitions": {
+  "TagsEntry": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "type": "string"
+    },
+    "Value": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Value",
+    "Key"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Arn": {
+   "type": "string"
+  },
+  "AuthenticationStrategy": {
+   "enum": [
+    "LDAP",
+    "SIMPLE"
+   ],
+   "type": "string"
+  },
+  "Data": {
+   "type": "string"
+  },
+  "Description": {
+   "type": "string"
+  },
+  "EngineType": {
+   "enum": [
+    "ACTIVEMQ",
+    "RABBITMQ"
+   ],
+   "type": "string"
+  },
+  "EngineVersion": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "Name": {
+   "type": "string"
+  },
+  "Revision": {
+   "type": "integer"
+  },
+  "Tags": {
+   "items": {
+    "$ref": "#/definitions/TagsEntry"
+   },
+   "type": "array",
+   "uniqueItems": false
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Revision",
+  "/properties/Id",
+  "/properties/Arn"
+ ],
+ "required": [
+  "EngineType",
+  "Data",
+  "Name"
+ ],
+ "typeName": "AWS::AmazonMQ::Configuration"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-amazonmq-configurationassociation.json

@@ -0,0 +1,46 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/Broker"
+ ],
+ "definitions": {
+  "ConfigurationId": {
+   "additionalProperties": false,
+   "properties": {
+    "Id": {
+     "type": "string"
+    },
+    "Revision": {
+     "type": "integer"
+    }
+   },
+   "required": [
+    "Revision",
+    "Id"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Broker": {
+   "type": "string"
+  },
+  "Configuration": {
+   "$ref": "#/definitions/ConfigurationId"
+  },
+  "Id": {
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "Broker",
+  "Configuration"
+ ],
+ "typeName": "AWS::AmazonMQ::ConfigurationAssociation"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-apigatewayv2-api.json

@@ -0,0 +1,143 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ProtocolType"
+ ],
+ "definitions": {
+  "BodyS3Location": {
+   "additionalProperties": false,
+   "properties": {
+    "Bucket": {
+     "type": "string"
+    },
+    "Etag": {
+     "type": "string"
+    },
+    "Key": {
+     "type": "string"
+    },
+    "Version": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "Cors": {
+   "additionalProperties": false,
+   "properties": {
+    "AllowCredentials": {
+     "type": "boolean"
+    },
+    "AllowHeaders": {
+     "items": {
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "AllowMethods": {
+     "items": {
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "AllowOrigins": {
+     "items": {
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "ExposeHeaders": {
+     "items": {
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "MaxAge": {
+     "type": "integer"
+    }
+   },
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "ApiEndpoint": {
+   "type": "string"
+  },
+  "ApiKeySelectionExpression": {
+   "type": "string"
+  },
+  "BasePath": {
+   "type": "string"
+  },
+  "Body": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  },
+  "BodyS3Location": {
+   "$ref": "#/definitions/BodyS3Location"
+  },
+  "CorsConfiguration": {
+   "$ref": "#/definitions/Cors"
+  },
+  "CredentialsArn": {
+   "type": "string"
+  },
+  "Description": {
+   "type": "string"
+  },
+  "DisableExecuteApiEndpoint": {
+   "type": "boolean"
+  },
+  "DisableSchemaValidation": {
+   "type": "boolean"
+  },
+  "FailOnWarnings": {
+   "type": "boolean"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "Name": {
+   "type": "string"
+  },
+  "ProtocolType": {
+   "type": "string"
+  },
+  "RouteKey": {
+   "type": "string"
+  },
+  "RouteSelectionExpression": {
+   "type": "string"
+  },
+  "Tags": {
+   "additionalProperties": false,
+   "patternProperties": {
+    ".*": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "Target": {
+   "type": "string"
+  },
+  "Version": {
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id",
+  "/properties/ApiEndpoint"
+ ],
+ "typeName": "AWS::ApiGatewayV2::Api"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-apigatewayv2-authorizer.json

@@ -0,0 +1,78 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ApiId"
+ ],
+ "definitions": {
+  "JWTConfiguration": {
+   "additionalProperties": false,
+   "properties": {
+    "Audience": {
+     "items": {
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "Issuer": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "ApiId": {
+   "type": "string"
+  },
+  "AuthorizerCredentialsArn": {
+   "type": "string"
+  },
+  "AuthorizerPayloadFormatVersion": {
+   "type": "string"
+  },
+  "AuthorizerResultTtlInSeconds": {
+   "type": "integer"
+  },
+  "AuthorizerType": {
+   "type": "string"
+  },
+  "AuthorizerUri": {
+   "type": "string"
+  },
+  "EnableSimpleResponses": {
+   "type": "boolean"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "IdentitySource": {
+   "items": {
+    "type": "string"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "IdentityValidationExpression": {
+   "type": "string"
+  },
+  "JwtConfiguration": {
+   "$ref": "#/definitions/JWTConfiguration"
+  },
+  "Name": {
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "AuthorizerType",
+  "ApiId",
+  "Name"
+ ],
+ "typeName": "AWS::ApiGatewayV2::Authorizer"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-apigatewayv2-deployment.json

@@ -0,0 +1,30 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ApiId"
+ ],
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "ApiId": {
+   "type": "string"
+  },
+  "Description": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "StageName": {
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "ApiId"
+ ],
+ "typeName": "AWS::ApiGatewayV2::Deployment"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-apigatewayv2-integrationresponse.json

@@ -0,0 +1,49 @@
+{
+ "additionalProperties": false,
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "ApiId": {
+   "type": "string"
+  },
+  "ContentHandlingStrategy": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "IntegrationId": {
+   "type": "string"
+  },
+  "IntegrationResponseKey": {
+   "type": "string"
+  },
+  "ResponseParameters": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  },
+  "ResponseTemplates": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  },
+  "TemplateSelectionExpression": {
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "IntegrationId",
+  "IntegrationResponseKey",
+  "ApiId"
+ ],
+ "typeName": "AWS::ApiGatewayV2::IntegrationResponse"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-apigatewayv2-model.json

@@ -0,0 +1,42 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ApiId"
+ ],
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "ApiId": {
+   "type": "string"
+  },
+  "ContentType": {
+   "type": "string"
+  },
+  "Description": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "Name": {
+   "type": "string"
+  },
+  "Schema": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "ApiId",
+  "Schema",
+  "Name"
+ ],
+ "typeName": "AWS::ApiGatewayV2::Model"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-apigatewayv2-route.json

@@ -0,0 +1,70 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ApiId"
+ ],
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "ApiId": {
+   "type": "string"
+  },
+  "ApiKeyRequired": {
+   "type": "boolean"
+  },
+  "AuthorizationScopes": {
+   "items": {
+    "type": "string"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "AuthorizationType": {
+   "type": "string"
+  },
+  "AuthorizerId": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "ModelSelectionExpression": {
+   "type": "string"
+  },
+  "OperationName": {
+   "type": "string"
+  },
+  "RequestModels": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  },
+  "RequestParameters": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  },
+  "RouteKey": {
+   "type": "string"
+  },
+  "RouteResponseSelectionExpression": {
+   "type": "string"
+  },
+  "Target": {
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "RouteKey",
+  "ApiId"
+ ],
+ "typeName": "AWS::ApiGatewayV2::Route"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-apigatewayv2-routeresponse.json

@@ -0,0 +1,50 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ApiId",
+  "/properties/RouteId"
+ ],
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "ApiId": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "ModelSelectionExpression": {
+   "type": "string"
+  },
+  "ResponseModels": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  },
+  "ResponseParameters": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  },
+  "RouteId": {
+   "type": "string"
+  },
+  "RouteResponseKey": {
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "RouteResponseKey",
+  "RouteId",
+  "ApiId"
+ ],
+ "typeName": "AWS::ApiGatewayV2::RouteResponse"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-apigatewayv2-vpclink.json

@@ -0,0 +1,51 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/SecurityGroupIds",
+  "/properties/SubnetIds"
+ ],
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Id": {
+   "type": "string"
+  },
+  "Name": {
+   "type": "string"
+  },
+  "SecurityGroupIds": {
+   "format": "AWS::EC2::SecurityGroup.Ids",
+   "items": {
+    "format": "AWS::EC2::SecurityGroup.GroupId",
+    "type": "string"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "SubnetIds": {
+   "items": {
+    "type": "string"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "Tags": {
+   "additionalProperties": false,
+   "patternProperties": {
+    ".*": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "SubnetIds",
+  "Name"
+ ],
+ "typeName": "AWS::ApiGatewayV2::VpcLink"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-applicationautoscaling-scalabletarget.json

@@ -0,0 +1,155 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ResourceId",
+  "/properties/ScalableDimension",
+  "/properties/ServiceNamespace"
+ ],
+ "definitions": {
+  "ScalableTargetAction": {
+   "additionalProperties": false,
+   "properties": {
+    "MaxCapacity": {
+     "type": "integer"
+    },
+    "MinCapacity": {
+     "type": "integer"
+    }
+   },
+   "type": "object"
+  },
+  "ScheduledAction": {
+   "additionalProperties": false,
+   "properties": {
+    "EndTime": {
+     "type": "string"
+    },
+    "ScalableTargetAction": {
+     "$ref": "#/definitions/ScalableTargetAction"
+    },
+    "Schedule": {
+     "type": "string"
+    },
+    "ScheduledActionName": {
+     "type": "string"
+    },
+    "StartTime": {
+     "type": "string"
+    },
+    "Timezone": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "ScheduledActionName",
+    "Schedule"
+   ],
+   "type": "object"
+  },
+  "SuspendedState": {
+   "additionalProperties": false,
+   "properties": {
+    "DynamicScalingInSuspended": {
+     "type": "boolean"
+    },
+    "DynamicScalingOutSuspended": {
+     "type": "boolean"
+    },
+    "ScheduledScalingSuspended": {
+     "type": "boolean"
+    }
+   },
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Id": {
+   "type": "string"
+  },
+  "MaxCapacity": {
+   "type": "integer"
+  },
+  "MinCapacity": {
+   "type": "integer"
+  },
+  "ResourceId": {
+   "type": "string"
+  },
+  "RoleARN": {
+   "type": "string"
+  },
+  "ScalableDimension": {
+   "enum": [
+    "appstream:fleet:DesiredCapacity",
+    "cassandra:table:ReadCapacityUnits",
+    "cassandra:table:WriteCapacityUnits",
+    "comprehend:document-classifier-endpoint:DesiredInferenceUnits",
+    "comprehend:entity-recognizer-endpoint:DesiredInferenceUnits",
+    "custom-resource:ResourceType:Property",
+    "dynamodb:index:ReadCapacityUnits",
+    "dynamodb:index:WriteCapacityUnits",
+    "dynamodb:table:ReadCapacityUnits",
+    "dynamodb:table:WriteCapacityUnits",
+    "ec2:spot-fleet-request:TargetCapacity",
+    "ecs:service:DesiredCount",
+    "elasticache:replication-group:NodeGroups",
+    "elasticache:replication-group:Replicas",
+    "elasticmapreduce:instancegroup:InstanceCount",
+    "kafka:broker-storage:VolumeSize",
+    "lambda:function:ProvisionedConcurrency",
+    "neptune:cluster:ReadReplicaCount",
+    "rds:cluster:ReadReplicaCount",
+    "sagemaker:inference-component:DesiredCopyCount",
+    "sagemaker:variant:DesiredInstanceCount",
+    "sagemaker:variant:DesiredProvisionedConcurrency",
+    "workspaces:workspacespool:DesiredUserSessions"
+   ],
+   "type": "string"
+  },
+  "ScheduledActions": {
+   "items": {
+    "$ref": "#/definitions/ScheduledAction"
+   },
+   "type": "array",
+   "uniqueItems": true
+  },
+  "ServiceNamespace": {
+   "enum": [
+    "appstream",
+    "cassandra",
+    "comprehend",
+    "custom-resource",
+    "dynamodb",
+    "ec2",
+    "ecs",
+    "elasticache",
+    "elasticmapreduce",
+    "kafka",
+    "lambda",
+    "neptune",
+    "rds",
+    "sagemaker",
+    "workspaces"
+   ],
+   "type": "string"
+  },
+  "SuspendedState": {
+   "$ref": "#/definitions/SuspendedState"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "ResourceId",
+  "ServiceNamespace",
+  "ScalableDimension",
+  "MinCapacity",
+  "RoleARN",
+  "MaxCapacity"
+ ],
+ "typeName": "AWS::ApplicationAutoScaling::ScalableTarget"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-autoscaling-launchconfiguration.json

@@ -0,0 +1,199 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/RamDiskId",
+  "/properties/InstanceType",
+  "/properties/InstanceMonitoring",
+  "/properties/ImageId",
+  "/properties/BlockDeviceMappings",
+  "/properties/SpotPrice",
+  "/properties/ClassicLinkVPCId",
+  "/properties/InstanceId",
+  "/properties/KeyName",
+  "/properties/PlacementTenancy",
+  "/properties/LaunchConfigurationName",
+  "/properties/IamInstanceProfile",
+  "/properties/UserData",
+  "/properties/AssociatePublicIpAddress",
+  "/properties/KernelId",
+  "/properties/EbsOptimized",
+  "/properties/SecurityGroups",
+  "/properties/MetadataOptions",
+  "/properties/ClassicLinkVPCSecurityGroups"
+ ],
+ "definitions": {
+  "BlockDevice": {
+   "additionalProperties": false,
+   "properties": {
+    "DeleteOnTermination": {
+     "type": "boolean"
+    },
+    "Encrypted": {
+     "type": "boolean"
+    },
+    "Iops": {
+     "type": "integer"
+    },
+    "SnapshotId": {
+     "type": "string"
+    },
+    "Throughput": {
+     "type": "integer"
+    },
+    "VolumeSize": {
+     "type": "integer"
+    },
+    "VolumeType": {
+     "enum": [
+      "gp2",
+      "gp3",
+      "io1",
+      "io2",
+      "sc1",
+      "st1",
+      "standard"
+     ],
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "BlockDeviceMapping": {
+   "additionalProperties": false,
+   "properties": {
+    "DeviceName": {
+     "type": "string"
+    },
+    "Ebs": {
+     "$ref": "#/definitions/BlockDevice"
+    },
+    "NoDevice": {
+     "type": "boolean"
+    },
+    "VirtualName": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "DeviceName"
+   ],
+   "requiredXor": [
+    "VirtualName",
+    "Ebs",
+    "NoDevice"
+   ],
+   "type": "object"
+  },
+  "MetadataOptions": {
+   "additionalProperties": false,
+   "properties": {
+    "HttpEndpoint": {
+     "enum": [
+      "disabled",
+      "enabled"
+     ],
+     "type": "string"
+    },
+    "HttpPutResponseHopLimit": {
+     "type": "integer"
+    },
+    "HttpTokens": {
+     "enum": [
+      "optional",
+      "required"
+     ],
+     "type": "string"
+    }
+   },
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "AssociatePublicIpAddress": {
+   "type": "boolean"
+  },
+  "BlockDeviceMappings": {
+   "items": {
+    "$ref": "#/definitions/BlockDeviceMapping"
+   },
+   "type": "array",
+   "uniqueItems": true
+  },
+  "ClassicLinkVPCId": {
+   "type": "string"
+  },
+  "ClassicLinkVPCSecurityGroups": {
+   "items": {
+    "type": "string"
+   },
+   "type": "array",
+   "uniqueItems": true
+  },
+  "EbsOptimized": {
+   "type": "boolean"
+  },
+  "IamInstanceProfile": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "ImageId": {
+   "format": "AWS::EC2::Image.Id",
+   "type": "string"
+  },
+  "InstanceId": {
+   "type": "string"
+  },
+  "InstanceMonitoring": {
+   "type": "boolean"
+  },
+  "InstanceType": {
+   "type": "string"
+  },
+  "KernelId": {
+   "type": "string"
+  },
+  "KeyName": {
+   "type": "string"
+  },
+  "LaunchConfigurationName": {
+   "type": "string"
+  },
+  "MetadataOptions": {
+   "$ref": "#/definitions/MetadataOptions"
+  },
+  "PlacementTenancy": {
+   "type": "string"
+  },
+  "RamDiskId": {
+   "type": "string"
+  },
+  "SecurityGroups": {
+   "format": "AWS::EC2::SecurityGroup.Ids",
+   "items": {
+    "format": "AWS::EC2::SecurityGroup.GroupId",
+    "type": "string"
+   },
+   "type": "array",
+   "uniqueItems": true
+  },
+  "SpotPrice": {
+   "type": "string"
+  },
+  "UserData": {
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "ImageId",
+  "InstanceType"
+ ],
+ "typeName": "AWS::AutoScaling::LaunchConfiguration"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-autoscaling-scalingpolicy.json

@@ -0,0 +1,429 @@
+{
+ "additionalProperties": false,
+ "definitions": {
+  "CustomizedMetricSpecification": {
+   "additionalProperties": false,
+   "properties": {
+    "Dimensions": {
+     "items": {
+      "$ref": "#/definitions/MetricDimension"
+     },
+     "type": "array",
+     "uniqueItems": true
+    },
+    "MetricName": {
+     "type": "string"
+    },
+    "Namespace": {
+     "type": "string"
+    },
+    "Statistic": {
+     "enum": [
+      "Average",
+      "Maximum",
+      "Minimum",
+      "SampleCount",
+      "Sum"
+     ],
+     "type": "string"
+    },
+    "Unit": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "MetricName",
+    "Statistic",
+    "Namespace"
+   ],
+   "type": "object"
+  },
+  "Metric": {
+   "additionalProperties": false,
+   "properties": {
+    "Dimensions": {
+     "items": {
+      "$ref": "#/definitions/MetricDimension"
+     },
+     "type": "array",
+     "uniqueItems": true
+    },
+    "MetricName": {
+     "type": "string"
+    },
+    "Namespace": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "MetricName",
+    "Namespace"
+   ],
+   "type": "object"
+  },
+  "MetricDataQuery": {
+   "additionalProperties": false,
+   "properties": {
+    "Expression": {
+     "type": "string"
+    },
+    "Id": {
+     "type": "string"
+    },
+    "Label": {
+     "type": "string"
+    },
+    "MetricStat": {
+     "$ref": "#/definitions/MetricStat"
+    },
+    "ReturnData": {
+     "type": "boolean"
+    }
+   },
+   "required": [
+    "Id"
+   ],
+   "type": "object"
+  },
+  "MetricDimension": {
+   "additionalProperties": false,
+   "properties": {
+    "Name": {
+     "type": "string"
+    },
+    "Value": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Value",
+    "Name"
+   ],
+   "type": "object"
+  },
+  "MetricStat": {
+   "additionalProperties": false,
+   "properties": {
+    "Metric": {
+     "$ref": "#/definitions/Metric"
+    },
+    "Stat": {
+     "type": "string"
+    },
+    "Unit": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Stat",
+    "Metric"
+   ],
+   "type": "object"
+  },
+  "PredefinedMetricSpecification": {
+   "additionalProperties": false,
+   "properties": {
+    "PredefinedMetricType": {
+     "enum": [
+      "ALBRequestCountPerTarget",
+      "ASGAverageCPUUtilization",
+      "ASGAverageNetworkIn",
+      "ASGAverageNetworkOut"
+     ],
+     "type": "string"
+    },
+    "ResourceLabel": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "PredefinedMetricType"
+   ],
+   "type": "object"
+  },
+  "PredictiveScalingConfiguration": {
+   "additionalProperties": false,
+   "properties": {
+    "MaxCapacityBreachBehavior": {
+     "enum": [
+      "HonorMaxCapacity",
+      "IncreaseMaxCapacity"
+     ],
+     "type": "string"
+    },
+    "MaxCapacityBuffer": {
+     "type": "integer"
+    },
+    "MetricSpecifications": {
+     "items": {
+      "$ref": "#/definitions/PredictiveScalingMetricSpecification"
+     },
+     "type": "array",
+     "uniqueItems": true
+    },
+    "Mode": {
+     "enum": [
+      "ForecastAndScale",
+      "ForecastOnly"
+     ],
+     "type": "string"
+    },
+    "SchedulingBufferTime": {
+     "type": "integer"
+    }
+   },
+   "required": [
+    "MetricSpecifications"
+   ],
+   "type": "object"
+  },
+  "PredictiveScalingCustomizedCapacityMetric": {
+   "additionalProperties": false,
+   "properties": {
+    "MetricDataQueries": {
+     "items": {
+      "$ref": "#/definitions/MetricDataQuery"
+     },
+     "type": "array",
+     "uniqueItems": true
+    }
+   },
+   "required": [
+    "MetricDataQueries"
+   ],
+   "type": "object"
+  },
+  "PredictiveScalingCustomizedLoadMetric": {
+   "additionalProperties": false,
+   "properties": {
+    "MetricDataQueries": {
+     "items": {
+      "$ref": "#/definitions/MetricDataQuery"
+     },
+     "type": "array",
+     "uniqueItems": true
+    }
+   },
+   "required": [
+    "MetricDataQueries"
+   ],
+   "type": "object"
+  },
+  "PredictiveScalingCustomizedScalingMetric": {
+   "additionalProperties": false,
+   "properties": {
+    "MetricDataQueries": {
+     "items": {
+      "$ref": "#/definitions/MetricDataQuery"
+     },
+     "type": "array",
+     "uniqueItems": true
+    }
+   },
+   "required": [
+    "MetricDataQueries"
+   ],
+   "type": "object"
+  },
+  "PredictiveScalingMetricSpecification": {
+   "additionalProperties": false,
+   "properties": {
+    "CustomizedCapacityMetricSpecification": {
+     "$ref": "#/definitions/PredictiveScalingCustomizedCapacityMetric"
+    },
+    "CustomizedLoadMetricSpecification": {
+     "$ref": "#/definitions/PredictiveScalingCustomizedLoadMetric"
+    },
+    "CustomizedScalingMetricSpecification": {
+     "$ref": "#/definitions/PredictiveScalingCustomizedScalingMetric"
+    },
+    "PredefinedLoadMetricSpecification": {
+     "$ref": "#/definitions/PredictiveScalingPredefinedLoadMetric"
+    },
+    "PredefinedMetricPairSpecification": {
+     "$ref": "#/definitions/PredictiveScalingPredefinedMetricPair"
+    },
+    "PredefinedScalingMetricSpecification": {
+     "$ref": "#/definitions/PredictiveScalingPredefinedScalingMetric"
+    },
+    "TargetValue": {
+     "type": "number"
+    }
+   },
+   "required": [
+    "TargetValue"
+   ],
+   "type": "object"
+  },
+  "PredictiveScalingPredefinedLoadMetric": {
+   "additionalProperties": false,
+   "properties": {
+    "PredefinedMetricType": {
+     "enum": [
+      "ALBTargetGroupRequestCount",
+      "ASGTotalCPUUtilization",
+      "ASGTotalNetworkIn",
+      "ASGTotalNetworkOut"
+     ],
+     "type": "string"
+    },
+    "ResourceLabel": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "PredefinedMetricType"
+   ],
+   "type": "object"
+  },
+  "PredictiveScalingPredefinedMetricPair": {
+   "additionalProperties": false,
+   "properties": {
+    "PredefinedMetricType": {
+     "enum": [
+      "ALBRequestCount",
+      "ASGCPUUtilization",
+      "ASGNetworkIn",
+      "ASGNetworkOut"
+     ],
+     "type": "string"
+    },
+    "ResourceLabel": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "PredefinedMetricType"
+   ],
+   "type": "object"
+  },
+  "PredictiveScalingPredefinedScalingMetric": {
+   "additionalProperties": false,
+   "properties": {
+    "PredefinedMetricType": {
+     "enum": [
+      "ALBRequestCountPerTarget",
+      "ASGAverageCPUUtilization",
+      "ASGAverageNetworkIn",
+      "ASGAverageNetworkOut"
+     ],
+     "type": "string"
+    },
+    "ResourceLabel": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "PredefinedMetricType"
+   ],
+   "type": "object"
+  },
+  "StepAdjustment": {
+   "additionalProperties": false,
+   "properties": {
+    "MetricIntervalLowerBound": {
+     "type": "number"
+    },
+    "MetricIntervalUpperBound": {
+     "type": "number"
+    },
+    "ScalingAdjustment": {
+     "type": "integer"
+    }
+   },
+   "required": [
+    "ScalingAdjustment"
+   ],
+   "type": "object"
+  },
+  "TargetTrackingConfiguration": {
+   "additionalProperties": false,
+   "properties": {
+    "CustomizedMetricSpecification": {
+     "$ref": "#/definitions/CustomizedMetricSpecification"
+    },
+    "DisableScaleIn": {
+     "type": "boolean"
+    },
+    "PredefinedMetricSpecification": {
+     "$ref": "#/definitions/PredefinedMetricSpecification"
+    },
+    "TargetValue": {
+     "type": "number"
+    }
+   },
+   "required": [
+    "TargetValue"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "AdjustmentType": {
+   "enum": [
+    "ChangeInCapacity",
+    "ExactCapacity",
+    "PercentChangeInCapacity"
+   ],
+   "type": "string"
+  },
+  "AutoScalingGroupName": {
+   "type": "string"
+  },
+  "Cooldown": {
+   "type": "string"
+  },
+  "EstimatedInstanceWarmup": {
+   "type": "integer"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "MetricAggregationType": {
+   "enum": [
+    "Average",
+    "Maximum",
+    "Minimum"
+   ],
+   "type": "string"
+  },
+  "MinAdjustmentMagnitude": {
+   "type": "integer"
+  },
+  "PolicyType": {
+   "enum": [
+    "PredictiveScaling",
+    "SimpleScaling",
+    "StepScaling",
+    "TargetTrackingScaling"
+   ],
+   "type": "string"
+  },
+  "PredictiveScalingConfiguration": {
+   "$ref": "#/definitions/PredictiveScalingConfiguration"
+  },
+  "ScalingAdjustment": {
+   "type": "integer"
+  },
+  "StepAdjustments": {
+   "items": {
+    "$ref": "#/definitions/StepAdjustment"
+   },
+   "type": "array",
+   "uniqueItems": true
+  },
+  "TargetTrackingConfiguration": {
+   "$ref": "#/definitions/TargetTrackingConfiguration"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "AutoScalingGroupName"
+ ],
+ "typeName": "AWS::AutoScaling::ScalingPolicy"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-cassandra-keyspace.json

@@ -0,0 +1,119 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ReplicationSpecification",
+  "/properties/KeyspaceName"
+ ],
+ "definitions": {
+  "RegionList": {
+   "insertionOrder": false,
+   "items": {
+    "enum": [
+     "ap-northeast-1",
+     "ap-northeast-2",
+     "ap-south-1",
+     "ap-southeast-1",
+     "ap-southeast-2",
+     "ca-central-1",
+     "eu-central-1",
+     "eu-north-1",
+     "eu-west-1",
+     "eu-west-2",
+     "eu-west-3",
+     "sa-east-1",
+     "us-east-1",
+     "us-east-2",
+     "us-west-1",
+     "us-west-2"
+    ],
+    "type": "string"
+   },
+   "maxItems": 6,
+   "minItems": 2,
+   "type": "array",
+   "uniqueItems": true
+  },
+  "ReplicationSpecification": {
+   "additionalProperties": false,
+   "default": {
+    "properties": {
+     "ReplicationStrategy": {
+      "const": "SINGLE_REGION",
+      "type": "string"
+     }
+    }
+   },
+   "dependencies": {
+    "RegionList": [
+     "ReplicationStrategy"
+    ]
+   },
+   "properties": {
+    "RegionList": {
+     "$ref": "#/definitions/RegionList"
+    },
+    "ReplicationStrategy": {
+     "enum": [
+      "SINGLE_REGION",
+      "MULTI_REGION"
+     ],
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "Tag": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "maxLength": 128,
+     "minLength": 1,
+     "type": "string"
+    },
+    "Value": {
+     "maxLength": 256,
+     "minLength": 1,
+     "type": "string"
+    }
+   },
+   "required": [
+    "Value",
+    "Key"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/KeyspaceName"
+ ],
+ "properties": {
+  "ClientSideTimestampsEnabled": {
+   "type": "boolean"
+  },
+  "KeyspaceName": {
+   "pattern": "^[a-zA-Z0-9][a-zA-Z0-9_]{1,47}$",
+   "type": "string"
+  },
+  "ReplicationSpecification": {
+   "$ref": "#/definitions/ReplicationSpecification"
+  },
+  "Tags": {
+   "items": {
+    "$ref": "#/definitions/Tag"
+   },
+   "maxItems": 50,
+   "minItems": 0,
+   "type": "array",
+   "uniqueItems": true
+  }
+ },
+ "required": [],
+ "tagging": {
+  "cloudFormationSystemTags": true,
+  "tagOnCreate": true,
+  "tagProperty": "/properties/Tags",
+  "tagUpdatable": true,
+  "taggable": true
+ },
+ "typeName": "AWS::Cassandra::Keyspace"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-cloudformation-stack.json

@@ -0,0 +1,71 @@
+{
+ "additionalProperties": false,
+ "definitions": {
+  "Tag": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "type": "string"
+    },
+    "Value": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Value",
+    "Key"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Id": {
+   "type": "string"
+  },
+  "NotificationARNs": {
+   "items": {
+    "type": "string"
+   },
+   "type": "array",
+   "uniqueItems": true
+  },
+  "Parameters": {
+   "patternProperties": {
+    "[a-zA-Z0-9]+": {
+     "type": [
+      "string",
+      "number",
+      "integer",
+      "object",
+      "array",
+      "boolean"
+     ]
+    }
+   },
+   "type": "object"
+  },
+  "Tags": {
+   "items": {
+    "$ref": "#/definitions/Tag"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "TemplateURL": {
+   "type": "string"
+  },
+  "TimeoutInMinutes": {
+   "type": "integer"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "TemplateURL"
+ ],
+ "typeName": "AWS::CloudFormation::Stack"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-codebuild-project.json

@@ -0,0 +1,596 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/Name"
+ ],
+ "definitions": {
+  "Artifacts": {
+   "additionalProperties": false,
+   "properties": {
+    "ArtifactIdentifier": {
+     "type": "string"
+    },
+    "EncryptionDisabled": {
+     "type": "boolean"
+    },
+    "Location": {
+     "type": "string"
+    },
+    "Name": {
+     "type": "string"
+    },
+    "NamespaceType": {
+     "type": "string"
+    },
+    "OverrideArtifactName": {
+     "type": "boolean"
+    },
+    "Packaging": {
+     "enum": [
+      "NONE",
+      "ZIP"
+     ],
+     "type": "string"
+    },
+    "Path": {
+     "type": "string"
+    },
+    "Type": {
+     "enum": [
+      "CODEPIPELINE",
+      "NO_ARTIFACTS",
+      "S3"
+     ],
+     "type": "string"
+    }
+   },
+   "required": [
+    "Type"
+   ],
+   "type": "object"
+  },
+  "BatchRestrictions": {
+   "additionalProperties": false,
+   "properties": {
+    "ComputeTypesAllowed": {
+     "items": {
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "MaximumBuildsAllowed": {
+     "type": "integer"
+    }
+   },
+   "type": "object"
+  },
+  "BuildStatusConfig": {
+   "additionalProperties": false,
+   "properties": {
+    "Context": {
+     "type": "string"
+    },
+    "TargetUrl": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "CloudWatchLogsConfig": {
+   "additionalProperties": false,
+   "properties": {
+    "GroupName": {
+     "type": "string"
+    },
+    "Status": {
+     "type": "string"
+    },
+    "StreamName": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Status"
+   ],
+   "type": "object"
+  },
+  "Environment": {
+   "additionalProperties": false,
+   "properties": {
+    "Certificate": {
+     "type": "string"
+    },
+    "ComputeType": {
+     "enum": [
+      "ATTRIBUTE_BASED_COMPUTE",
+      "BUILD_GENERAL1_2XLARGE",
+      "BUILD_GENERAL1_LARGE",
+      "BUILD_GENERAL1_MEDIUM",
+      "BUILD_GENERAL1_SMALL",
+      "BUILD_GENERAL1_XLARGE",
+      "BUILD_LAMBDA_10GB",
+      "BUILD_LAMBDA_1GB",
+      "BUILD_LAMBDA_2GB",
+      "BUILD_LAMBDA_4GB",
+      "BUILD_LAMBDA_8GB"
+     ],
+     "type": "string"
+    },
+    "EnvironmentVariables": {
+     "items": {
+      "$ref": "#/definitions/EnvironmentVariable"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "Fleet": {
+     "$ref": "#/definitions/ProjectFleet"
+    },
+    "Image": {
+     "type": "string"
+    },
+    "ImagePullCredentialsType": {
+     "enum": [
+      "CODEBUILD",
+      "SERVICE_ROLE"
+     ],
+     "type": "string"
+    },
+    "PrivilegedMode": {
+     "type": "boolean"
+    },
+    "RegistryCredential": {
+     "$ref": "#/definitions/RegistryCredential"
+    },
+    "Type": {
+     "enum": [
+      "ARM_CONTAINER",
+      "ARM_LAMBDA_CONTAINER",
+      "LINUX_CONTAINER",
+      "LINUX_GPU_CONTAINER",
+      "LINUX_LAMBDA_CONTAINER",
+      "MAC_ARM",
+      "WINDOWS_CONTAINER",
+      "WINDOWS_SERVER_2019_CONTAINER"
+     ],
+     "type": "string"
+    }
+   },
+   "required": [
+    "Type",
+    "Image",
+    "ComputeType"
+   ],
+   "type": "object"
+  },
+  "EnvironmentVariable": {
+   "additionalProperties": false,
+   "properties": {
+    "Name": {
+     "type": "string"
+    },
+    "Type": {
+     "type": "string"
+    },
+    "Value": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Value",
+    "Name"
+   ],
+   "type": "object"
+  },
+  "FilterGroup": {
+   "type": "array"
+  },
+  "GitSubmodulesConfig": {
+   "additionalProperties": false,
+   "properties": {
+    "FetchSubmodules": {
+     "type": "boolean"
+    }
+   },
+   "required": [
+    "FetchSubmodules"
+   ],
+   "type": "object"
+  },
+  "LogsConfig": {
+   "additionalProperties": false,
+   "properties": {
+    "CloudWatchLogs": {
+     "$ref": "#/definitions/CloudWatchLogsConfig"
+    },
+    "S3Logs": {
+     "$ref": "#/definitions/S3LogsConfig"
+    }
+   },
+   "type": "object"
+  },
+  "ProjectBuildBatchConfig": {
+   "additionalProperties": false,
+   "properties": {
+    "BatchReportMode": {
+     "type": "string"
+    },
+    "CombineArtifacts": {
+     "type": "boolean"
+    },
+    "Restrictions": {
+     "$ref": "#/definitions/BatchRestrictions"
+    },
+    "ServiceRole": {
+     "type": "string"
+    },
+    "TimeoutInMins": {
+     "type": "integer"
+    }
+   },
+   "type": "object"
+  },
+  "ProjectCache": {
+   "additionalProperties": false,
+   "properties": {
+    "Location": {
+     "type": "string"
+    },
+    "Modes": {
+     "items": {
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "Type": {
+     "enum": [
+      "LOCAL",
+      "NO_CACHE",
+      "S3"
+     ],
+     "type": "string"
+    }
+   },
+   "required": [
+    "Type"
+   ],
+   "type": "object"
+  },
+  "ProjectFileSystemLocation": {
+   "additionalProperties": false,
+   "properties": {
+    "Identifier": {
+     "type": "string"
+    },
+    "Location": {
+     "type": "string"
+    },
+    "MountOptions": {
+     "type": "string"
+    },
+    "MountPoint": {
+     "type": "string"
+    },
+    "Type": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "MountPoint",
+    "Type",
+    "Identifier",
+    "Location"
+   ],
+   "type": "object"
+  },
+  "ProjectFleet": {
+   "additionalProperties": false,
+   "properties": {
+    "FleetArn": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "ProjectSourceVersion": {
+   "additionalProperties": false,
+   "properties": {
+    "SourceIdentifier": {
+     "type": "string"
+    },
+    "SourceVersion": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "SourceIdentifier"
+   ],
+   "type": "object"
+  },
+  "ProjectTriggers": {
+   "additionalProperties": false,
+   "properties": {
+    "BuildType": {
+     "type": "string"
+    },
+    "FilterGroups": {
+     "items": {
+      "$ref": "#/definitions/FilterGroup"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "Webhook": {
+     "type": "boolean"
+    }
+   },
+   "type": "object"
+  },
+  "RegistryCredential": {
+   "additionalProperties": false,
+   "properties": {
+    "Credential": {
+     "type": "string"
+    },
+    "CredentialProvider": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Credential",
+    "CredentialProvider"
+   ],
+   "type": "object"
+  },
+  "S3LogsConfig": {
+   "additionalProperties": false,
+   "properties": {
+    "EncryptionDisabled": {
+     "type": "boolean"
+    },
+    "Location": {
+     "type": "string"
+    },
+    "Status": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Status"
+   ],
+   "type": "object"
+  },
+  "Source": {
+   "additionalProperties": false,
+   "properties": {
+    "Auth": {
+     "$ref": "#/definitions/SourceAuth"
+    },
+    "BuildSpec": {
+     "type": "string"
+    },
+    "BuildStatusConfig": {
+     "$ref": "#/definitions/BuildStatusConfig"
+    },
+    "GitCloneDepth": {
+     "type": "integer"
+    },
+    "GitSubmodulesConfig": {
+     "$ref": "#/definitions/GitSubmodulesConfig"
+    },
+    "InsecureSsl": {
+     "type": "boolean"
+    },
+    "Location": {
+     "type": "string"
+    },
+    "ReportBuildStatus": {
+     "type": "boolean"
+    },
+    "SourceIdentifier": {
+     "type": "string"
+    },
+    "Type": {
+     "enum": [
+      "BITBUCKET",
+      "CODECOMMIT",
+      "CODEPIPELINE",
+      "GITHUB",
+      "GITHUB_ENTERPRISE",
+      "GITLAB",
+      "GITLAB_SELF_MANAGED",
+      "NO_SOURCE",
+      "S3"
+     ],
+     "type": "string"
+    }
+   },
+   "required": [
+    "Type"
+   ],
+   "type": "object"
+  },
+  "SourceAuth": {
+   "additionalProperties": false,
+   "properties": {
+    "Resource": {
+     "type": "string"
+    },
+    "Type": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Type"
+   ],
+   "type": "object"
+  },
+  "Tag": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "type": "string"
+    },
+    "Value": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Value",
+    "Key"
+   ],
+   "type": "object"
+  },
+  "VpcConfig": {
+   "additionalProperties": false,
+   "properties": {
+    "SecurityGroupIds": {
+     "format": "AWS::EC2::SecurityGroup.Ids",
+     "items": {
+      "format": "AWS::EC2::SecurityGroup.GroupId",
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "Subnets": {
+     "format": "AWS::EC2::Subnet.Ids",
+     "items": {
+      "format": "AWS::EC2::Subnet.Id",
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "VpcId": {
+     "format": "AWS::EC2::VPC.Id",
+     "type": "string"
+    }
+   },
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Arn": {
+   "type": "string"
+  },
+  "Artifacts": {
+   "$ref": "#/definitions/Artifacts"
+  },
+  "AutoRetryLimit": {
+   "type": "number"
+  },
+  "BadgeEnabled": {
+   "type": "boolean"
+  },
+  "BuildBatchConfig": {
+   "$ref": "#/definitions/ProjectBuildBatchConfig"
+  },
+  "Cache": {
+   "$ref": "#/definitions/ProjectCache"
+  },
+  "ConcurrentBuildLimit": {
+   "type": "integer"
+  },
+  "Description": {
+   "type": "string"
+  },
+  "EncryptionKey": {
+   "type": "string"
+  },
+  "Environment": {
+   "$ref": "#/definitions/Environment"
+  },
+  "FileSystemLocations": {
+   "items": {
+    "$ref": "#/definitions/ProjectFileSystemLocation"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "Id": {
+   "type": "string"
+  },
+  "LogsConfig": {
+   "$ref": "#/definitions/LogsConfig"
+  },
+  "Name": {
+   "type": "string"
+  },
+  "QueuedTimeoutInMinutes": {
+   "maximum": 480,
+   "minimum": 5,
+   "type": "integer"
+  },
+  "ResourceAccessRole": {
+   "type": "string"
+  },
+  "SecondaryArtifacts": {
+   "items": {
+    "$ref": "#/definitions/Artifacts"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "SecondarySourceVersions": {
+   "items": {
+    "$ref": "#/definitions/ProjectSourceVersion"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "SecondarySources": {
+   "items": {
+    "$ref": "#/definitions/Source"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "ServiceRole": {
+   "type": "string"
+  },
+  "Source": {
+   "$ref": "#/definitions/Source"
+  },
+  "SourceVersion": {
+   "type": "string"
+  },
+  "Tags": {
+   "items": {
+    "$ref": "#/definitions/Tag"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "TimeoutInMinutes": {
+   "maximum": 480,
+   "minimum": 5,
+   "type": "integer"
+  },
+  "Triggers": {
+   "$ref": "#/definitions/ProjectTriggers"
+  },
+  "Visibility": {
+   "type": "string"
+  },
+  "VpcConfig": {
+   "$ref": "#/definitions/VpcConfig"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id",
+  "/properties/Arn"
+ ],
+ "required": [
+  "Artifacts",
+  "ServiceRole",
+  "Environment",
+  "Source"
+ ],
+ "typeName": "AWS::CodeBuild::Project"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-codepipeline-customactiontype.json

@@ -0,0 +1,140 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ConfigurationProperties",
+  "/properties/Version",
+  "/properties/OutputArtifactDetails",
+  "/properties/InputArtifactDetails",
+  "/properties/Settings",
+  "/properties/Provider",
+  "/properties/Category"
+ ],
+ "definitions": {
+  "ArtifactDetails": {
+   "additionalProperties": false,
+   "properties": {
+    "MaximumCount": {
+     "type": "integer"
+    },
+    "MinimumCount": {
+     "type": "integer"
+    }
+   },
+   "required": [
+    "MinimumCount",
+    "MaximumCount"
+   ],
+   "type": "object"
+  },
+  "ConfigurationProperties": {
+   "additionalProperties": false,
+   "properties": {
+    "Description": {
+     "type": "string"
+    },
+    "Key": {
+     "type": "boolean"
+    },
+    "Name": {
+     "type": "string"
+    },
+    "Queryable": {
+     "type": "boolean"
+    },
+    "Required": {
+     "type": "boolean"
+    },
+    "Secret": {
+     "type": "boolean"
+    },
+    "Type": {
+     "enum": [
+      "Boolean",
+      "Number",
+      "String"
+     ],
+     "type": "string"
+    }
+   },
+   "required": [
+    "Secret",
+    "Required",
+    "Key",
+    "Name"
+   ],
+   "type": "object"
+  },
+  "Settings": {
+   "additionalProperties": false,
+   "properties": {
+    "EntityUrlTemplate": {
+     "type": "string"
+    },
+    "ExecutionUrlTemplate": {
+     "type": "string"
+    },
+    "RevisionUrlTemplate": {
+     "type": "string"
+    },
+    "ThirdPartyConfigurationUrl": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Category": {
+   "enum": [
+    "Approval",
+    "Build",
+    "Compute",
+    "Deploy",
+    "Invoke",
+    "Source",
+    "Test"
+   ],
+   "type": "string"
+  },
+  "ConfigurationProperties": {
+   "items": {
+    "$ref": "#/definitions/ConfigurationProperties"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "Id": {
+   "type": "string"
+  },
+  "InputArtifactDetails": {
+   "$ref": "#/definitions/ArtifactDetails"
+  },
+  "OutputArtifactDetails": {
+   "$ref": "#/definitions/ArtifactDetails"
+  },
+  "Provider": {
+   "pattern": "[0-9A-Za-z_-]+",
+   "type": "string"
+  },
+  "Settings": {
+   "$ref": "#/definitions/Settings"
+  },
+  "Version": {
+   "pattern": "[0-9A-Za-z_-]+",
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "Category",
+  "InputArtifactDetails",
+  "OutputArtifactDetails",
+  "Provider"
+ ],
+ "typeName": "AWS::CodePipeline::CustomActionType"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-config-aggregationauthorization.json

@@ -0,0 +1,54 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/AuthorizedAwsRegion",
+  "/properties/AuthorizedAccountId"
+ ],
+ "definitions": {
+  "Tag": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "type": "string"
+    },
+    "Value": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Value",
+    "Key"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "AuthorizedAccountId": {
+   "type": "string"
+  },
+  "AuthorizedAwsRegion": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "Tags": {
+   "items": {
+    "$ref": "#/definitions/Tag"
+   },
+   "type": "array",
+   "uniqueItems": false
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "AuthorizedAccountId",
+  "AuthorizedAwsRegion"
+ ],
+ "typeName": "AWS::Config::AggregationAuthorization"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-config-configrule.json

@@ -0,0 +1,178 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ConfigRuleName"
+ ],
+ "definitions": {
+  "CustomPolicyDetails": {
+   "additionalProperties": false,
+   "properties": {
+    "EnableDebugLogDelivery": {
+     "type": "boolean"
+    },
+    "PolicyRuntime": {
+     "type": "string"
+    },
+    "PolicyText": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "EvaluationModeConfiguration": {
+   "additionalProperties": false,
+   "properties": {
+    "Mode": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "Scope": {
+   "additionalProperties": false,
+   "properties": {
+    "ComplianceResourceId": {
+     "type": "string"
+    },
+    "ComplianceResourceTypes": {
+     "items": {
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": true
+    },
+    "TagKey": {
+     "type": "string"
+    },
+    "TagValue": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "Source": {
+   "additionalProperties": false,
+   "properties": {
+    "CustomPolicyDetails": {
+     "$ref": "#/definitions/CustomPolicyDetails"
+    },
+    "Owner": {
+     "enum": [
+      "AWS",
+      "CUSTOM_LAMBDA",
+      "CUSTOM_POLICY"
+     ],
+     "type": "string"
+    },
+    "SourceDetails": {
+     "items": {
+      "$ref": "#/definitions/SourceDetail"
+     },
+     "type": "array",
+     "uniqueItems": true
+    },
+    "SourceIdentifier": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Owner"
+   ],
+   "type": "object"
+  },
+  "SourceDetail": {
+   "additionalProperties": false,
+   "properties": {
+    "EventSource": {
+     "enum": [
+      "aws.config"
+     ],
+     "type": "string"
+    },
+    "MaximumExecutionFrequency": {
+     "enum": [
+      "One_Hour",
+      "Six_Hours",
+      "Three_Hours",
+      "Twelve_Hours",
+      "TwentyFour_Hours"
+     ],
+     "type": "string"
+    },
+    "MessageType": {
+     "enum": [
+      "ConfigurationItemChangeNotification",
+      "ConfigurationSnapshotDeliveryCompleted",
+      "OversizedConfigurationItemChangeNotification",
+      "ScheduledNotification"
+     ],
+     "type": "string"
+    }
+   },
+   "required": [
+    "EventSource",
+    "MessageType"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/ConfigRuleId"
+ ],
+ "properties": {
+  "Arn": {
+   "type": "string"
+  },
+  "Compliance": {
+   "properties": {
+    "Type": {
+     "type": "string"
+    }
+   },
+   "type": "object"
+  },
+  "ConfigRuleId": {
+   "type": "string"
+  },
+  "ConfigRuleName": {
+   "type": "string"
+  },
+  "Description": {
+   "maxLength": 256,
+   "minLength": 1,
+   "type": "string"
+  },
+  "EvaluationModes": {
+   "items": {
+    "$ref": "#/definitions/EvaluationModeConfiguration"
+   },
+   "type": "array",
+   "uniqueItems": true
+  },
+  "InputParameters": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  },
+  "MaximumExecutionFrequency": {
+   "type": "string"
+  },
+  "Scope": {
+   "$ref": "#/definitions/Scope"
+  },
+  "Source": {
+   "$ref": "#/definitions/Source"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/ConfigRuleId",
+  "/properties/Compliance/Type",
+  "/properties/Arn"
+ ],
+ "required": [
+  "Source"
+ ],
+ "typeName": "AWS::Config::ConfigRule"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-datapipeline-pipeline.json

@@ -0,0 +1,172 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/Name",
+  "/properties/Description"
+ ],
+ "definitions": {
+  "Field": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "type": "string"
+    },
+    "RefValue": {
+     "type": "string"
+    },
+    "StringValue": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Key"
+   ],
+   "type": "object"
+  },
+  "ParameterAttribute": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "type": "string"
+    },
+    "StringValue": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "StringValue",
+    "Key"
+   ],
+   "type": "object"
+  },
+  "ParameterObject": {
+   "additionalProperties": false,
+   "properties": {
+    "Attributes": {
+     "items": {
+      "$ref": "#/definitions/ParameterAttribute"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "Id": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Attributes",
+    "Id"
+   ],
+   "type": "object"
+  },
+  "ParameterValue": {
+   "additionalProperties": false,
+   "properties": {
+    "Id": {
+     "type": "string"
+    },
+    "StringValue": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Id",
+    "StringValue"
+   ],
+   "type": "object"
+  },
+  "PipelineObject": {
+   "additionalProperties": false,
+   "properties": {
+    "Fields": {
+     "items": {
+      "$ref": "#/definitions/Field"
+     },
+     "type": "array",
+     "uniqueItems": false
+    },
+    "Id": {
+     "type": "string"
+    },
+    "Name": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Fields",
+    "Id",
+    "Name"
+   ],
+   "type": "object"
+  },
+  "PipelineTag": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "type": "string"
+    },
+    "Value": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Value",
+    "Key"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Activate": {
+   "type": "boolean"
+  },
+  "Description": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "Name": {
+   "type": "string"
+  },
+  "ParameterObjects": {
+   "items": {
+    "$ref": "#/definitions/ParameterObject"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "ParameterValues": {
+   "items": {
+    "$ref": "#/definitions/ParameterValue"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "PipelineObjects": {
+   "items": {
+    "$ref": "#/definitions/PipelineObject"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "PipelineTags": {
+   "items": {
+    "$ref": "#/definitions/PipelineTag"
+   },
+   "type": "array",
+   "uniqueItems": false
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "ParameterObjects",
+  "Name"
+ ],
+ "typeName": "AWS::DataPipeline::Pipeline"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-directoryservice-simplead.json

@@ -0,0 +1,99 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/Size",
+  "/properties/VpcSettings",
+  "/properties/Name",
+  "/properties/Password",
+  "/properties/ShortName",
+  "/properties/Description",
+  "/properties/CreateAlias"
+ ],
+ "definitions": {
+  "VpcSettings": {
+   "additionalProperties": false,
+   "properties": {
+    "SubnetIds": {
+     "items": {
+      "pattern": "^(subnet-[0-9a-f]{8}|subnet-[0-9a-f]{17})$",
+      "type": "string"
+     },
+     "type": "array",
+     "uniqueItems": true
+    },
+    "VpcId": {
+     "format": "AWS::EC2::VPC.Id",
+     "pattern": "^(vpc-[0-9a-f]{8}|vpc-[0-9a-f]{17})$",
+     "type": "string"
+    }
+   },
+   "required": [
+    "VpcId",
+    "SubnetIds"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Alias": {
+   "type": "string"
+  },
+  "CreateAlias": {
+   "type": "boolean"
+  },
+  "Description": {
+   "pattern": "^([a-zA-Z0-9_])[\\\\a-zA-Z0-9_@#%*+=:?./!\\s-]*$",
+   "type": "string"
+  },
+  "DnsIpAddresses": {
+   "items": {
+    "type": "string"
+   },
+   "type": "array",
+   "uniqueItems": false
+  },
+  "EnableSso": {
+   "type": "boolean"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "Name": {
+   "pattern": "^([a-zA-Z0-9]+[\\\\.-])+([a-zA-Z0-9])+$",
+   "type": "string"
+  },
+  "Password": {
+   "pattern": "(?=^.{8,64}$)((?=.*\\d)(?=.*[A-Z])(?=.*[a-z])|(?=.*\\d)(?=.*[^A-Za-z0-9\\s])(?=.*[a-z])|(?=.*[^A-Za-z0-9\\s])(?=.*[A-Z])(?=.*[a-z])|(?=.*\\d)(?=.*[A-Z])(?=.*[^A-Za-z0-9\\s]))^.*",
+   "type": "string"
+  },
+  "ShortName": {
+   "pattern": "^[^\\\\/:*?\"<>|.]+[^\\\\/:*?\"<>|]*$",
+   "type": "string"
+  },
+  "Size": {
+   "enum": [
+    "Large",
+    "Small"
+   ],
+   "type": "string"
+  },
+  "VpcSettings": {
+   "$ref": "#/definitions/VpcSettings"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Alias",
+  "/properties/DnsIpAddresses",
+  "/properties/Id"
+ ],
+ "required": [
+  "VpcSettings",
+  "Size",
+  "Name",
+  "Password"
+ ],
+ "typeName": "AWS::DirectoryService::SimpleAD"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-docdb-dbclusterparametergroup.json

@@ -0,0 +1,66 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/Family",
+  "/properties/Name",
+  "/properties/Description"
+ ],
+ "definitions": {
+  "Tag": {
+   "additionalProperties": false,
+   "properties": {
+    "Key": {
+     "type": "string"
+    },
+    "Value": {
+     "type": "string"
+    }
+   },
+   "required": [
+    "Value",
+    "Key"
+   ],
+   "type": "object"
+  }
+ },
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "Description": {
+   "type": "string"
+  },
+  "Family": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "Name": {
+   "type": "string"
+  },
+  "Parameters": {
+   "format": "json",
+   "type": [
+    "object",
+    "string"
+   ]
+  },
+  "Tags": {
+   "items": {
+    "$ref": "#/definitions/Tag"
+   },
+   "type": "array",
+   "uniqueItems": false
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "Description",
+  "Parameters",
+  "Family"
+ ],
+ "typeName": "AWS::DocDB::DBClusterParameterGroup"
+}

testbed/aws-cloudformation__cfn-lint/src/cfnlint/data/schemas/providers/us_gov_east_1/aws-ec2-clientvpnauthorizationrule.json

@@ -0,0 +1,41 @@
+{
+ "additionalProperties": false,
+ "createOnlyProperties": [
+  "/properties/ClientVpnEndpointId",
+  "/properties/AccessGroupId",
+  "/properties/TargetNetworkCidr",
+  "/properties/AuthorizeAllGroups",
+  "/properties/Description"
+ ],
+ "primaryIdentifier": [
+  "/properties/Id"
+ ],
+ "properties": {
+  "AccessGroupId": {
+   "type": "string"
+  },
+  "AuthorizeAllGroups": {
+   "type": "boolean"
+  },
+  "ClientVpnEndpointId": {
+   "type": "string"
+  },
+  "Description": {
+   "type": "string"
+  },
+  "Id": {
+   "type": "string"
+  },
+  "TargetNetworkCidr": {
+   "type": "string"
+  }
+ },
+ "readOnlyProperties": [
+  "/properties/Id"
+ ],
+ "required": [
+  "ClientVpnEndpointId",
+  "TargetNetworkCidr"
+ ],
+ "typeName": "AWS::EC2::ClientVpnAuthorizationRule"
+}