Add files using upload-large-folder tool

testbed/aws-cloudformation__cfn-lint/.pre-commit-config.yaml

@@ -0,0 +1,44 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: check-ast
+      - id: check-json
+        exclude: "(test/fixtures/templates/bad/json_parse.json|test/fixtures/templates/bad/core/config_invalid_json.json|test/fixtures/templates/bad/duplicate.json)"
+      - id: check-toml
+      - id: check-vcs-permalinks
+      - id: check-yaml
+        exclude: "test/fixtures/templates/"
+        args: [--unsafe]
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+        args: [--fix, auto]
+      - id: trailing-whitespace
+  - repo: https://github.com/psf/black
+    rev: 24.8.0
+    hooks:
+    - id: black
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.13.2
+    hooks:
+    - id: isort
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: "v0.5.7"
+    hooks:
+      - id: ruff
+  - repo: https://github.com/PyCQA/bandit
+    rev: "1.7.9"
+    hooks:
+      - id: bandit
+        additional_dependencies:
+        - "bandit[toml]"
+        args: ["-c", "pyproject.toml"]
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: "v1.11.1"
+    hooks:
+    - id: mypy
+      additional_dependencies:
+        - "types-PyYAML"
+        - "types-regex"
+        - "types-requests"

testbed/aws-cloudformation__cfn-lint/.pre-commit-hooks.yaml

@@ -0,0 +1,18 @@
+- id: cfn-python-lint
+  name: AWS CloudFormation Linter
+  description: 'cfn-lint is a tool for finding issues with CloudFormation templates'
+  entry: cfn-lint
+  language: python
+  files: \.(json|yaml|yml)$
+- id: cfn-lint # we have removed most identifications to cfn-python-lint
+  name: AWS CloudFormation Linter
+  description: 'cfn-lint is a tool for finding issues with CloudFormation templates'
+  entry: cfn-lint
+  language: python
+  files: \.(json|yaml|yml)$
+- id: cfn-lint-rc # Provide a configuration to use with .cfnlintrc
+  name: AWS CloudFormation Linter
+  description: 'cfn-lint is a tool for finding issues with CloudFormation templates'
+  entry: cfn-lint
+  language: python
+  pass_filenames: false

testbed/aws-cloudformation__cfn-lint/CODE_OF_CONDUCT.md

@@ -0,0 +1,4 @@
+## Code of Conduct
+This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct).
+For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact
+opensource-codeofconduct@amazon.com with any additional questions or comments.

testbed/aws-cloudformation__cfn-lint/CONTRIBUTING.md

@@ -0,0 +1,104 @@
+# Contributing Guidelines
+
+Thank you for your interest in contributing to our project. Whether it's a bug report, new feature, correction, or additional
+documentation, we greatly value feedback and contributions from our community.
+
+Please read through this document before submitting any issues or pull requests to ensure we have all the necessary
+information to effectively respond to your bug report or contribution.
+
+
+## Reporting Bugs/Feature Requests
+
+We welcome you to use the GitHub issue tracker to report bugs or suggest features.
+
+When filing an issue, please check [existing open](https://github.com/aws-cloudformation/cfn-python-lint/issues), or [recently closed](https://github.com/aws-cloudformation/cfn-python-lint/issues?utf8=%E2%9C%93&q=is%3Aissue%20is%3Aclosed%20), issues to make sure somebody else hasn't already
+reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
+
+* A reproducible test case or series of steps
+* The version of our code being used
+* Any modifications you've made relevant to the bug
+* Anything unusual about your environment or deployment
+
+## Development Environment
+
+1. You will need Python 3 >= 3.5. Verify which version you have by running `python --version`.
+
+    > If you don't have it installed, download it [here](https://www.python.org/downloads/). When you do this, `pip` should be installed automatically.
+
+1. Install `cfn-lint` from source by forking the repository and then doing a developer install:
+
+    ```bash
+    # fork the repository
+    git clone https://github.com/<YOUR-USERNAME>/cfn-python-lint.git
+    cd cfn-python-lint
+    pip3 install -e .
+    ```
+
+1. Run `pip3 show cfn-lint`. The `Location` printed should be the folder from the step above.
+1. You should now be able to modify the source code and see the changes immediately by running any of the `cfn-lint` commands. (Note: run `pip3 install -e .` again to re-install changes).
+
+## Running the tests
+
+The unit tests (and `pylint` for linting the Python code) are processed by [`tox`](https://tox.readthedocs.io/en/latest/). The configuration file is [tox.ini](/tox.ini).
+
+Make sure Tox is installed and then run Tox by just calling it:
+
+```bash
+# Install Tox
+$ pip install tox
+
+# Run all tests (This command is also used when validating a Pull Request)
+$ tox
+
+# Run a specific test suite
+$ tox -e py37 # Run all unit tests against Python 3.7
+```
+Tox test suites available:
+* **py37**: Unit tests (Python 3.7)
+* **py38**: Unit tests (Python 3.8)
+* **py39**: Unit tests (Python 3.9)
+* **py310**: Unit tests (Python 3.10)
+* **py311**: Unit tests (Python 3.11)
+* **py312**: Unit tests (Python 3.12)
+* **py313**: Unit tests (Python 3.13)
+* **style**: Python syntax check
+
+## Contributing via Pull Requests
+Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
+
+1. You are working against the latest source on the *main* branch.
+2. You check existing open, and recently merged, pull requests to make sure someone else hasn't addressed the problem already.
+3. You open an issue to discuss any significant work - we would hate for your time to be wasted.
+
+To send us a pull request, please:
+
+1. Fork the repository.
+2. Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
+3. Ensure local tests pass.
+4. Commit to your fork using clear commit messages.
+5. Send us a pull request, answering any default questions in the pull request interface.
+6. Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
+
+GitHub provides additional document on [forking a repository](https://help.github.com/articles/fork-a-repo/) and
+[creating a pull request](https://help.github.com/articles/creating-a-pull-request/).
+
+
+## Finding contributions to work on
+Looking at the existing issues is a great way to find something to contribute on. As our projects, by default, use the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any ['help wanted'](https://github.com/aws-cloudformation/cfn-python-lint/labels/help%20wanted) issues is a great place to start.
+
+
+## Code of Conduct
+This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct).
+For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact
+opensource-codeofconduct@amazon.com with any additional questions or comments.
+
+
+## Security issue notifications
+If you discover a potential security issue in this project we ask that you notify AWS/Amazon Security via our [vulnerability reporting page](http://aws.amazon.com/security/vulnerability-reporting/). Please do **not** create a public GitHub issue.
+
+
+## Licensing
+
+See the [LICENSE](https://github.com/aws-cloudformation/cfn-python-lint/blob/main/LICENSE) file for our project's licensing. We will ask you to confirm the licensing of your contribution.
+
+We may ask you to sign a [Contributor License Agreement (CLA)](http://en.wikipedia.org/wiki/Contributor_License_Agreement) for larger changes.

testbed/aws-cloudformation__cfn-lint/Dockerfile

@@ -0,0 +1,7 @@
+FROM public.ecr.aws/docker/library/python:3.13-alpine3.20
+
+RUN pip install cfn-lint[full]
+RUN pip install pydot
+
+ENTRYPOINT ["cfn-lint"]
+CMD ["--help"]

testbed/aws-cloudformation__cfn-lint/LICENSE

@@ -0,0 +1,14 @@
+MIT No Attribution
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify,
+merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

testbed/aws-cloudformation__cfn-lint/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md LICENSE
+recursive-include test *

testbed/aws-cloudformation__cfn-lint/NOTICE

@@ -0,0 +1,2 @@
+cfn-flip
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

testbed/aws-cloudformation__cfn-lint/README.md

@@ -0,0 +1,364 @@
+# AWS CloudFormation Linter
+
+<img alt="[cfn-lint logo]" src="https://github.com/aws-cloudformation/cfn-python-lint/blob/main/logo.png?raw=true" width="150" align="right">
+
+[![Testing](https://github.com/aws-cloudformation/cfn-python-lint/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/aws-cloudformation/cfn-python-lint/actions/workflows/test.yaml)
+[![PyPI version](https://badge.fury.io/py/cfn-lint.svg)](https://badge.fury.io/py/cfn-lint)
+[![PyPI downloads](https://pepy.tech/badge/cfn-lint/week)](https://pypistats.org/packages/cfn-lint)
+[![PyPI downloads](https://pepy.tech/badge/cfn-lint/month)](https://pypistats.org/packages/cfn-lint)
+[![codecov](https://codecov.io/gh/aws-cloudformation/cfn-lint/branch/main/graph/badge.svg)](https://codecov.io/gh/aws-cloudformation/cfn-python-lint)
+[![Discord Shield](https://img.shields.io/discord/981586120448020580?logo=discord)](https://discord.gg/KENDm6DHCv)
+
+Validate AWS CloudFormation yaml/json templates against the [AWS CloudFormation resource provider schemas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-type-schemas.html) and additional checks. Includes checking valid values for resource properties and best practices.
+
+### Warning
+
+This is an attempt to provide validation for AWS CloudFormation templates properties and
+their values. For values things can get pretty complicated (mappings, joins, splits,
+conditions, and nesting those functions inside each other) so it's a best effort to
+validate those values but the promise is to not fail if we can't understand or translate
+all the things that could be going on.
+
+## Contribute
+
+We encourage you to contribute to `cfn-lint`! Please check out the [Contributing Guidelines](https://github.com/aws-cloudformation/cfn-lint/blob/main/CONTRIBUTING.md) for more information on how to proceed.
+
+## Community
+
+Join us on Discord! Connect & interact with CloudFormation developers &
+experts, find channels to discuss and get help for cfn-lint, CloudFormation registry, StackSets,
+Guard and more:
+
+[![Join our Discord](https://discordapp.com/api/guilds/981586120448020580/widget.png?style=banner3)](https://discord.gg/9zpd7TTRwq)
+
+#### Serverless Application Model
+
+The Serverless Application Model (SAM) is supported by the linter. The template is
+transformed using [AWS SAM](https://github.com/awslabs/serverless-application-model) before the linter processes the template.
+
+_To get information about the [SAM Transformation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/transform-aws-serverless.html), run the linter with `--info`_
+
+## Install
+
+Python 3.8+ is supported.
+
+### Pip
+
+`pip install cfn-lint`. If pip is not available, run
+`python setup.py clean --all` then `python setup.py install`.
+
+#### Optional dependencies
+
+`cfn-lint` has optional dependencies based on certain features you may need.
+
+* `pip install cfn-lint[full]` for installing all the optional dependencies. This will install all the dependencies for graph, junit, and sarif.
+* `pip install cfn-lint[graph]` for installing `pydot` to draw and output template graphs
+* `pip install cfn-lint[junit]` for installing the packages to output the `junit` format
+* `pip install cfn-lint[sarif]` for installing the packages to output the `sarif` format
+
+
+### Homebrew (macOS)
+
+`brew install cfn-lint`
+
+### Docker
+
+In `cfn-lint` source tree:
+
+```shell
+docker build --tag cfn-lint:latest .
+```
+
+In repository to be linted:
+
+```shell
+docker run --rm -v `pwd`:/data cfn-lint:latest /data/template.yaml
+```
+
+### Editor Plugins
+
+There are IDE plugins available to get direct linter feedback from you favorite editor:
+
+- [Atom](https://atom.io/packages/atom-cfn-lint)
+- [Emacs](https://www.emacswiki.org/emacs/CfnLint)
+- NeoVim 0.2.0+/Vim 8
+  - [ALE](https://github.com/w0rp/ale#supported-languages)
+  - [Coc](https://github.com/joenye/coc-cfn-lint)
+  - [Syntastic](https://github.com/speshak/vim-cfn)
+- [Sublime](https://packagecontrol.io/packages/SublimeLinter-contrib-cloudformation)
+- [Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=kddejong.vscode-cfn-lint)
+- [IntelliJ IDEA](https://plugins.jetbrains.com/plugin/10973-cfn-lint)
+
+### [GitHub Action](https://github.com/marketplace/actions/cfn-lint-action)
+
+### [Online demo](https://github.com/PatMyron/cfn-lint-online)
+
+## Basic Usage
+
+- `cfn-lint template.yaml`
+- `cfn-lint -t template.yaml`
+
+Multiple files can be linted by either specifying multiple specific files:
+
+- `cfn-lint template1.yaml template2.yaml`
+- `cfn-lint -t template1.yaml template2.yaml`
+
+or by using wildcards (globbing):
+
+Lint all `yaml` files in `path`:
+
+- `cfn-lint path/*.yaml`
+
+Lint all `yaml` files in `path` and all subdirectories (recursive):
+
+- `cfn-lint path/**/*.yaml`
+
+_Note_: If using sh/bash/zsh, you must enable globbing.
+(`shopt -s globstar` for sh/bash, `setopt extended_glob` for zsh).
+
+##### Exit Codes
+
+`cfn-lint` will return a non zero exit if there are any issues with your template. The value is dependent on the severity of the issues found. For each level of discovered error `cfn-lint` will use bitwise OR to determine the final exit code. This will result in these possibilities.
+
+- 0 is no issue was found
+- 2 is an error
+- 4 is a warning
+- 6 is an error and a warning
+- 8 is an informational
+- 10 is an error and informational
+- 12 is an warning and informational
+- 14 is an error and a warning and an informational
+
+###### Configuring Exit Codes
+
+`cfn-lint` allows you to configure exit codes. You can provide the parameter `--non-zero-exit-code` with a value of `informational`, `warning`, `error`, or `none`. `cfn-lint` will determine the exit code based on the match severity being the value of the parameter `--non-zero-exit-code` and higher. The exit codes will remain the same as above.
+
+The order of severity is as follows:
+
+1. `informational` _default_
+1. `warning`
+1. `error`
+1. `none` _Exit code will always be 0 unless there is a syntax error_
+
+##### Specifying the template as an input stream
+
+The template to be linted can also be passed using standard input:
+
+- `cat path/template.yaml | cfn-lint -`
+
+##### Specifying the template with other parameters
+
+- `cfn-lint -r us-east-1 ap-south-1 -- template.yaml`
+- `cfn-lint -r us-east-1 ap-south-1 -t template.yaml`
+
+## Configuration
+
+### Command Line
+
+From a command prompt run `cfn-lint <path to template>` to run standard linting of the template.
+
+### Config File
+
+It will look for a configuration file in the following locations (by order of preference):
+
+- `.cfnlintrc`, `.cfnlintrc.yaml` or `.cfnlintrc.yml` in the current working directory
+- `~/.cfnlintrc` for the home directory
+
+In that file you can specify settings from the parameter section below.
+
+Example:
+
+```yaml
+templates:
+  - test/fixtures/templates/good/**/*.yaml
+ignore_templates:
+  - codebuild.yaml
+include_checks:
+  - I
+custom_rules: custom_rules.txt
+```
+
+### Parameters
+
+Optional parameters:
+
+| Command Line               | Metadata             | Options                                        | Description                                                                                                                                                                                                                                           |
+| -------------------------- | -------------------- | ---------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| -h, --help                 |                      |                                                | Get description of cfn-lint                                                                                                                                                                                                                           |
+| -z, --custom-rules         |                      | filename                                       | Text file containing user-defined custom rules. See [here](#Custom-Rules) for more information                                                                                                                                                        |
+| -t, --template             |                      | filename                                       | Alternative way to specify Template file path to the file that needs to be tested by cfn-lint                                                                                                                                                         |
+| -f, --format               | format               | quiet, parseable, json, junit, pretty, sarif   | Output format                                                                                                                                                                                                                                         |
+| -l, --list-rules           |                      |                                                | List all the rules                                                                                                                                                                                                                                    |
+| -r, --regions              | regions              | [REGIONS [REGIONS ...]], ALL_REGIONS           | Test the template against many regions. [Supported regions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-type-schemas.html)                                                                                                |
+| -b, --ignore-bad-template  | ignore_bad_template  |                                                | Ignores bad template errors                                                                                                                                                                                                                           |
+| --ignore-templates         |                      | IGNORE_TEMPLATES [IGNORE_TEMPLATES ...]        | Ignore templates from being scanned                                                                                                                                                                                                                   |
+| -a, --append-rules         | append_rules         | [RULESPATH [RULESPATH ...]]                    | Specify one or more rules paths using one or more --append-rules arguments. Each path can be either a directory containing python files, or an import path to a module.                                                                               |
+| -i, --ignore-checks        | ignore_checks        | [IGNORE_CHECKS [IGNORE_CHECKS ...]]            | Only check rules whose ID do not match or prefix these values. Examples: <br />- A value of `W` will disable all warnings<br />- `W2` disables all Warnings for Parameter rules.<br />- `W2001` will disable rule `W2001`                             |
+| -e, --include-experimental | include_experimental |                                                | Whether rules that still in an experimental state should be included in the checks                                                                                                                                                                    |
+| -c, --include-checks       |                      | INCLUDE_CHECKS [INCLUDE_CHECKS ...]            | Include rules whose id match these values                                                                                                                                                                                                             |
+| -m, --mandatory-checks     |                      |                                                | Rules to check regardless of ignore configuration                                                                                                                                                                                                     |
+| --non-zero-exit-code       |                      | informational (default), warning, error, none] | Exit code will be non zero from the specified rule class and higher                                                                                                                                                                                   |
+| -x, --configure-rule       |                      | CONFIGURE_RULES [CONFIGURE_RULES ...]          | Provide configuration for a rule. Format RuleId:key=value. Example: E3012:strict=true                                                                                                                                                                 |
+| -D, --debug                |                      |                                                | Specify to enable debug logging. Debug logging outputs detailed information about rules processing, useful for debugging rules.                                                                                                                       |
+| -I, --info                 |                      |                                                | Specify to enable logging. Outputs additional information about the template processing.                                                                                                                                                              |
+| -u, --update-specs         |                      |                                                | Update the [CloudFormation resource provider schemas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-type-schemas.html). You may need sudo to run this. You will need internet access when running this command              |
+| -o, --override-spec        |                      | filename                                       | Spec-style file containing custom definitions. Can be used to override CloudFormation specifications. More info [here](#customize-specifications)                                                                                                     |
+| -g, --build-graph          |                      |                                                | Creates a file in the same directory as the template that models the template's resources in [DOT format](<https://en.wikipedia.org/wiki/DOT_(graph_description_language)>)                                                                           |
+| -s, --registry-schemas     |                      |                                                | one or more directories of [CloudFormation Registry](https://aws.amazon.com/blogs/aws/cloudformation-update-cli-third-party-resource-support-registry/) [Resource Schemas](https://github.com/aws-cloudformation/aws-cloudformation-resource-schema/) |
+| -v, --version              |                      |                                                | Version of cfn-lint                                                                                                                                                                                                                                   |
+
+### Info Rules
+
+To maintain backwards compatibility `info` rules are not included by default. To include these rules you will need to include `-c I` or `--include-checks I`
+
+### Metadata
+
+#### Template Based Metadata
+
+Inside the root level Metadata key you can configure cfn-lint using the supported parameters.
+
+```yaml
+Metadata:
+  cfn-lint:
+    config:
+      regions:
+        - us-east-1
+        - us-east-2
+      ignore_checks:
+        - E2530
+```
+
+#### Resource Based Metadata
+
+Inside a resources Metadata key you can configure cfn-lint to ignore checks. This will filter out failures for the resource in which the Metadata belongs. Keep in mind that [`AWS::Serverless` resources may lose metadata during the Serverless transform](https://github.com/awslabs/serverless-application-model/issues/450#issuecomment-643420308)
+
+```yaml
+Resources:
+  myInstance:
+    Type: AWS::EC2::Instance
+    Metadata:
+      cfn-lint:
+        config:
+          ignore_checks:
+            - E3030
+    Properties:
+      InstanceType: nt.x4superlarge
+      ImageId: ami-abc1234
+```
+
+### Precedence
+
+cfn-lint applies configurations from several sources. The rules at lower levels are overridden by those at higher levels.
+
+1. cfnlintrc configurations
+2. Template Metadata configurations
+3. CLI parameters
+
+### Configure Rules
+
+Certain rules support configuration properties. You can configure these rules by using `configure_rules` parameter.
+
+From the command line the format is `RuleId:key=value`, for example: `E3012:strict=true`.
+From the cfnlintrc or Metadata section the format is
+
+```yaml
+Metadata:
+  cfn-lint:
+    config:
+      configure_rules:
+        RuleId:
+          key: value
+```
+
+The configurable rules have a non-empty Config entry in the table [here](docs/rules.md#rules-1).
+
+### Getting Started Guides
+
+There are [getting started guides](/docs/getting_started) available in the documentation section to help with integrating `cfn-lint` or creating rules.
+
+## Rules
+
+This linter checks the AWS CloudFormation template by processing a collection of Rules, where every rule handles a specific function check or validation of the template.
+
+This collection of rules can be extended with custom rules using the `--append-rules` argument.
+
+More information describing how rules are set up and an overview of all the Rules that are applied by this linter are documented [here](docs/rules.md).
+
+## Custom Rules
+
+The linter supports the creation of custom one-line rules which compare any resource with a property using pre-defined operators. These custom rules take the following format:
+
+```
+<Resource Type> <Property[*]> <Operator> <Value> [Error Level] [Custom Error Message]
+```
+
+### Example
+
+A separate custom rule text file must be created.
+
+The example below validates `example_template.yml` does not use any EC2 instances of size `m4.16xlarge`
+
+_custom_rule.txt_
+
+```
+AWS::EC2::Instance InstanceType NOT_EQUALS "m4.16xlarge" WARN "This is an expensive instance type, don't use it"
+```
+
+_example_template.yml_
+
+```yaml
+AWSTemplateFormatVersion: "2010-09-09"
+Resources:
+  myInstance:
+    Type: AWS::EC2::Instance
+    Properties:
+      InstanceType: m4.16xlarge
+      ImageId: ami-asdfef
+```
+
+The custom rule can be added to the [configuration file](#Config-File) or ran as a [command line argument](#Parameters)
+
+The linter will produce the following output, running `cfn-lint example_template.yml -z custom_rules.txt`:
+
+```
+W9001  This is an expensive instance type, don't use it
+mqtemplate.yml:6:17
+```
+
+More information describing how custom rules are setup and an overview of all operators available is documented [here](docs/custom_rules.md).
+
+## Customize specifications
+
+The linter follows the [AWS CloudFormation resource provider schemas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resource-type-schemas.html) by default. However, for your use case specific requirements might exist. For example, within your organisation it might be mandatory to use [Tagging](https://aws.amazon.com/answers/account-management/aws-tagging-strategies/).
+
+The linter provides the possibility to implement these customized specifications using the `--override-spec` argument.
+
+More information about how this feature works is documented [here](docs/customize_specifications.md)
+
+## pre-commit
+
+If you'd like cfn-lint to be run automatically when making changes to files in your Git repository, you can install [pre-commit](https://pre-commit.com/) and add the following text to your repositories' `.pre-commit-config.yaml`:
+
+```yaml
+repos:
+  - repo: https://github.com/aws-cloudformation/cfn-lint
+    rev: v1.19.0 # The version of cfn-lint to use
+    hooks:
+      - id: cfn-lint
+        files: path/to/cfn/dir/.*\.(json|yml|yaml)$
+```
+
+If you are using a `.cfnlintrc` and specifying the `templates` or `ignore_templates` we would recommend using the `.cfnlintrc` exlusively to determine which files should be scanned and then using:
+
+```yaml
+repos:
+  - repo: https://github.com/aws-cloudformation/cfn-lint
+    rev: v1.19.0 # The version of cfn-lint to use
+    hooks:
+      - id: cfn-lint-rc
+```
+
+_Note: When mixing .cfnlintrc ignore_templates and files option in your .pre-commit-config.yaml cfn-lint may return a file not found error_
+
+- If you exclude the `files:` line above, every json/yml/yaml file will be checked.
+- You can see available cfn-lint versions on the [releases page](https://github.com/aws-cloudformation/cfn-python-lint/releases).

testbed/aws-cloudformation__cfn-lint/custom_rules.txt

@@ -0,0 +1,3 @@
+#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"

testbed/aws-cloudformation__cfn-lint/pyproject.toml

@@ -0,0 +1,211 @@
+[build-system]
+requires = [
+  "setuptools >= 65.5.1",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.dynamic]
+version = {attr = "cfnlint.version.__version__"}
+readme = {file = ["README.md"], content-type = "text/markdown"}
+
+[project]
+name = "cfn-lint"
+description = "Checks CloudFormation templates for practices and behaviour that could potentially be improved"
+requires-python = ">=3.8"
+license = {text = "MIT no attribution"}
+keywords = ["aws", "cloudformation", "lint"]
+authors = [
+  {email = "kddejong@amazon.com"},
+  {name = "Kevin DeJong"},
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dynamic = ["version", "readme"]
+dependencies = [
+    "pyyaml>5.4",
+    "aws-sam-translator>=1.91.0",
+    "jsonpatch",
+    "networkx>=2.4,<4",
+    "sympy>=1.0.0",
+    "regex",
+    "typing_extensions",
+]
+
+[project.optional-dependencies]
+graph = [
+    "pydot"
+]
+junit = [
+    "junit-xml~=1.9"
+]
+sarif = [
+    "jschema_to_python~=1.2.3",
+    "sarif-om~=1.0.4",
+]
+full = [
+    "junit-xml~=1.9",
+    "jschema_to_python~=1.2.3",
+    "sarif-om~=1.0.4",
+    "pydot"
+]
+
+[project.scripts]
+cfn-lint = "cfnlint.runner:main"
+
+[tool.setuptools.package-data]
+cfnlint = ["data/**/*.json"]
+
+[project.urls]
+Homepage = "https://github.com/aws-cloudformation/cfn-lint"
+Documentation = "https://github.com/aws-cloudformation/cfn-lint"
+Issues = "https://github.com/aws-cloudformation/cfn-lint/issues"
+Changelog = "https://github.com/aws-cloudformation/cfn-lint/blob/main/CHANGELOG.md"
+Source = "https://github.com/aws-cloudformation/cfn-lint"
+
+[tool.isort]
+profile = "black"
+
+[tool.black]
+skip-string-normalization = false
+line-length = 88
+
+[tool.bandit]
+skips = ["B101", "B303", "B310", "B110", "B112", "B324", "B404", "B603", "B607"]
+exclude_dirs = ["tests", "scripts"]
+
+[tool.ruff]
+# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default.
+lint.select = ["E", "F"]
+lint.ignore = []
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+lint.fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"]
+lint.unfixable = []
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+# Same as Black.
+line-length = 88
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+
+[tool.pytest.ini_options]
+addopts = [
+  "-m not data"
+]
+markers = [
+  "data: marks tests as slow (deselect with '-m \"not data\"')",
+]
+testpaths = [
+    "test",
+]
+
+[tool.coverage.run]
+branch = true
+source = [
+  "src/cfnlint"
+]
+
+[tool.coverage.report]
+skip_empty = true
+skip_covered = true
+show_missing = true
+sort = "Cover"
+exclude_lines = [
+  "pragma: no cover",
+  "if TYPE_CHECKING:"
+]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+files = [
+  "src/cfnlint/**/*.py"
+]
+exclude = [
+  "src/cfnlint/data/"
+]
+
+# Per-module options:
+[[tool.mypy.overrides]]
+module = "networkx.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "pydot.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "pygraphviz.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "importlib_resources.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "samtranslator.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "sarif_om.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "jschema_to_python.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "junit_xml.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "jsonpatch.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "urllib2.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "json.*"
+ignore_missing_imports = true

testbed/aws-cloudformation__cfn-lint/setup.cfg

@@ -0,0 +1,2 @@
+[metadata]
+description_file = README.md

testbed/aws-cloudformation__cfn-lint/test/fixtures/templates/__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/test/fixtures/templates/integration/aws-ec2-instance.yaml

@@ -0,0 +1,20 @@
+Resources:
+  NetworkInterface:
+    Type: AWS::EC2::NetworkInterface
+    Properties:
+      Description: foobar
+      SourceDestCheck: false
+      SubnetId: subnet-0abc1def2345a678b
+  Instance:
+    Type: AWS::EC2::Instance
+    Properties:
+      ImageId: ami-abcdefgh
+      InstanceType: t2.micro
+      NetworkInterfaces:
+        - AssociateCarrierIpAddress: true
+          AssociatePublicIpAddress: true
+          DeviceIndex: "0"
+          NetworkInterfaceId: !Ref NetworkInterface
+      Tags:
+        - Key: foo
+          Value: bar

testbed/aws-cloudformation__cfn-lint/test/fixtures/templates/integration/aws-ec2-launchtemplate.yaml

@@ -0,0 +1,14 @@
+Resources:
+  LaunchTemplate:
+    Type: AWS::EC2::LaunchTemplate
+    Properties:
+      LaunchTemplateData:
+        ImageId: ami-abcdefgh
+        InstanceType: t2.micro
+        UserData: !Base64 "#!/bin/bash\necho 'Hello World' > /var/www/html/index.html"
+        NetworkInterfaces:
+          - AssociateCarrierIpAddress: true
+            AssociatePublicIpAddress: true
+            DeviceIndex: 0
+            NetworkInterfaceId: !Ref NetworkInterface
+      LaunchTemplateName: MyLaunchTemplate

testbed/aws-cloudformation__cfn-lint/test/fixtures/templates/integration/aws-ec2-networkinterface.yaml

@@ -0,0 +1,17 @@
+Parameters:
+  SubnetId:
+    Type: AWS::EC2::Subnet::Id
+  SecurityGroupId:
+    Type: AWS::EC2::SecurityGroup::Id
+Resources:
+  NetworkInterface:
+    Type: AWS::EC2::NetworkInterface
+    Properties:
+      Description: "a network interface"
+      GroupSet:
+        - !Ref SecurityGroupId
+      SourceDestCheck: false
+      SubnetId: !Ref SubnetId
+      Ipv6Addresses:
+        - Ipv6Address: abc
+      Ipv6AddressCount: 1

testbed/aws-cloudformation__cfn-lint/test/fixtures/templates/integration/aws-ec2-subnet.yaml

@@ -0,0 +1,19 @@
+Parameters:
+  Vpc:
+    Type: AWS::EC2::VPC::Id
+Resources:
+  Subnet1:
+    Type: AWS::EC2::Subnet
+    Properties:
+      VpcId: !Ref Vpc
+      CidrBlock: 10.0.0.0/24
+      Ipv4NetmaskLength: 10
+  Subnet2:
+    Type: AWS::EC2::Subnet
+    Properties:
+      VpcId: !Ref Vpc
+  Subnet3:
+    Type: AWS::EC2::Subnet
+    Properties:
+      VpcId: !Ref Vpc
+      Ipv4IpamPoolId: test

testbed/aws-cloudformation__cfn-lint/test/integration/jsonschema/test_validator_cfn.py

@@ -0,0 +1,366 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import json
+import unittest
+from collections import deque
+from typing import List
+
+import jsonpatch
+
+from cfnlint.decode import decode_str
+from cfnlint.helpers import FUNCTIONS
+from cfnlint.jsonschema import CfnTemplateValidator, ValidationError
+from cfnlint.template import Template
+
+
+def build_template(patch: jsonpatch.JsonPatch | None) -> Template:
+    """
+    Build a template object from a dict
+    """
+    template_obj = {
+        "AWSTemplateFormatVersion": "2010-09-09",
+        "Conditions": {
+            "IsUsEast1": {"Fn::Equals": ["true", {"Ref": "AWS::Region"}]},
+            "IsNotUsEast1": {"Fn::Not": [{"Condition": "IsUsEast1"}]},
+        },
+        "Resources": {
+            "MyResource": {
+                "Type": "AWS::Test::Type",
+                "Properties": {
+                    "Name": "Name",
+                    "Tags": [
+                        {"Key": "Name", "Value": "Value"},
+                    ],
+                },
+            }
+        },
+    }
+
+    if patch is not None:
+        jsonpatch.apply_patch(template_obj, patch, True)
+
+    template, _ = decode_str(json.dumps(template_obj))
+    if template:
+        return Template("", template, regions=["us-east-1"])
+
+    raise Exception("Template is invalid")
+
+
+def build_schema(patch: jsonpatch.JsonPatch | None):
+    schema = {
+        "properties": {
+            "Name": {
+                "type": "string",
+            },
+            "Tags": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "Key": {"type": "string"},
+                        "Value": {"type": "string"},
+                    },
+                },
+            },
+        },
+        "type": "object",
+    }
+
+    if patch is not None:
+        jsonpatch.apply_patch(schema, patch, True)
+
+    return schema
+
+
+class TestValidatorCfnConditions(unittest.TestCase):
+    """
+    Integration testing of the CfnTemplateValidator class
+    with a Template that allows us to exhaust scenario
+    """
+
+    def run_test(
+        self,
+        template_patches: jsonpatch.JsonPatch,
+        schema_patches: jsonpatch.JsonPatch,
+        expected_errs: List[ValidationError],
+    ):
+        """
+        Run the test
+        """
+        cfn = build_template(template_patches)
+        schema = build_schema(schema_patches)
+
+        props = (
+            cfn.template.get("Resources", {})
+            .get("MyResource", {})
+            .get("Properties", {})
+        )
+
+        context = cfn.context.evolve(functions=FUNCTIONS)
+        validator = CfnTemplateValidator(schema=schema, cfn=cfn, context=context)
+        errs = list(validator.iter_errors(props))
+
+        self.assertEqual(len(errs), len(expected_errs), f"Received: {errs!r}")
+        for i, err in enumerate(errs):
+            self.assertEqual(expected_errs[i].message, err.message)
+            self.assertEqual(expected_errs[i].path, err.path)
+            self.assertEqual(expected_errs[i].validator, err.validator)
+            self.assertEqual(expected_errs[i].validator_value, err.validator_value)
+
+    def test_required(self):
+        schema_patch = jsonpatch.JsonPatch(
+            patch=[{"op": "add", "path": "/required", "value": ["Name"]}],
+        )
+        self.run_test(
+            template_patches=None,
+            schema_patches=schema_patch,
+            expected_errs=[],
+        )
+
+        self.run_test(
+            template_patches=jsonpatch.JsonPatch(
+                patch=[
+                    {"op": "remove", "path": "/Resources/MyResource/Properties/Name"}
+                ],
+            ),
+            schema_patches=schema_patch,
+            expected_errs=[
+                ValidationError(
+                    "'Name' is a required property",
+                    validator="required",
+                    validator_value=["Name"],
+                ),
+            ],
+        )
+
+        self.run_test(
+            template_patches=jsonpatch.JsonPatch(
+                patch=[
+                    {
+                        "op": "replace",
+                        "path": "/Resources/MyResource/Properties/Name",
+                        "value": {
+                            "Fn::If": [
+                                "IsUsEast1",
+                                "Name",
+                                {"Ref": "AWS::NoValue"},
+                            ]
+                        },
+                    }
+                ],
+            ),
+            schema_patches=schema_patch,
+            expected_errs=[
+                ValidationError(
+                    "'Name' is a required property",
+                    validator="required",
+                    validator_value=["Name"],
+                ),
+            ],
+        )
+
+    def test_unique_items(self):
+        schema_patch = jsonpatch.JsonPatch(
+            [
+                {"op": "add", "path": "/properties/Tags/uniqueItems", "value": True},
+            ]
+        )
+        self.run_test(
+            template_patches=None,
+            schema_patches=schema_patch,
+            expected_errs=[],
+        )
+
+        self.run_test(
+            template_patches=jsonpatch.JsonPatch(
+                [
+                    {
+                        "op": "add",
+                        "path": "/Resources/MyResource/Properties/Tags/-",
+                        "value": {"Key": "Name", "Value": "Value"},
+                    },
+                ]
+            ),
+            schema_patches=schema_patch,
+            expected_errs=[
+                ValidationError(
+                    message=(
+                        "[{'Key': 'Name', 'Value': 'Value'}, "
+                        "{'Key': 'Name', 'Value': 'Value'}] has "
+                        "non-unique elements"
+                    ),
+                    path=deque(["Tags"]),
+                    validator="uniqueItems",
+                    validator_value=True,
+                ),
+            ],
+        )
+
+        self.run_test(
+            template_patches=jsonpatch.JsonPatch(
+                [
+                    {
+                        "op": "add",
+                        "path": "/Resources/MyResource/Properties/Tags/-",
+                        "value": {
+                            "Fn::If": [
+                                "IsUsEast1",
+                                {"Key": "Name", "Value": "Value"},
+                                {"Key": "Foo", "Value": "Bar"},
+                            ]
+                        },
+                    },
+                ]
+            ),
+            schema_patches=schema_patch,
+            expected_errs=[
+                ValidationError(
+                    message=(
+                        "[{'Key': 'Name', 'Value': 'Value'}, "
+                        "{'Key': 'Name', 'Value': 'Value'}] has "
+                        "non-unique elements"
+                    ),
+                    path=deque(["Tags"]),
+                    validator="uniqueItems",
+                    validator_value=True,
+                ),
+            ],
+        )
+
+        self.run_test(
+            template_patches=jsonpatch.JsonPatch(
+                [
+                    {
+                        "op": "replace",
+                        "path": "/Resources/MyResource/Properties/Tags",
+                        "value": [
+                            {
+                                "Fn::If": [
+                                    "IsUsEast1",
+                                    {"Key": "Name", "Value": "Value"},
+                                    {"Ref": "AWS::NoValue"},
+                                ],
+                            },
+                            {
+                                "Fn::If": [
+                                    "IsUsEast1",
+                                    {"Ref": "AWS::NoValue"},
+                                    {"Key": "Name", "Value": "Value"},
+                                ],
+                            },
+                        ],
+                    },
+                ]
+            ),
+            schema_patches=schema_patch,
+            expected_errs=[],
+        )
+
+        self.run_test(
+            template_patches=jsonpatch.JsonPatch(
+                [
+                    {
+                        "op": "replace",
+                        "path": "/Resources/MyResource/Properties/Tags",
+                        "value": [
+                            {
+                                "Fn::If": [
+                                    "IsUsEast1",
+                                    {"Key": "Name", "Value": "Value"},
+                                    {"Ref": "AWS::NoValue"},
+                                ],
+                            },
+                            {
+                                "Fn::If": [
+                                    "IsNotUsEast1",
+                                    {"Ref": "AWS::NoValue"},
+                                    {"Key": "Name", "Value": "Value"},
+                                ],
+                            },
+                        ],
+                    },
+                ]
+            ),
+            schema_patches=schema_patch,
+            expected_errs=[
+                ValidationError(
+                    message=(
+                        "[{'Key': 'Name', 'Value': 'Value'}, "
+                        "{'Key': 'Name', 'Value': 'Value'}] has "
+                        "non-unique elements"
+                    ),
+                    path=deque(["Tags"]),
+                    validator="uniqueItems",
+                    validator_value=True,
+                ),
+            ],
+        )
+
+    def test_dependencies(self):
+        schema_patch = jsonpatch.JsonPatch(
+            [
+                {"op": "add", "path": "/dependencies", "value": {"Name": ["Tags"]}},
+            ]
+        )
+        self.run_test(
+            template_patches=None,
+            schema_patches=schema_patch,
+            expected_errs=[],
+        )
+
+        self.run_test(
+            template_patches=jsonpatch.JsonPatch(
+                [
+                    {"op": "remove", "path": "/Resources/MyResource/Properties/Tags"},
+                ]
+            ),
+            schema_patches=schema_patch,
+            expected_errs=[
+                ValidationError(
+                    message="'Tags' is a dependency of 'Name'",
+                    path=deque([]),
+                    validator="dependencies",
+                    validator_value={"Name": ["Tags"]},
+                ),
+            ],
+        )
+
+        self.run_test(
+            template_patches=jsonpatch.JsonPatch(
+                [
+                    {
+                        "op": "replace",
+                        "path": "/Resources/MyResource/Properties/Tags",
+                        "value": {
+                            "Fn::If": [
+                                "IsUsEast1",
+                                {"Ref": "AWS::NoValue"},
+                                [
+                                    {
+                                        "Fn::If": [
+                                            "IsUsEast1",
+                                            {"Ref": "AWS::NoValue"},
+                                            {"Key": "Name", "Value": "Value"},
+                                        ]
+                                    },
+                                ],
+                            ]
+                        },
+                    },
+                ]
+            ),
+            schema_patches=schema_patch,
+            expected_errs=[
+                ValidationError(
+                    message="'Tags' is a dependency of 'Name'",
+                    path=deque([]),
+                    validator="dependencies",
+                    validator_value={"Name": ["Tags"]},
+                ),
+            ],
+        )

testbed/aws-cloudformation__cfn-lint/test/integration/rules/test_rules.py

@@ -0,0 +1,32 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import pathlib
+
+from cfnlint.helpers import load_plugins
+
+
+def test_rule_descriptions():
+    root_dir = pathlib.Path(__file__).parent.parent.parent.parent / "src/cfnlint/rules"
+    rules = load_plugins(
+        str(root_dir),
+    )
+
+    descriptions = set()
+    shortdesc = set()
+
+    for rule in rules:
+        if not rule.id:
+            continue
+        assert (
+            rule.description not in descriptions
+        ), f"Duplicate description {rule.description!r}"
+        assert (
+            rule.shortdesc not in shortdesc
+        ), f"Duplicate shortdesc {rule.shortdesc!r}"
+        descriptions.add(rule.description)
+        shortdesc.add(rule.shortdesc)

testbed/aws-cloudformation__cfn-lint/test/integration/test_good_templates.py

@@ -0,0 +1,228 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from pathlib import Path
+from test.integration import BaseCliTestCase
+
+from cfnlint import ConfigMixIn
+
+
+class TestQuickStartTemplates(BaseCliTestCase):
+    """Test QuickStart Templates Parsing"""
+
+    # ruff: noqa: E501
+    scenarios = [
+        {
+            "filename": "test/fixtures/templates/good/generic.yaml",
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": "test/fixtures/templates/good/minimal.yaml",
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": "test/fixtures/templates/good/transform.yaml",
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": "test/fixtures/templates/issues/sam_w_conditions.yaml",
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": (
+                "test/fixtures/templates/bad/transform_serverless_template.yaml"
+            ),
+            "results": [
+                {
+                    "Filename": "test/fixtures/templates/bad/transform_serverless_template.yaml",
+                    "Id": "9e05773a-b0d0-f157-2955-596d9bd54749",
+                    "Level": "Error",
+                    "Location": {
+                        "End": {"ColumnNumber": 2, "LineNumber": 1},
+                        "Path": None,
+                        "Start": {"ColumnNumber": 1, "LineNumber": 1},
+                    },
+                    "Message": "Error transforming template: Resource with id [myFunctionMyTimer] is invalid. Missing required property 'Schedule'.",
+                    "ParentId": None,
+                    "Rule": {
+                        "Description": "Errors found when performing transformation on the template",
+                        "Id": "E0001",
+                        "ShortDescription": "Error found when transforming the template",
+                        "Source": "https://github.com/aws-cloudformation/cfn-lint",
+                    },
+                },
+                {
+                    "Filename": "test/fixtures/templates/bad/transform_serverless_template.yaml",
+                    "Id": "fd751fa3-7d1f-e194-7108-eb08352814c8",
+                    "Level": "Error",
+                    "Location": {
+                        "End": {"ColumnNumber": 2, "LineNumber": 1},
+                        "Path": None,
+                        "Start": {"ColumnNumber": 1, "LineNumber": 1},
+                    },
+                    "Message": "Error transforming template: Resource with id [ExampleLayer] is invalid. Missing required property 'ContentUri'.",
+                    "ParentId": None,
+                    "Rule": {
+                        "Description": "Errors found when performing transformation on the template",
+                        "Id": "E0001",
+                        "ShortDescription": "Error found when transforming the template",
+                        "Source": "https://github.com/aws-cloudformation/cfn-lint",
+                    },
+                },
+                {
+                    "Filename": "test/fixtures/templates/bad/transform_serverless_template.yaml",
+                    "Id": "74181426-e865-10eb-96fd-908dfd30a358",
+                    "Level": "Error",
+                    "Location": {
+                        "End": {"ColumnNumber": 2, "LineNumber": 1},
+                        "Path": None,
+                        "Start": {"ColumnNumber": 1, "LineNumber": 1},
+                    },
+                    "Message": "Error transforming template: Resource with id [AppName] is invalid. Resource is missing the required [Location] property.",
+                    "ParentId": None,
+                    "Rule": {
+                        "Description": "Errors found when performing transformation on the template",
+                        "Id": "E0001",
+                        "ShortDescription": "Error found when transforming the template",
+                        "Source": "https://github.com/aws-cloudformation/cfn-lint",
+                    },
+                },
+            ],
+            "exit_code": 2,
+        },
+        {
+            "filename": "test/fixtures/templates/good/conditions.yaml",
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": "test/fixtures/templates/good/resources_codepipeline.yaml",
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": "test/fixtures/templates/good/resources_cognito_userpool_tag_is_string_map.yaml",
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": "test/fixtures/templates/bad/resources_cognito_userpool_tag_is_list.yaml",
+            "results": [
+                {
+                    "Filename": str(
+                        Path(
+                            "test/fixtures/templates/bad/resources_cognito_userpool_tag_is_list.yaml"
+                        )
+                    ),
+                    "Id": "3732b0a0-6d44-72af-860a-88e5f8ca790c",
+                    "Level": "Error",
+                    "Location": {
+                        "Start": {"ColumnNumber": 7, "LineNumber": 16},
+                        "End": {"ColumnNumber": 19, "LineNumber": 16},
+                        "Path": [
+                            "Resources",
+                            "MyCognitoUserPool",
+                            "Properties",
+                            "UserPoolTags",
+                        ],
+                    },
+                    "Message": (
+                        "[{'Key': 'Key1', 'Value': 'Value1'}, {'Key': 'Key2', 'Value':"
+                        " 'Value2'}] is not of type 'object'"
+                    ),
+                    "ParentId": None,
+                    "Rule": {
+                        "Description": (
+                            "Checks resource property values with Primitive Types for"
+                            " values that match those types."
+                        ),
+                        "Id": "E3012",
+                        "ShortDescription": "Check resource properties values",
+                        "Source": "https://github.com/aws-cloudformation/cfn-lint/blob/main/docs/cfn-schema-specification.md#type",
+                    },
+                }
+            ],
+            "exit_code": 2,
+        },
+        {
+            "filename": "test/fixtures/templates/good/transform_serverless_api.yaml",
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": (
+                "test/fixtures/templates/good/transform_serverless_function.yaml"
+            ),
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": (
+                "test/fixtures/templates/good/transform_serverless_globals.yaml"
+            ),
+            "results": [
+                {
+                    "Filename": str(
+                        Path(
+                            "test/fixtures/templates/good/transform_serverless_globals.yaml"
+                        )
+                    ),
+                    "Id": "f0f6c586-81bc-9182-de02-659a3a1a5b2c",
+                    "Level": "Error",
+                    "Location": {
+                        "End": {"ColumnNumber": 13, "LineNumber": 10},
+                        "Path": ["Resources", "myFunction", "Properties", "Runtime"],
+                        "Start": {"ColumnNumber": 3, "LineNumber": 10},
+                    },
+                    "Message": "Runtime 'nodejs6.10' was deprecated on '2019-08-12'. Creation was disabled on '2019-08-12' and update on '2019-08-12'. Please consider updating to 'nodejs20.x'",
+                    "ParentId": None,
+                    "Rule": {
+                        "Description": (
+                            "Check if an EOL Lambda Runtime is specified and you cannot update the function"
+                        ),
+                        "Id": "E2533",
+                        "ShortDescription": (
+                            "Check if Lambda Function Runtimes are updatable"
+                        ),
+                        "Source": "https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html",
+                    },
+                }
+            ],
+            "exit_code": 2,
+        },
+        {
+            "filename": "test/fixtures/templates/good/transform/list_transform.yaml",
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": (
+                "test/fixtures/templates/good/transform/list_transform_many.yaml"
+            ),
+            "results": [],
+            "exit_code": 0,
+        },
+        {
+            "filename": (
+                "test/fixtures/templates/good/transform/list_transform_not_sam.yaml"
+            ),
+            "results": [],
+            "exit_code": 0,
+        },
+    ]
+
+    def test_templates(self):
+        """Test Successful JSON Parsing"""
+        self.run_scenarios()
+
+    def test_module_integration(self):
+        """Test same templates using integration approach"""
+        self.run_module_integration_scenarios(
+            ConfigMixIn([], include_checks=["W", "E"])
+        )

testbed/aws-cloudformation__cfn-lint/test/integration/test_integration_templates.py

@@ -0,0 +1,104 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from test.integration import BaseCliTestCase
+
+from cfnlint import ConfigMixIn
+
+
+class TestQuickStartTemplates(BaseCliTestCase):
+    """Test QuickStart Templates Parsing"""
+
+    scenarios = [
+        {
+            "filename": (
+                "test/fixtures/templates/integration"
+                "/resources-cloudformation-init.yaml"
+            ),
+            "results_filename": (
+                "test/fixtures/results/integration/"
+                "resources-cloudformation-init.json"
+            ),
+            "exit_code": 0,
+        },
+        {
+            "filename": "test/fixtures/templates/integration/dynamic-references.yaml",
+            "results_filename": (
+                "test/fixtures/results/integration" "/dynamic-references.json"
+            ),
+            "exit_code": 2,
+        },
+        {
+            "filename": "test/fixtures/templates/integration/ref-no-value.yaml",
+            "results_filename": ("test/fixtures/results/integration/ref-no-value.json"),
+            "exit_code": 2,
+        },
+        {
+            "filename": "test/fixtures/templates/integration/metdata.yaml",
+            "results_filename": ("test/fixtures/results/integration/metadata.json"),
+            "exit_code": 4,
+        },
+        {
+            "filename": ("test/fixtures/templates/integration/availability-zones.yaml"),
+            "results_filename": (
+                "test/fixtures/results/integration/availability-zones.json"
+            ),
+            "exit_code": 2,
+        },
+        {
+            "filename": ("test/fixtures/templates/integration/getatt-types.yaml"),
+            "results_filename": ("test/fixtures/results/integration/getatt-types.json"),
+            "exit_code": 10,
+        },
+        {
+            "filename": (
+                "test/fixtures/templates/integration/aws-ec2-networkinterface.yaml"
+            ),
+            "results_filename": (
+                "test/fixtures/results/integration/aws-ec2-networkinterface.json"
+            ),
+            "exit_code": 2,
+        },
+        {
+            "filename": ("test/fixtures/templates/integration/aws-ec2-instance.yaml"),
+            "results_filename": (
+                "test/fixtures/results/integration/aws-ec2-instance.json"
+            ),
+            "exit_code": 2,
+        },
+        {
+            "filename": (
+                "test/fixtures/templates/integration/aws-ec2-launchtemplate.yaml"
+            ),
+            "results_filename": (
+                "test/fixtures/results/integration/aws-ec2-launchtemplate.json"
+            ),
+            "exit_code": 2,
+        },
+        {
+            "filename": ("test/fixtures/templates/integration/aws-ec2-subnet.yaml"),
+            "results_filename": (
+                "test/fixtures/results/integration/aws-ec2-subnet.json"
+            ),
+            "exit_code": 2,
+        },
+        {
+            "filename": ("test/fixtures/templates/integration/aws-dynamodb-table.yaml"),
+            "results_filename": (
+                "test/fixtures/results/integration/aws-dynamodb-table.json"
+            ),
+            "exit_code": 2,
+        },
+    ]
+
+    def test_templates(self):
+        """Test same templates using integration approach"""
+        self.run_module_integration_scenarios(
+            ConfigMixIn(
+                [],
+                include_checks=["I"],
+                include_experimental=True,
+            )
+        )

testbed/aws-cloudformation__cfn-lint/test/integration/test_patches.py

@@ -0,0 +1,28 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import json
+import os
+from test.integration import BaseCliTestCase
+
+from jsonpatch import InvalidJsonPatch, JsonPatch
+
+
+class TestPatches(BaseCliTestCase):
+    """Test Patches"""
+
+    def test_patches(self):
+        """Test ignoring certain rules"""
+        for root, _, files in os.walk(
+            "src/cfnlint/data/ExtendedProviderSchemas", topdown=True
+        ):
+            for name in files:
+                if name.endswith(".json"):
+                    with open(os.path.join(root, name)) as fh:
+                        patches = json.load(fh)
+                        try:
+                            JsonPatch(patches)
+                        except InvalidJsonPatch:
+                            raise Exception(f"Invalid patch: {name}")

testbed/aws-cloudformation__cfn-lint/test/integration/test_quickstart_templates_non_strict.py

@@ -0,0 +1,71 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from test.integration import BaseCliTestCase
+
+from cfnlint import ConfigMixIn
+
+
+class TestQuickStartTemplates(BaseCliTestCase):
+    """Test QuickStart Templates Parsing"""
+
+    scenarios = [
+        {
+            "filename": "test/fixtures/templates/quickstart/nist_high_main.yaml",
+            "results_filename": (
+                "test/fixtures/results/quickstart/non_strict/nist_high_main.json"
+            ),
+            "exit_code": 14,
+        },
+        {
+            "filename": "test/fixtures/templates/quickstart/nist_application.yaml",
+            "results_filename": (
+                "test/fixtures/results/quickstart/non_strict/nist_application.json"
+            ),
+            "exit_code": 14,
+        },
+        {
+            "filename": "test/fixtures/templates/quickstart/openshift.yaml",
+            "results_filename": (
+                "test/fixtures/results/quickstart/non_strict/openshift.json"
+            ),
+            "exit_code": 12,
+        },
+        {
+            "filename": "test/fixtures/templates/quickstart/cis_benchmark.yaml",
+            "results_filename": (
+                "test/fixtures/results/quickstart/non_strict/cis_benchmark.json"
+            ),
+            "exit_code": 4,
+        },
+    ]
+
+    def test_templates(self):
+        """Test Successful JSON Parsing"""
+        self.maxDiff = None
+        self.run_scenarios(
+            [
+                "--include-checks",
+                "I",
+                "--include-experimental",
+                "--configure-rule",
+                "E3012:strict=false",
+            ]
+        )
+
+    def test_module_integration(self):
+        """Test same templates using integration approach"""
+        self.run_module_integration_scenarios(
+            ConfigMixIn(
+                [],
+                include_checks=["I"],
+                configure_rules={
+                    "E3012": {
+                        "strict": False,
+                    }
+                },
+                include_experimental=True,
+            )
+        )

testbed/aws-cloudformation__cfn-lint/test/integration/test_schema_files.py

@@ -0,0 +1,282 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import json
+import os
+import pathlib
+from typing import Any, List
+from unittest import TestCase
+
+import pytest
+import regex as re
+
+import cfnlint
+from cfnlint.helpers import REGIONS, ensure_list, load_plugins, load_resource
+from cfnlint.jsonschema import StandardValidator, ValidationError
+from cfnlint.schema.resolver import RefResolutionError, RefResolver
+
+
+@pytest.mark.data
+class TestSchemaFiles(TestCase):
+    """Test schema files"""
+
+    _found_keywords: List[str] = [
+        "*",
+        "Conditions",
+        "Description",
+        "Mappings",
+        "Metadata",
+        "Metadata/AWS::CloudFormation::Interface",
+        "Metadata/cfn-lint",
+        "Outputs",
+        "Outputs/*",
+        "Outputs/*/Condition",
+        "Outputs/*/Export/Name",
+        "Outputs/*/Value",
+        "Parameters",
+        "Parameters/*",
+        "Resources",
+        "Resources/*",
+        "Resources/*/Condition",
+        "Resources/*/CreationPolicy",
+        "Resources/*/DeletionPolicy",
+        "Resources/*/DependsOn",
+        "Resources/*/DependsOn/*",
+        "Resources/*/Metadata",
+        "Resources/*/Metadata/AWS::CloudFormation::Init",
+        "Resources/*/Type",
+        "Resources/*/UpdatePolicy",
+        "Resources/*/UpdateReplacePolicy",
+        "Rules",
+        "Rules/*/Assertions/*/Assert",
+        "Rules/*/RuleCondition",
+        "Transform",
+    ]
+
+    def setUp(self) -> None:
+        schema_path = os.path.join(os.path.dirname(cfnlint.__file__), "data", "schemas")
+        self.paths = {
+            "extensions": os.path.join(schema_path, "extensions"),
+            "providers": os.path.join(schema_path, "providers"),
+            "other": os.path.join(schema_path, "other"),
+            "fixtures": os.path.join(
+                os.path.dirname(__file__),
+                "..",
+                "fixtures",
+                "schemas",
+                "providers",
+            ),
+        }
+        filename = os.path.join(
+            self.paths["fixtures"], "..", "json_schema", "draft7.json"
+        )
+        with open(filename, "r") as fh:
+            d = json.load(fh)
+            self.schema_draft7 = d
+
+        super().setUp()
+
+    def get_files(self, dir):
+        for dirpath, _, filenames in os.walk(dir):
+            for filename in fnmatch.filter(filenames, "*.json"):
+                yield dirpath, filename
+
+    def pattern(self, validator, patrn, instance, schema):
+        try:
+            re.compile(patrn)
+        except Exception:
+            yield ValidationError(f"Pattern doesn't compile: {patrn}")
+
+    def validate_basic_schema_details(
+        self, schema_resolver: RefResolver, filepath: str
+    ):
+        """
+        Validate that readOnly, writeOnly, etc are valid
+        """
+        sections = [
+            "readOnlyProperties",
+            "writeOnlyProperties",
+            "conditionalCreateOnlyProperties",
+            "nonPublicProperties",
+            "nonPublicDefinitions",
+            "createOnlyProperties",
+            "deprecatedProperties",
+            "primaryIdentifier",
+        ]
+        for section in sections:
+            for prop in schema_resolver.referrer.get(section, []):
+                try:
+                    self.assertIsNotNone(schema_resolver.resolve_cfn_pointer(prop))
+                except RefResolutionError:
+                    self.fail(f"Can't find prop {prop} for {section} in {filepath}")
+
+    def _build_keywords(self, obj: Any, schema_resolver: RefResolver, refs: list[str]):
+        if not isinstance(obj, dict):
+            yield []
+            return
+
+        if "$ref" in obj:
+            ref = obj["$ref"]
+            if ref in refs:
+                yield []
+                return
+            _, resolved_schema = schema_resolver.resolve(ref)
+            yield from self._build_keywords(
+                resolved_schema, schema_resolver, refs + [ref]
+            )
+
+        if "type" in obj:
+            if "object" in ensure_list(obj["type"]):
+                if "properties" in obj:
+                    for k, v in obj["properties"].items():
+                        for item in self._build_keywords(v, schema_resolver, refs):
+                            yield [k] + item
+            if "array" in ensure_list(obj["type"]):
+                if "items" in obj:
+                    for item in self._build_keywords(
+                        obj["items"], schema_resolver, refs
+                    ):
+                        yield ["*"] + item
+
+        yield []
+
+    def build_keywords(self, schema_resolver):
+        self._found_keywords.append(
+            "/".join(["Resources", schema_resolver.referrer["typeName"], "Properties"])
+        )
+        for k, v in schema_resolver.referrer.get("properties").items():
+            for item in self._build_keywords(v, schema_resolver, []):
+                self._found_keywords.append(
+                    "/".join(
+                        [
+                            "Resources",
+                            schema_resolver.referrer["typeName"],
+                            "Properties",
+                            k,
+                        ]
+                        + item
+                    )
+                )
+
+    def test_data_module_specs(self):
+        """Test data file formats"""
+
+        draft7_schema = load_resource(
+            "cfnlint.data.schemas.other.draft7", "schema.json"
+        )
+        store = {"http://json-schema.org/draft-07/schema": draft7_schema}
+        dir = self.paths["fixtures"]
+        for dirpath, filename in self.get_files(dir):
+            with open(os.path.join(dirpath, filename), "r", encoding="utf8") as fh:
+                store[filename] = json.load(fh)
+
+        resolver = RefResolver.from_schema(
+            store["provider.definition.schema.v1.json"], store=store
+        )
+
+        validator = (
+            StandardValidator({})
+            .extend(
+                validators={
+                    "cfnLint": self.cfn_lint,
+                    "pattern": self.pattern,
+                },
+            )(schema=store["provider.definition.schema.v1.json"])
+            .evolve(resolver=resolver)
+        )
+
+        for region in REGIONS:
+            dir = os.path.join(
+                self.paths["providers"],
+                region.replace("-", "_"),
+            )
+
+            for dirpath, filename in self.get_files(dir):
+                with open(os.path.join(dirpath, filename), "r", encoding="utf8") as fh:
+                    d = json.load(fh)
+                    # not allowed but true with this resource
+                    if filename == "aws-cloudformation-customresource.json":
+                        d["additionalProperties"] = False
+                    if filename == "module.json":
+                        continue
+                    errs = list(validator.iter_errors(d))
+                    self.assertListEqual(
+                        errs, [], f"Error with {dirpath}/{filename}: {errs}"
+                    )
+                    schema_resolver = RefResolver(d)
+                    self.validate_basic_schema_details(
+                        schema_resolver, f"{dirpath}/{filename}"
+                    )
+
+                    if region == "us-east-1":
+                        self.build_keywords(schema_resolver)
+
+    def cfn_lint(self, validator, _, keywords, schema):
+        keywords = ensure_list(keywords)
+        self._found_keywords.extend(keywords)
+
+    def test_other_specs(self):
+        """Test data file formats"""
+
+        draft7_schema = load_resource(
+            "cfnlint.data.schemas.other.draft7", "schema.json"
+        )
+        store = {"http://json-schema.org/draft-07/schema": draft7_schema}
+        dir = self.paths["fixtures"]
+        for dirpath, filename in self.get_files(dir):
+            with open(os.path.join(dirpath, filename), "r", encoding="utf8") as fh:
+                store[filename] = json.load(fh)
+
+        resolver = RefResolver.from_schema(
+            store["http://json-schema.org/draft-07/schema"], store=store
+        )
+
+        validator = (
+            StandardValidator({})
+            .extend(
+                validators={
+                    "cfnLint": self.cfn_lint,
+                    "pattern": self.pattern,
+                },
+            )(schema=store["http://json-schema.org/draft-07/schema"])
+            .evolve(resolver=resolver)
+        )
+
+        for dir_name in ["extensions", "other"]:
+            dir = self.paths[dir_name]
+
+            for dirpath, filename in self.get_files(dir):
+                with open(os.path.join(dirpath, filename), "r", encoding="utf8") as fh:
+                    d = json.load(fh)
+                    errs = list(validator.iter_errors(d))
+                    self.assertListEqual(
+                        errs, [], f"Error with {dirpath}/{filename}: {errs}"
+                    )
+                    schema_resolver = RefResolver(d)
+                    self.validate_basic_schema_details(
+                        schema_resolver, f"{dirpath}/{filename}"
+                    )
+
+    def test_x_keywords(self):
+        root_dir = pathlib.Path(__file__).parent.parent.parent / "src/cfnlint/rules"
+        rules = load_plugins(
+            str(root_dir),
+            "CfnLintKeyword",
+            "cfnlint.rules.jsonschema.CfnLintKeyword",
+        )
+        rules.extend(
+            load_plugins(
+                str(root_dir),
+                "CfnLintJsonSchema",
+                "cfnlint.rules.jsonschema.CfnLintJsonSchema",
+            )
+        )
+
+        for rule in rules:
+            for keyword in rule.keywords:
+                self.assertIn(keyword, self._found_keywords, f"{keyword} not found")

testbed/aws-cloudformation__cfn-lint/test/testlib/__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/test/testlib/testcase.py

@@ -0,0 +1,33 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from unittest import TestCase
+
+import cfnlint.decode.cfn_yaml
+
+
+class BaseTestCase(TestCase):
+    """
+    All test cases should inherit from this class as any common
+    functionality that is added here will then be available to all
+    subclasses. This facilitates the ability to update in one spot
+    and allow all tests to get the update for easy maintenance.
+    """
+
+    def load_template(self, filename):
+        """Return template"""
+        return cfnlint.decode.cfn_yaml.load(filename)
+
+    def assertEqualListOfDicts(self, a, b):
+        """Compare two lists of dicts"""
+        assert isinstance(a, list)
+        assert isinstance(b, list)
+
+        def key_func(d):
+            """sort dict based on keys"""
+            items = ((k, v if v is not None else "") for k, v in d.items())
+            return sorted(items)
+
+        self.assertEqual(sorted(a, key=key_func), sorted(b, key=key_func))

testbed/aws-cloudformation__cfn-lint/test/unit/__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/test/unit/module/cfn_json/__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/test/unit/module/cfn_json/test_cfn_json.py

@@ -0,0 +1,109 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from io import StringIO
+from test.testlib.testcase import BaseTestCase
+from unittest.mock import patch
+
+import cfnlint.decode.cfn_json  # pylint: disable=E0401
+from cfnlint import ConfigMixIn
+from cfnlint.config import _DEFAULT_RULESDIR
+from cfnlint.rules import Rules
+from cfnlint.template.template import Template  # pylint: disable=E0401
+
+
+class TestCfnJson(BaseTestCase):
+    """Test JSON Parsing"""
+
+    def setUp(self):
+        """SetUp template object"""
+        self.rules = Rules.create_from_directory(_DEFAULT_RULESDIR)
+        self.config = ConfigMixIn(
+            include_experimental=True,
+        )
+
+        self.filenames = {
+            "config_rule": {
+                "filename": "test/fixtures/templates/quickstart/config-rules.json",
+                "failures": 5,
+            },
+            "iam": {
+                "filename": "test/fixtures/templates/quickstart/iam.json",
+                "failures": 5,
+            },
+            "nat_instance": {
+                "filename": "test/fixtures/templates/quickstart/nat-instance.json",
+                "failures": 4,
+            },
+            "vpc_management": {
+                "filename": "test/fixtures/templates/quickstart/vpc-management.json",
+                "failures": 9,
+            },
+            "vpc": {
+                "filename": "test/fixtures/templates/quickstart/vpc.json",
+                "failures": 5,
+            },
+            "poller": {
+                "filename": "test/fixtures/templates/public/lambda-poller.json",
+                "failures": 1,
+            },
+        }
+
+    def test_success_parse(self):
+        """Test Successful JSON Parsing"""
+        for _, values in self.filenames.items():
+            filename = values.get("filename")
+            failures = values.get("failures")
+
+            template = cfnlint.decode.cfn_json.load(filename)
+            cfn = Template(filename, template, ["us-east-1"])
+
+            matches = list(self.rules.run(filename, cfn, self.config))
+            assert (
+                len(matches) == failures
+            ), "Expected {} failures, got {} on {}".format(failures, matches, filename)
+
+    def test_success_escape_character(self):
+        """Test Successful JSON Parsing"""
+        failures = 1
+        filename = "test/fixtures/templates/good/decode/parsing.json"
+        template = cfnlint.decode.cfn_json.load(filename)
+        cfn = Template(filename, template, ["us-east-1"])
+
+        matches = list(self.rules.run(filename, cfn, self.config))
+        assert len(matches) == failures, "Expected {} failures, got {} on {}".format(
+            failures, matches, filename
+        )
+
+    def test_success_parse_stdin(self):
+        """Test Successful JSON Parsing through stdin"""
+        for _, values in self.filenames.items():
+            filename = None
+            failures = values.get("failures")
+            with open(values.get("filename"), "r") as fp:
+                file_content = fp.read()
+            with patch("sys.stdin", StringIO(file_content)):
+                template = cfnlint.decode.cfn_json.load(filename)
+                cfn = Template(filename, template, ["us-east-1"])
+
+                matches = list(self.rules.run(filename, cfn, self.config))
+                assert (
+                    len(matches) == failures
+                ), "Expected {} failures, got {} on {}".format(
+                    failures, matches, values.get("filename")
+                )
+
+    def test_fail_run(self):
+        """Test failure run"""
+
+        filename = "test/fixtures/templates/bad/json_parse.json"
+
+        try:
+            cfnlint.decode.cfn_json.load(filename)
+        except cfnlint.decode.cfn_json.JSONDecodeError:
+            assert True
+            return
+
+        assert False

testbed/aws-cloudformation__cfn-lint/test/unit/module/cfn_yaml/test_yaml.py

@@ -0,0 +1,77 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from io import StringIO
+from test.testlib.testcase import BaseTestCase
+from unittest.mock import patch
+
+import cfnlint.decode.cfn_yaml  # pylint: disable=E0401
+from cfnlint.config import _DEFAULT_RULESDIR, ConfigMixIn
+from cfnlint.rules import Rules
+from cfnlint.template.template import Template  # pylint: disable=E0401
+
+
+class TestYamlParse(BaseTestCase):
+    """Test YAML Parsing"""
+
+    def setUp(self):
+        """SetUp template object"""
+        self.rules = Rules.create_from_directory(_DEFAULT_RULESDIR)
+
+        self.filenames = {
+            "config_rule": {
+                "filename": "test/fixtures/templates/public/lambda-poller.yaml",
+                "failures": 1,
+            },
+            "generic_bad": {
+                "filename": "test/fixtures/templates/bad/generic.yaml",
+                "failures": 35,
+            },
+        }
+
+    def test_success_parse(self):
+        """Test Successful YAML Parsing"""
+        for _, values in self.filenames.items():
+            filename = values.get("filename")
+            failures = values.get("failures")
+            template = cfnlint.decode.cfn_yaml.load(filename)
+            cfn = Template(filename, template, ["us-east-1"])
+
+            matches = list(self.rules.run(filename, cfn, ConfigMixIn({})))
+            assert (
+                len(matches) == failures
+            ), "Expected {} failures, got {} on {}".format(
+                failures, len(matches), filename
+            )
+
+    def test_success_parse_stdin(self):
+        """Test Successful YAML Parsing through stdin"""
+        for _, values in self.filenames.items():
+            filename = None
+            failures = values.get("failures")
+            with open(values.get("filename"), "r") as fp:
+                file_content = fp.read()
+
+            with patch("sys.stdin", StringIO(file_content)):
+                template = cfnlint.decode.cfn_yaml.load(filename)
+                cfn = Template(filename, template, ["us-east-1"])
+
+                matches = []
+                matches.extend(self.rules.run(filename, cfn, ConfigMixIn({})))
+                assert (
+                    len(matches) == failures
+                ), "Expected {} failures, got {} on {}".format(
+                    failures, len(matches), values.get("filename")
+                )
+
+    def test_map_failure(self):
+        """Test a failure is passed on unhashable map"""
+        filename = "test/fixtures/templates/bad/core/parse_invalid_map.yaml"
+
+        self.assertRaises(
+            cfnlint.decode.cfn_yaml.CfnParseError,
+            cfnlint.decode.cfn_yaml.load,
+            filename,
+        )

testbed/aws-cloudformation__cfn-lint/test/unit/module/conditions/__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/test/unit/module/conditions/test_condition.py

@@ -0,0 +1,97 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from unittest import TestCase
+
+from cfnlint.conditions._condition import (
+    ConditionAnd,
+    ConditionNot,
+    ConditionOr,
+    ConditionUnnammed,
+)
+from cfnlint.conditions._utils import get_hash
+
+
+class TestCondition(TestCase):
+    """Test Condition"""
+
+    def test_not_condition(self):
+        """Test not condition"""
+
+        with self.assertRaises(ValueError):
+            ConditionNot(
+                [
+                    {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]},
+                    {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-west-2"]},
+                ],
+                {},
+            )
+
+    def test_unnamed_condition(self):
+        """Test unnamed condition"""
+
+        with self.assertRaises(ValueError):
+            ConditionUnnammed(
+                "equals",  # not a string
+                {},
+            )
+
+    def test_not_a_list(self):
+        """Test condition failures"""
+
+        with self.assertRaises(ValueError):
+            ConditionUnnammed({"Fn::And": {}}, {})
+
+        with self.assertRaises(ValueError):
+            ConditionUnnammed({"Condition": {}}, {})
+
+        with self.assertRaises(ValueError):
+            ConditionUnnammed({"BadKey": {}}, {})
+
+    def test_condition_test(self):
+        equals = {"Ref": "AWS::Region"}
+        h = get_hash(equals)
+        self.assertTrue(
+            ConditionNot(
+                [
+                    {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]},
+                ],
+                {},
+            )._test(
+                {h: "us-west-2"},
+            )
+        )
+        self.assertFalse(
+            ConditionNot(
+                [
+                    {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]},
+                ],
+                {},
+            )._test(
+                {h: "us-east-1"},
+            )
+        )
+        self.assertFalse(
+            ConditionAnd(
+                [
+                    {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]},
+                    {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-west-2"]},
+                ],
+                {},
+            )._test(
+                {h: "us-east-1"},
+            )
+        )
+        self.assertTrue(
+            ConditionOr(
+                [
+                    {"Fn::Equals": ["us-east-1", {"Ref": "AWS::Region"}]},
+                    {"Fn::Equals": ["us-west-2", {"Ref": "AWS::Region"}]},
+                ],
+                {},
+            )._test(
+                {h: "us-east-1"},
+            )
+        )

testbed/aws-cloudformation__cfn-lint/test/unit/module/conditions/test_conditions.py

@@ -0,0 +1,331 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import string
+from unittest import TestCase
+
+from cfnlint.conditions import UnknownSatisfisfaction
+from cfnlint.conditions._utils import get_hash
+from cfnlint.decode import decode_str
+from cfnlint.template import Template
+
+
+class TestConditions(TestCase):
+    """Test Conditions"""
+
+    def test_bad_condition_definition(self):
+        """Badly formatted condition statements will return no results"""
+        template = decode_str(
+            """
+        Conditions:
+          IsProd: !Equals [!Ref Environment, "prod", "production"]
+          IsUsEast1: !Equals [!Ref "AWS::Region", "us-east-1"]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(
+            len(cfn.conditions._conditions), 1
+        )  # would be 2 but IsProd fails
+        # test coverage for KeyErrors in the following functions
+        self.assertTrue(
+            cfn.conditions.check_implies(
+                {
+                    "Test": True,
+                },
+                "IsUsEast1",
+            )
+        )
+        self.assertEqual(
+            list(cfn.conditions.build_scenarios({"IsProd": None, "IsUsEast1": None})),
+            [],
+        )
+
+    def test_run_away_scenarios(self):
+        """We cap runaway scenarios"""
+        template = {
+            "Parameters": {},
+            "Conditions": {},
+        }
+        condition_names = {}
+        for p in string.ascii_letters[0:10]:
+            template["Parameters"][f"{p}Parameter"] = {
+                "Type": "String",
+            }
+            template["Conditions"][f"{p}Condition"] = {
+                "Fn::Equals": [{"Ref": f"{p}Parameter"}, "{p}"]
+            }
+            condition_names[f"{p}Condition"] = None
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 10)
+        self.assertEqual(
+            len(list(cfn.conditions.build_scenarios(condition_names))),
+            cfn.conditions._max_scenarios,
+        )
+
+    def test_check_implies(self):
+        """We properly validate implies scenarios"""
+        template = {
+            "Parameters": {},
+            "Conditions": {},
+        }
+        condition_names = []
+        for p in string.ascii_letters[0:4]:
+            template["Parameters"][f"{p}Parameter"] = {
+                "Type": "String",
+            }
+            template["Conditions"][f"{p}Condition"] = {
+                "Fn::Equals": [{"Ref": f"{p}Parameter"}, "{p}"]
+            }
+            condition_names.append(f"{p}Condition")
+
+        cfn = Template("", template)
+        self.assertFalse(
+            cfn.conditions.check_implies({"aCondition": False}, "aCondition")
+        )
+        self.assertTrue(
+            cfn.conditions.check_implies({"aCondition": True}, "aCondition")
+        )
+        self.assertTrue(
+            cfn.conditions.check_implies(
+                {"aCondition": True, "bCondition": False}, "aCondition"
+            )
+        )
+
+    def test_check_always_true_or_false(self):
+        """We properly validate static equals"""
+        template = decode_str(
+            """
+        Parameters:
+          FalseParameter:
+            Default: "false"
+            Type: String
+        Conditions:
+          IsTrue: !Equals ["true", "true"]
+          IsFalse: !Equals [!Ref FalseParameter, !Ref FalseParameter]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 2)
+        # test coverage for KeyErrors in the following functions
+        self.assertTrue(cfn.conditions.check_implies({"IsTrue": True}, "IsFalse"))
+
+    def test_check_never_false(self):
+        """With allowed values two conditions can not both be false"""
+        template = decode_str(
+            """
+        Parameters:
+          Environment:
+            Type: String
+            AllowedValues: ["prod", "dev"]
+        Conditions:
+          IsProd: !Equals [!Ref Environment, "prod"]
+          IsDev: !Equals [!Ref Environment, "dev"]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 2)
+        self.assertListEqual(
+            list(cfn.conditions.build_scenarios({"IsProd": None, "IsDev": None})),
+            [
+                {"IsProd": True, "IsDev": False},
+                {"IsProd": False, "IsDev": True},
+            ],
+        )
+
+    def test_check_can_be_false(self):
+        """With allowed values two conditions can both be false"""
+        template = decode_str(
+            """
+        Parameters:
+          Environment:
+            Type: String
+            AllowedValues: ["prod", "dev", "stage"]
+        Conditions:
+          IsProd: !Equals [!Ref Environment, "prod"]
+          IsDev: !Equals [!Ref Environment, "dev"]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 2)
+        self.assertListEqual(
+            list(cfn.conditions.build_scenarios({"IsProd": None, "IsDev": None})),
+            [
+                {"IsProd": True, "IsDev": False},
+                {"IsProd": False, "IsDev": True},
+                {"IsProd": False, "IsDev": False},
+            ],
+        )
+        self.assertListEqual(
+            list(cfn.conditions.build_scenarios({"IsProd": {True}, "IsDev": None})),
+            [
+                {"IsProd": True, "IsDev": False},
+            ],
+        )
+        self.assertListEqual(
+            list(cfn.conditions.build_scenarios({"IsProd": {False}, "IsDev": None})),
+            [
+                {"IsProd": False, "IsDev": True},
+                {"IsProd": False, "IsDev": False},
+            ],
+        )
+
+    def test_check_can_be_good_when_condition_value(self):
+        """Some times a condition Equals doesn't match to allowed values"""
+        template = decode_str(
+            """
+        Parameters:
+          Environment:
+            Type: String
+            AllowedValues: ["prod", "dev", "stage"]
+        Conditions:
+          IsGamma: !Equals [!Ref Environment, "gamma"]
+          IsBeta: !Equals ["beta", !Ref Environment]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 2)
+        self.assertListEqual(
+            list(cfn.conditions.build_scenarios({"IsGamma": None, "IsBeta": None})),
+            [
+                {"IsBeta": False, "IsGamma": False},
+            ],
+        )
+        self.assertListEqual(
+            list(cfn.conditions.build_scenarios({"IsGamma": None})),
+            [
+                {"IsGamma": False},
+            ],
+        )
+
+    def test_check_condition_region(self):
+        """Regional based condition testing"""
+        template = decode_str(
+            """
+        Parameters:
+          Environment:
+            Type: String
+            AllowedValues: ["prod", "dev", "stage"]
+        Conditions:
+          IsUsEast1: !Equals [!Ref AWS::Region, "us-east-1"]
+          IsUsWest2: !Equals ["us-west-2", !Ref AWS::Region]
+          IsProd: !Equals [!Ref Environment, "prod"]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 3)
+        self.assertListEqual(
+            cfn.conditions.build_scenerios_on_region("IsUsEast1", "us-east-1"),
+            [
+                True,
+            ],
+        )
+        self.assertListEqual(
+            cfn.conditions.build_scenerios_on_region("IsUsEast1", "us-west-2"),
+            [
+                False,
+            ],
+        )
+        self.assertListEqual(
+            cfn.conditions.build_scenerios_on_region("IsUsWest2", "us-west-2"),
+            [
+                True,
+            ],
+        )
+        self.assertListEqual(
+            cfn.conditions.build_scenerios_on_region("IsUsWest2", "us-east-1"),
+            [
+                False,
+            ],
+        )
+        self.assertListEqual(
+            cfn.conditions.build_scenerios_on_region("IsProd", "us-east-1"),
+            [
+                True,
+                False,
+            ],
+        )
+        self.assertListEqual(
+            cfn.conditions.build_scenerios_on_region("Foo", "us-east-1"),
+            [
+                True,
+                False,
+            ],
+        )
+
+    def test_test_condition(self):
+        """Get condition and test"""
+        template = decode_str(
+            """
+        Parameters:
+          Environment:
+            Type: String
+            AllowedValues: ["prod", "dev", "stage"]
+        Conditions:
+          IsUsEast1: !Equals [!Ref AWS::Region, "us-east-1"]
+          IsUsWest2: !Equals ["us-west-2", !Ref AWS::Region]
+          IsProd: !Equals [!Ref Environment, "prod"]
+          IsUsEast1AndProd: !And [!Condition IsUsEast1, !Condition IsProd]
+        """
+        )[0]
+
+        h_region = get_hash({"Ref": "AWS::Region"})
+        h_environment = get_hash({"Ref": "Environment"})
+
+        cfn = Template("", template)
+        self.assertTrue(cfn.conditions.get("IsUsEast1").test({h_region: "us-east-1"}))
+        self.assertFalse(cfn.conditions.get("IsProd").test({h_environment: "dev"}))
+        self.assertTrue(
+            cfn.conditions.get("IsUsEast1AndProd").test(
+                {h_region: "us-east-1", h_environment: "prod"}
+            )
+        )
+        self.assertFalse(
+            cfn.conditions.get("IsUsEast1AndProd").test(
+                {h_region: "us-east-1", h_environment: "dev"}
+            )
+        )
+
+    def test_build_scenerios_on_region_with_condition_dne(self):
+        """Get condition and test"""
+        template = decode_str(
+            """
+        Conditions:
+          IsUsEast1: !Equals [!Ref AWS::Region, "us-east-1"]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertListEqual(
+            list(cfn.conditions.build_scenerios_on_region("IsProd", "us-east-1")),
+            [True, False],
+        )
+
+    def test_satifaction(self):
+        """Get condition and test"""
+        template = decode_str(
+            """
+        Parameters:
+          SecurityGroups:
+            Default: ""
+            Type: CommaDelimitedList
+        Conditions:
+          IsUsEast1: !Equals [!Ref AWS::Region, "us-east-1"]
+          HasSecurityGroups: !Not [ !Equals [ !Join [ '', !Ref SecurityGroups ], ''] ]
+        """
+        )[0]
+
+        cfn = Template("", template)
+
+        with self.assertRaises(UnknownSatisfisfaction):
+            cfn.conditions.satisfiable(
+                {"HasSecurityGroups": True}, {"SecurityGroups": [""]}
+            )

testbed/aws-cloudformation__cfn-lint/test/unit/module/conditions/test_equals.py

@@ -0,0 +1,74 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from unittest import TestCase
+
+from cfnlint.conditions._equals import Equal
+from cfnlint.conditions._utils import get_hash
+
+
+class TestEquals(TestCase):
+    """Test Equals"""
+
+    def setUp(self) -> None:
+        self.equals = {"Ref": "AWS::Region"}
+        self.equals_h = get_hash(self.equals)
+
+        self.parameter_region = {"Ref": "Region"}
+        self.parameter_region_h = get_hash(self.parameter_region)
+
+        self.parameter_env = {"Ref": "Environment"}
+        self.parameter_env_h = get_hash(self.parameter_env)
+
+        return super().setUp()
+
+    def test_equals_error_test(self):
+        """Test equals scenarios condition"""
+        equal = Equal([self.equals, "us-east-1"])
+
+        with self.assertRaises(ValueError):
+            equal.test({"foo": "bar"})
+
+    def test_equals_left_test(self):
+        """Test equals scenarios condition"""
+        equal = Equal([self.equals, "us-east-1"])
+
+        self.assertTrue(equal.test({self.equals_h: "us-east-1"}))
+        self.assertFalse(equal.test({self.equals_h: "us-west-2"}))
+
+        equal = Equal([self.equals, self.parameter_region])
+        self.assertTrue(
+            equal.test(
+                {
+                    self.equals_h: self.parameter_region_h,
+                    self.parameter_region_h: self.equals_h,
+                }
+            )
+        )
+        self.assertFalse(equal.test({self.equals_h: self.parameter_env_h}))
+
+    def test_equals_left_right(self):
+        """Test equals scenarios condition"""
+        equal = Equal(["us-east-1", self.equals])
+
+        self.assertTrue(equal.test({self.equals_h: "us-east-1"}))
+        self.assertFalse(equal.test({self.equals_h: "us-west-2"}))
+
+        equal = Equal([self.parameter_region, self.equals])
+        self.assertTrue(
+            equal.test(
+                {
+                    self.equals_h: self.parameter_region_h,
+                    self.parameter_region_h: self.equals_h,
+                }
+            )
+        )
+        self.assertFalse(equal.test({self.equals_h: self.parameter_env_h}))
+
+    def test_equal_string_test(self):
+        """Test equals scenarios condition"""
+        equal = Equal(["us-west-2", "us-east-1"])
+
+        self.assertFalse(equal.test({"foo": "bar"}))

testbed/aws-cloudformation__cfn-lint/test/unit/module/conditions/test_rules.py

@@ -0,0 +1,524 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from unittest import TestCase
+
+from cfnlint.conditions._rule import _Assertion
+from cfnlint.decode import decode_str
+from cfnlint.template import Template
+
+
+class TestConditionsWithRules(TestCase):
+
+    def test_conditions_with_rules(self):
+        template = decode_str(
+            """
+        Conditions:
+          IsProd: !Equals [!Ref Environment, "prod"]
+          IsUsEast1: !Equals [!Ref "AWS::Region", "us-east-1"]
+        Rules:
+          Rule1:
+            Assertions:
+            - Assert:
+                Fn::And:
+                - !Equals [!Ref Environment, "prod"]
+                - !Equals [!Ref "AWS::Region", "us-east-1"]
+          Rule2:
+            Assertions:
+            - Assert:
+                Fn::Or:
+                - !Equals [!Ref Environment, "prod"]
+                - !Equals [!Ref "AWS::Region", "us-east-1"]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 2)
+        self.assertEqual(len(cfn.conditions._rules), 2)
+
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[0].equals],
+            [
+                "d0f5e92fc5233a6b011342df171f191838491056",
+                "362a2ca660fa34c91feeee4681e8433101d2a687",
+            ],
+        )
+
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {"IsProd": True, "IsUsEast1": True},
+                {"AWS::Region": "us-east-1", "Environment": "prod"},
+            )
+        )
+        self.assertFalse(
+            cfn.conditions.satisfiable(
+                {"IsProd": True, "IsUsEast1": False},
+                {"AWS::Region": "us-west-2", "Environment": "prod"},
+            )
+        )
+        self.assertFalse(
+            cfn.conditions.satisfiable(
+                {"IsProd": False, "IsUsEast1": True},
+                {"AWS::Region": "us-east-1", "Environment": "dev"},
+            )
+        )
+        self.assertFalse(
+            cfn.conditions.satisfiable(
+                {"IsProd": False, "IsUsEast1": False},
+                {"AWS::Region": "us-west-2", "Environment": "dev"},
+            )
+        )
+
+    def test_conditions_with_rules_implies(self):
+        template = decode_str(
+            """
+        Conditions:
+          IsProd: !Equals [!Ref Environment, "prod"]
+          IsUsEast1: !Equals [!Ref "AWS::Region", "us-east-1"]
+        Rules:
+          Rule:
+            RuleCondition: !Equals [!Ref Environment, "prod"]
+            Assertions:
+            - Assert: !Equals [!Ref "AWS::Region", "us-east-1"]
+
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 2)
+        self.assertEqual(len(cfn.conditions._rules), 1)
+
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[0].equals],
+            [
+                "d0f5e92fc5233a6b011342df171f191838491056",
+                "362a2ca660fa34c91feeee4681e8433101d2a687",
+            ],
+        )
+
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {"IsProd": True, "IsUsEast1": True},
+                {"AWS::Region": "us-east-1", "Environment": "prod"},
+            )
+        )
+        self.assertFalse(
+            cfn.conditions.satisfiable(
+                {"IsProd": True, "IsUsEast1": False},
+                {"AWS::Region": "us-west-2", "Environment": "prod"},
+            )
+        )
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {"IsProd": False, "IsUsEast1": True},
+                {"AWS::Region": "us-east-1", "Environment": "dev"},
+            )
+        )
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {"IsProd": False, "IsUsEast1": False},
+                {"AWS::Region": "us-west-2", "Environment": "dev"},
+            )
+        )
+
+    def test_conditions_with_multiple_rules(self):
+        template = decode_str(
+            """
+        Parameters:
+          Environment:
+            Type: String
+            Default: dev
+            AllowedValues:
+            - dev
+            - stage
+            - prod
+        Conditions:
+          IsProd: !Equals [!Ref Environment, "prod"]
+          IsDev: !Equals [!Ref Environment, "dev"]
+          IsUsEast1: !Equals [!Ref "AWS::Region", "us-east-1"]
+          IsNotUsEast1: !Not [!Condition IsUsEast1]
+        Rules:
+          Rule1:
+            RuleCondition: !Equals [!Ref Environment, "prod"]
+            Assertions:
+            - Assert: !Equals [!Ref "AWS::Region", "us-east-1"]
+          Rule2:
+            RuleCondition: !Equals [!Ref Environment, "dev"]
+            Assertions:
+            - Assert: !Not [!Equals [!Ref "AWS::Region", "us-east-1"]]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 4)
+        self.assertEqual(len(cfn.conditions._rules), 2)
+
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[0].equals],
+            [
+                "d0f5e92fc5233a6b011342df171f191838491056",
+                "362a2ca660fa34c91feeee4681e8433101d2a687",
+            ],
+        )
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[1].equals],
+            [
+                "d2dab653475dd270354fe84c4f80b54883e958bb",
+                "362a2ca660fa34c91feeee4681e8433101d2a687",
+            ],
+        )
+
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {
+                    "IsProd": True,
+                    "IsUsEast1": True,
+                    "IsDev": False,
+                    "IsNotUsEast1": False,
+                },
+                {"AWS::Region": "us-east-1", "Environment": "prod"},
+            )
+        )
+        self.assertFalse(
+            cfn.conditions.satisfiable(
+                {
+                    "IsProd": True,
+                    "IsUsEast1": False,
+                    "IsDev": False,
+                    "IsNotUsEast1": False,
+                },
+                {"AWS::Region": "us-west-2", "Environment": "prod"},
+            )
+        )
+        self.assertFalse(
+            cfn.conditions.satisfiable(
+                {
+                    "IsProd": False,
+                    "IsUsEast1": True,
+                    "IsDev": True,
+                    "IsNotUsEast1": False,
+                },
+                {"AWS::Region": "us-east-1", "Environment": "dev"},
+            )
+        )
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {
+                    "IsProd": False,
+                    "IsUsEast1": False,
+                    "IsDev": True,
+                    "IsNotUsEast1": True,
+                },
+                {"AWS::Region": "us-west-2", "Environment": "dev"},
+            )
+        )
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {
+                    "IsProd": False,
+                    "IsUsEast1": True,
+                    "IsDev": False,
+                    "IsNotUsEast1": False,
+                },
+                {"AWS::Region": "us-east-1", "Environment": "stage"},
+            )
+        )
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {
+                    "IsProd": False,
+                    "IsUsEast1": False,
+                    "IsDev": False,
+                    "IsNotUsEast1": True,
+                },
+                {"AWS::Region": "us-west-2", "Environment": "stage"},
+            )
+        )
+
+    def test_fn_equals_assertions_two(self):
+        template = decode_str(
+            """
+        Rules:
+          Rule1:
+            Assertions:
+            - Assert: !Equals ["A", "B"]
+          Rule2:
+            Assertions:
+            - Assert: !Equals ["A", "A"]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 0)
+        self.assertEqual(len(cfn.conditions._rules), 2)
+
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[0].equals],
+            [
+                "e7e68477799682e53ecb09f476128abaeba0bdae",
+            ],
+        )
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[1].equals],
+            [
+                "da2a95009a205d5caacd42c3c11ebd4c151b3409",
+            ],
+        )
+
+        self.assertFalse(
+            cfn.conditions.satisfiable(
+                {},
+                {},
+            )
+        )
+
+    def test_fn_equals_assertions_one(self):
+        template = decode_str(
+            """
+        Rules:
+          Rule1:
+            Assertions:
+            - Assert: !Equals ["A", "A"]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 0)
+        self.assertEqual(len(cfn.conditions._rules), 1)
+
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[0].equals],
+            [
+                "da2a95009a205d5caacd42c3c11ebd4c151b3409",
+            ],
+        )
+
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {},
+                {},
+            )
+        )
+
+    def test_fn_equals_assertions_ref_no_data(self):
+        template = decode_str(
+            """
+        Parameters:
+            AccountId:
+                Type: String
+        Rules:
+          Rule1:
+            Assertions:
+            - Assert: !Equals [!Ref AccountId, !Ref AWS::AccountId]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 0)
+        self.assertEqual(len(cfn.conditions._rules), 1)
+
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[0].equals],
+            [
+                "f36e61f3d5bf6cdc6ea2e7f01487af728094a439",
+            ],
+        )
+
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {},
+                {},
+            )
+        )
+
+    def test_fn_equals_assertions_ref_never_satisfiable(self):
+        template = decode_str(
+            """
+        Parameters:
+            AccountId:
+                Type: String
+        Rules:
+          Rule1:
+            Assertions:
+            - Assert: !Equals [!Ref AccountId, !Ref AWS::AccountId]
+            - Assert: !Not [!Equals [!Ref AccountId, !Ref AWS::AccountId]]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 0)
+        self.assertEqual(len(cfn.conditions._rules), 1)
+
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[0].equals],
+            [
+                "f36e61f3d5bf6cdc6ea2e7f01487af728094a439",
+                "f36e61f3d5bf6cdc6ea2e7f01487af728094a439",
+            ],
+        )
+
+        self.assertFalse(
+            cfn.conditions.satisfiable(
+                {},
+                {},
+            )
+        )
+
+    def test_conditions_with_rules_and_parameters(self):
+        template = decode_str(
+            """
+        Conditions:
+            DeployGateway: !Equals
+                - !Ref 'DeployGateway'
+                - 'true'
+            DeployVpc: !Equals
+                - !Ref 'DeployVpc'
+                - 'true'
+        Parameters:
+            DeployAnything:
+                AllowedValues:
+                - 'false'
+                - 'true'
+                Type: 'String'
+            DeployGateway:
+                AllowedValues:
+                - 'false'
+                - 'true'
+                Type: 'String'
+            DeployVpc:
+                AllowedValues:
+                - 'false'
+                - 'true'
+                Type: 'String'
+        Rules:
+            DeployGateway:
+                Assertions:
+                - Assert: !Or
+                    - !Equals
+                        - !Ref 'DeployAnything'
+                        - 'true'
+                    - !Equals
+                        - !Ref 'DeployGateway'
+                        - 'false'
+            DeployVpc:
+                Assertions:
+                - Assert: !Or
+                    - !Equals
+                        - !Ref 'DeployGateway'
+                        - 'true'
+                    - !Equals
+                        - !Ref 'DeployVpc'
+                        - 'false'
+        Resources:
+            InternetGateway:
+                Condition: 'DeployGateway'
+                Type: 'AWS::EC2::InternetGateway'
+            InternetGatewayAttachment:
+                Condition: 'DeployVpc'
+                Type: 'AWS::EC2::VPCGatewayAttachment'
+                Properties:
+                    InternetGatewayId: !Ref 'InternetGateway'
+                    VpcId: !Ref 'Vpc'
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._conditions), 2)
+        self.assertEqual(len(cfn.conditions._rules), 2)
+
+        self.assertListEqual(
+            [equal.hash for equal in cfn.conditions._rules[0].equals],
+            [
+                "d0d70a1e66dc83d7a0fce24c2eca396af1f34e53",
+                "bbf5c94c1a4b5a79c7a7863fe9463884cb422450",
+            ],
+        )
+
+        self.assertTrue(
+            cfn.conditions.satisfiable(
+                {},
+                {},
+            )
+        )
+
+        self.assertTrue(
+            cfn.conditions.check_implies({"DeployVpc": True}, "DeployGateway")
+        )
+
+        self.assertFalse(
+            cfn.conditions.check_implies({"DeployVpc": False}, "DeployGateway")
+        )
+
+        self.assertFalse(
+            cfn.conditions.check_implies({"DeployGateway": False}, "DeployVpc")
+        )
+
+
+class TestAssertion(TestCase):
+    def test_assertion_errors(self):
+        with self.assertRaises(ValueError):
+            _Assertion({"A": "B", "C": "D"}, {})
+
+        with self.assertRaises(ValueError):
+            _Assertion({"Fn::Not": {"C": "D"}}, {})
+
+        with self.assertRaises(ValueError):
+            _Assertion({"Not": {"C": "D"}}, {})
+
+        with self.assertRaises(ValueError):
+            _Assertion({"Condition": {"C": "D"}}, {})
+
+    def test_init_rules_with_list(self):
+        template = decode_str(
+            """
+        Conditions:
+          IsUsEast1: !Equals [!Ref "AWS::Region", "us-east-1"]
+          IsNotUsEast1: !Not [!Condition IsUsEast1]
+        Rules: []
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertListEqual(cfn.conditions._rules, [])
+
+    def test_init_rules_with_wrong_assertions_type(self):
+        template = decode_str(
+            """
+        Conditions:
+          IsUsEast1: !Equals [!Ref "AWS::Region", "us-east-1"]
+          IsNotUsEast1: !Not [!Condition IsUsEast1]
+        Rules:
+          Rule1:
+            Assertions: {"Foo": "Bar"}
+          Rule2:
+            Assertions:
+            - Assert: !Equals [!Ref "AWS::Region", "us-east-1"]
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._rules), 1)
+
+    def test_init_rules_with_no_keys(self):
+        template = decode_str(
+            """
+        Conditions:
+          IsUsEast1: !Equals [!Ref "AWS::Region", "us-east-1"]
+          IsNotUsEast1: !Not [!Condition IsUsEast1]
+        Rules:
+          Rule1:
+            Foo: Bar
+          Rule2:
+            Assertions:
+            - Assert:
+                Fn::Or:
+                - !Not [!Equals [!Ref "AWS::Region", "us-east-1"]]
+                - !Equals [!Ref "AWS::Region", "us-east-1"]
+          Rule3: []
+        """
+        )[0]
+
+        cfn = Template("", template)
+        self.assertEqual(len(cfn.conditions._rules), 1)

testbed/aws-cloudformation__cfn-lint/test/unit/module/config/__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/test/unit/module/config/test_cli_args.py

@@ -0,0 +1,137 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import logging
+import os
+from test.testlib.testcase import BaseTestCase
+from unittest.mock import patch
+
+import cfnlint.config  # pylint: disable=E0401
+
+LOGGER = logging.getLogger("cfnlint")
+
+
+class TestArgsParser(BaseTestCase):
+    """Test Parser Arguments"""
+
+    def tearDown(self):
+        """Setup"""
+        for handler in LOGGER.handlers:
+            LOGGER.removeHandler(handler)
+
+    def test_create_parser(self):
+        """Test success run"""
+
+        config = cfnlint.config.CliArgs(
+            ["-t", "test.yaml", "--ignore-bad-template", "--format", "quiet", "--debug"]
+        )
+        self.assertEqual(config.cli_args.templates, [])
+        self.assertEqual(config.cli_args.template_alt, ["test.yaml"])
+        self.assertEqual(config.cli_args.ignore_bad_template, True)
+        self.assertEqual(config.cli_args.format, "quiet")
+        self.assertEqual(config.cli_args.debug, True)
+
+    def test_create_parser_default_param(self):
+        """Test success run"""
+
+        config = cfnlint.config.CliArgs(
+            [
+                "--regions",
+                "us-east-1",
+                "us-west-2",
+                "--",
+                "template1.yaml",
+                "template2.yaml",
+            ]
+        )
+        self.assertEqual(
+            config.cli_args.templates, ["template1.yaml", "template2.yaml"]
+        )
+        self.assertEqual(config.cli_args.template_alt, [])
+        self.assertEqual(config.cli_args.regions, ["us-east-1", "us-west-2"])
+
+    def test_stdout(self):
+        """Test success run"""
+
+        config = cfnlint.config.CliArgs(["-t", "template1.yaml"])
+        self.assertIsNone(config.cli_args.output_file)
+
+    def test_output_file(self):
+        """Test success run"""
+
+        config = cfnlint.config.CliArgs(
+            ["-t", "template1.yaml", "--output-file", "test_output.txt"]
+        )
+        self.assertEqual(config.cli_args.output_file, "test_output.txt")
+
+    def test_force_update_specs(self):
+        """Test success run"""
+
+        config = cfnlint.config.CliArgs(["--update-specs", "--force"])
+        self.assertEqual(config.cli_args.force, True)
+        self.assertEqual(config.cli_args.update_specs, True)
+
+    def test_create_parser_exend(self):
+        """Test success run"""
+
+        config = cfnlint.config.CliArgs(
+            ["-t", "template1.yaml", "-t", "template2.yaml"]
+        )
+        self.assertEqual(config.cli_args.templates, [])
+        self.assertEqual(
+            config.cli_args.template_alt, ["template1.yaml", "template2.yaml"]
+        )
+
+    def test_create_parser_config_file_regions(self):
+        """Test success run"""
+
+        config = cfnlint.config.CliArgs(
+            [
+                "--regions",
+                "us-west-1",
+                "--include-checks",
+                "I1234",
+                "--",
+                "template1.yaml",
+            ]
+        )
+        self.assertEqual(config.cli_args.templates, ["template1.yaml"])
+        self.assertEqual(config.cli_args.include_checks, ["I1234"])
+        self.assertEqual(config.cli_args.regions, ["us-west-1"])
+
+    def test_create_parser_config_file(self):
+        """Test success run"""
+
+        config = cfnlint.config.CliArgs(
+            ["--mandatory-checks", "I1234", "--", "template1.yaml"]
+        )
+        self.assertEqual(config.cli_args.templates, ["template1.yaml"])
+        self.assertEqual(config.cli_args.mandatory_checks, ["I1234"])
+
+    def test_create_parser_rule_configuration(self):
+        """Test success run"""
+
+        config = cfnlint.config.CliArgs(
+            ["-x", "E3012:strict=true", "-x", "E3012:key=value,E3001:key=value"]
+        )
+        self.assertEqual(
+            config.cli_args.configure_rules,
+            {"E3012": {"key": "value", "strict": "true"}, "E3001": {"key": "value"}},
+        )
+
+    def test_exit_code_parameter(self):
+        """Test values of exit code"""
+
+        for param in ["informational", "warning", "error"]:
+            with self.subTest():
+                config = cfnlint.config.CliArgs(["--non-zero-exit-code", param])
+                self.assertEqual(config.cli_args.non_zero_exit_code, param)
+
+    def test_exit_code_parameter_error(self):
+        """Test result when bad value provided"""
+        with open(os.devnull, "w") as devnull:
+            with patch("sys.stderr", devnull):
+                with self.assertRaises(SystemExit):
+                    cfnlint.config.CliArgs(["--non-zero-exit-code", "bad"])

testbed/aws-cloudformation__cfn-lint/test/unit/module/config/test_config_file_args.py

@@ -0,0 +1,137 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import logging
+from pathlib import Path
+from test.testlib.testcase import BaseTestCase
+from unittest.mock import patch
+
+import cfnlint.config  # pylint: disable=E0401
+from cfnlint.jsonschema import ValidationError
+
+LOGGER = logging.getLogger("cfnlint")
+
+
+class TestConfigFileArgs(BaseTestCase):
+    """Test ConfigParser Arguments"""
+
+    def tearDown(self):
+        """Setup"""
+        for handler in LOGGER.handlers:
+            LOGGER.removeHandler(handler)
+
+    def test_config_parser_read_config(self):
+        """Testing one file successful"""
+        config = cfnlint.config.ConfigFileArgs(
+            config_file=Path("test/fixtures/configs/cfnlintrc_read.yaml")
+        )
+        self.assertEqual(
+            config.file_args,
+            {
+                "templates": ["test/fixtures/templates/good/**/*.yaml"],
+                "include_checks": ["I"],
+            },
+        )
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_parser_read_config_only_one_read(self, yaml_mock):
+        """Testing one file successful"""
+        # Should only have one read here
+        # We aren't going to search and find the possible locations of
+        # cfnlintrc
+        yaml_mock.side_effect = [
+            {"regions": ["us-west-1"]},
+        ]
+        config = cfnlint.config.ConfigFileArgs(
+            config_file=Path("test/fixtures/configs/cfnlintrc_read.yaml")
+        )
+        self.assertEqual(config.file_args, {"regions": ["us-west-1"]})
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_parser_read(self, yaml_mock):
+        """Testing one file successful"""
+        yaml_mock.side_effect = [{"regions": ["us-west-1"]}, {}]
+        results = cfnlint.config.ConfigFileArgs()
+        self.assertEqual(results.file_args, {"regions": ["us-west-1"]})
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_parser_read_merge(self, yaml_mock):
+        """test the merge of config"""
+
+        yaml_mock.side_effect = [{"regions": ["us-west-1"]}, {"regions": ["us-east-1"]}]
+
+        results = cfnlint.config.ConfigFileArgs()
+        self.assertEqual(results.file_args, {"regions": ["us-east-1"]})
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_parser_fail_on_bad_config(self, yaml_mock):
+        """test the read call to the config parser is reading two files"""
+
+        yaml_mock.side_effect = [{"regions": True}, {}]
+
+        with self.assertRaises(ValidationError):
+            cfnlint.config.ConfigFileArgs()
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_parser_fail_on_config_rules(self, yaml_mock):
+        """
+        test the read call to the config parser is
+        parsing configure rules correctly
+        """
+
+        yaml_mock.side_effect = [{"configure_rules": {"E3012": {"strict": False}}}, {}]
+
+        results = cfnlint.config.ConfigFileArgs()
+        self.assertEqual(
+            results.file_args, {"configure_rules": {"E3012": {"strict": False}}}
+        )
+
+    @patch("pathlib.Path.is_file", create=True)
+    def test_config_parser_is_file_both(self, is_file_mock):
+        calls = [
+            True,
+            True,
+            False,
+            False,
+        ]
+        is_file_mock.side_effect = calls
+        my_config = cfnlint.config.ConfigFileArgs()
+        self.assertEqual(my_config._user_config_file.name, ".cfnlintrc")
+        self.assertEqual(my_config._project_config_file.name, ".cfnlintrc")
+        self.assertEqual(is_file_mock.call_count, len(calls))
+
+    @patch("pathlib.Path.is_file", create=True)
+    def test_config_parser_is_file_both_yaml(self, is_file_mock):
+        calls = [
+            False,
+            True,
+            False,
+            True,
+            False,
+            False,
+        ]
+        is_file_mock.side_effect = calls
+        my_config = cfnlint.config.ConfigFileArgs()
+        self.assertEqual(my_config._user_config_file.name, ".cfnlintrc.yaml")
+        self.assertEqual(my_config._project_config_file.name, ".cfnlintrc.yaml")
+        self.assertEqual(is_file_mock.call_count, len(calls))
+
+    @patch("pathlib.Path.is_file", create=True)
+    def test_config_parser_is_file_both_yml(self, is_file_mock):
+        calls = [
+            False,
+            False,
+            True,
+            False,
+            False,
+            True,
+            False,
+            False,
+        ]
+        is_file_mock.side_effect = calls
+        my_config = cfnlint.config.ConfigFileArgs()
+        self.assertEqual(my_config._user_config_file.name, ".cfnlintrc.yml")
+        self.assertEqual(my_config._project_config_file.name, ".cfnlintrc.yml")
+        self.assertEqual(is_file_mock.call_count, len(calls))

testbed/aws-cloudformation__cfn-lint/test/unit/module/config/test_config_mixin.py

@@ -0,0 +1,265 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import logging
+import os
+from pathlib import Path
+from test.testlib.testcase import BaseTestCase
+from unittest.mock import patch
+
+import cfnlint.config  # pylint: disable=E0401
+from cfnlint.helpers import REGIONS
+
+LOGGER = logging.getLogger("cfnlint")
+
+
+class TestConfigMixIn(BaseTestCase):
+    """Test ConfigParser Arguments"""
+
+    def tearDown(self):
+        """Setup"""
+        for handler in LOGGER.handlers:
+            LOGGER.removeHandler(handler)
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_mix_in(self, yaml_mock):
+        """Test mix in"""
+        yaml_mock.side_effect = [
+            {"include_checks": ["I", "I1111"], "regions": ["us-west-2"]},
+            {},
+        ]
+
+        config = cfnlint.config.ConfigMixIn(["--regions", "us-west-1"])
+        self.assertEqual(config.regions, ["us-west-1"])
+        self.assertEqual(config.include_checks, ["W", "E", "I", "I1111"])
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_precedence(self, yaml_mock):
+        """Test precedence in"""
+
+        yaml_mock.side_effect = [
+            {
+                "include_checks": ["I"],
+                "ignore_checks": ["E3001"],
+                "regions": ["us-west-2"],
+            },
+            {},
+        ]
+        config = cfnlint.config.ConfigMixIn(["--include-checks", "I1234", "I4321"])
+        config.template_args = {
+            "Metadata": {
+                "cfn-lint": {
+                    "config": {"include_checks": ["I9876"], "ignore_checks": ["W3001"]}
+                }
+            }
+        }
+        # config files wins
+        self.assertEqual(config.regions, ["us-west-2"])
+        # CLI should win
+        self.assertEqual(config.include_checks, ["W", "E", "I1234", "I4321"])
+        # template file wins over config file
+        self.assertEqual(config.ignore_checks, ["W3001"])
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_file_output(self, yaml_mock):
+        """Test precedence in"""
+
+        yaml_mock.side_effect = [{"output_file": "test_output.txt"}, {}]
+        config = cfnlint.config.ConfigMixIn([])
+
+        # Config file wins
+        self.assertEqual(config.output_file, "test_output.txt")
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_file_output_mixin(self, yaml_mock):
+        """Test precedence in"""
+
+        yaml_mock.side_effect = [{"output_file": "test_output.txt"}, {}]
+        config = cfnlint.config.ConfigMixIn(["--output-file", "test_output_2.txt"])
+
+        # CLI args win
+        self.assertEqual(config.output_file, "test_output_2.txt")
+
+    @patch.dict(
+        os.environ,
+        {
+            "HOME": os.environ.get("HOME", ""),
+            "USERPROFILE": os.environ.get("USERPROFILE", ""),
+            "HOMEPATH": os.environ.get("HOMEPATH", ""),
+            "HOMEDRIVE": os.environ.get("HOMEDRIVE", ""),
+        },
+        clear=True,
+    )
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_default_region(self, yaml_mock):
+        """Test precedence in"""
+
+        yaml_mock.side_effect = [{}, {}]
+        config = cfnlint.config.ConfigMixIn([])
+
+        # test defaults
+        self.assertEqual(config.regions, ["us-east-1"])
+
+    @patch.dict(
+        os.environ,
+        {
+            "AWS_REGION": "us-west-2",
+            "AWS_DEFAULT_REGION": "us-west-1",
+            "HOME": os.environ.get("HOME", ""),
+            "USERPROFILE": os.environ.get("USERPROFILE", ""),
+            "HOMEPATH": os.environ.get("HOMEPATH", ""),
+            "HOMEDRIVE": os.environ.get("HOMEDRIVE", ""),
+        },
+        clear=True,
+    )
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_region_from_AWS_REGION_envvar(self, yaml_mock):
+        """Test precedence in"""
+
+        yaml_mock.side_effect = [{}, {}]
+        config = cfnlint.config.ConfigMixIn([])
+
+        # test defaults
+        self.assertEqual(config.regions, ["us-west-2"])
+
+    @patch.dict(
+        os.environ,
+        {
+            "AWS_DEFAULT_REGION": "us-west-1",
+            "HOME": os.environ.get("HOME", ""),
+            "USERPROFILE": os.environ.get("USERPROFILE", ""),
+            "HOMEPATH": os.environ.get("HOMEPATH", ""),
+            "HOMEDRIVE": os.environ.get("HOMEDRIVE", ""),
+        },
+        clear=True,
+    )
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_region_from_AWS_DEFAULT_REGION_envvar(self, yaml_mock):
+        """Test precedence in"""
+
+        yaml_mock.side_effect = [{}, {}]
+        config = cfnlint.config.ConfigMixIn([])
+
+        # test defaults
+        self.assertEqual(config.regions, ["us-west-1"])
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_all_regions(self, yaml_mock):
+        """Test precedence in"""
+
+        yaml_mock.side_effect = [{"regions": ["ALL_REGIONS"]}, {}]
+        config = cfnlint.config.ConfigMixIn([])
+
+        # test defaults
+        self.assertEqual(config.regions, REGIONS)
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_force_with_update_specs(self, yaml_mock):
+        """Test precedence in"""
+
+        yaml_mock.side_effect = [{}, {}]
+        config = cfnlint.config.ConfigMixIn(["--update-specs", "--force"])
+
+        # test defaults
+        self.assertEqual(config.force, True)
+        self.assertEqual(config.update_specs, True)
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_expand_paths(self, yaml_mock):
+        """Test precedence in"""
+
+        yaml_mock.side_effect = [
+            {"templates": ["test/fixtures/templates/public/*.yaml"]},
+            {},
+        ]
+        config = cfnlint.config.ConfigMixIn([])
+
+        # test defaults
+        self.assertEqual(
+            config.templates,
+            [
+                str(
+                    Path(
+                        "test/fixtures/templates/public"
+                        + os.path.sep
+                        + "lambda-poller.yaml"
+                    )
+                ),
+                str(
+                    Path(
+                        "test/fixtures/templates/public"
+                        + os.path.sep
+                        + "rds-cluster.yaml"
+                    )
+                ),
+            ],
+        )
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_expand_paths_nomatch(self, yaml_mock):
+        """Test precedence in"""
+
+        filename = "test/fixtures/templates/nonexistant/*.yaml"
+        yaml_mock.side_effect = [
+            {"templates": [filename]},
+            {},
+        ]
+        config = cfnlint.config.ConfigMixIn([])
+
+        # test defaults
+        self.assertEqual(config.templates, [])
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_expand_ignore_templates(self, yaml_mock):
+        """Test ignore templates"""
+
+        yaml_mock.side_effect = [
+            {
+                "templates": ["test/fixtures/templates/bad/resources/iam/*.yaml"],
+                "ignore_templates": [
+                    "test/fixtures/templates/bad/resources/iam/resource_*.yaml"
+                ],
+            },
+            {},
+        ]
+        config = cfnlint.config.ConfigMixIn([])
+
+        # test defaults
+        self.assertNotIn(
+            str(Path("test/fixtures/templates/bad/resources/iam/resource_policy.yaml")),
+            config.templates,
+        )
+        self.assertEqual(len(config.templates), 3)
+
+    @patch("cfnlint.config.ConfigFileArgs._read_config", create=True)
+    def test_config_merge(self, yaml_mock):
+        """Test merging lists"""
+
+        yaml_mock.side_effect = [
+            {
+                "include_checks": ["I"],
+                "ignore_checks": ["E3001"],
+                "regions": ["us-west-2"],
+            },
+            {},
+        ]
+        config = cfnlint.config.ConfigMixIn(
+            ["--include-checks", "I1234", "I4321", "--merge-configs"]
+        )
+        config.template_args = {
+            "Metadata": {
+                "cfn-lint": {
+                    "config": {"include_checks": ["I9876"], "ignore_checks": ["W3001"]}
+                }
+            }
+        }
+        # config files wins
+        self.assertEqual(config.regions, ["us-west-2"])
+        # CLI should win
+        self.assertEqual(
+            config.include_checks, ["W", "E", "I1234", "I4321", "I9876", "I"]
+        )
+        # template file wins over config file
+        self.assertEqual(config.ignore_checks, ["W3001", "E3001"])

testbed/aws-cloudformation__cfn-lint/test/unit/module/config/test_logging.py

@@ -0,0 +1,41 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import logging
+from test.testlib.testcase import BaseTestCase
+
+import cfnlint.config  # pylint: disable=E0401
+
+LOGGER = logging.getLogger("cfnlint")
+
+
+class TestLogging(BaseTestCase):
+    """Test Logging Arguments"""
+
+    def tearDown(self):
+        """Setup"""
+        for handler in LOGGER.handlers:
+            LOGGER.removeHandler(handler)
+
+    def test_logging_info(self):
+        """Test success run"""
+
+        cfnlint.config.configure_logging(False, True)
+        self.assertEqual(logging.INFO, LOGGER.level)
+        self.assertEqual(len(LOGGER.handlers), 1)
+
+    def test_logging_debug(self):
+        """Test debug level"""
+
+        cfnlint.config.configure_logging(True, False)
+        self.assertEqual(logging.DEBUG, LOGGER.level)
+        self.assertEqual(len(LOGGER.handlers), 1)
+
+    def test_no_logging(self):
+        """Test no logging level"""
+
+        cfnlint.config.configure_logging(False, False)
+        self.assertEqual(logging.WARNING, LOGGER.level)
+        self.assertEqual(len(LOGGER.handlers), 1)

testbed/aws-cloudformation__cfn-lint/test/unit/module/config/test_template_args.py

@@ -0,0 +1,105 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import logging
+from test.testlib.testcase import BaseTestCase
+
+import cfnlint.config  # pylint: disable=E0401
+
+LOGGER = logging.getLogger("cfnlint")
+
+
+class TestTempalteArgs(BaseTestCase):
+    """Test ConfigParser Arguments"""
+
+    def tearDown(self):
+        """Setup"""
+        for handler in LOGGER.handlers:
+            LOGGER.removeHandler(handler)
+
+    def test_template_args(self):
+        """test template args"""
+        config = cfnlint.config.TemplateArgs(
+            {
+                "Metadata": {
+                    "cfn-lint": {
+                        "config": {
+                            "regions": ["us-east-1", "us-east-2"],
+                            "ignore_checks": ["E2530"],
+                            "configure_rules": {"E3012": {"strict": "false"}},
+                        }
+                    }
+                }
+            }
+        )
+
+        self.assertEqual(config.template_args["regions"], ["us-east-1", "us-east-2"])
+        self.assertEqual(
+            config.template_args["configure_rules"], {"E3012": {"strict": "false"}}
+        )
+
+    def test_template_args_failure_bad_format(self):
+        """test template args"""
+        config = cfnlint.config.TemplateArgs(
+            {
+                "Metadata": {
+                    "cfn-lint": {
+                        "config": {"configure_rules": [{"E3012": {"strict": "false"}}]}
+                    }
+                }
+            }
+        )
+
+        self.assertEqual(config.template_args.get("configure_rules"), None)
+
+    def test_template_args_failure_bad_value(self):
+        """test template args"""
+        config = cfnlint.config.TemplateArgs(
+            {
+                "Metadata": {
+                    "cfn-lint": {
+                        "config": {
+                            "configure_rules": [{"E3012": {"bad_value": "false"}}]
+                        }
+                    }
+                }
+            }
+        )
+
+        self.assertEqual(config.template_args.get("configure_rules"), None)
+
+    def test_template_args_failure_good_and_bad_value(self):
+        """test template args"""
+        config = cfnlint.config.TemplateArgs(
+            {
+                "Metadata": {
+                    "cfn-lint": {
+                        "config": {
+                            "configure_rules": [
+                                {
+                                    "A1": {"strict": "false"},
+                                    "E3012": {"strict": "false"},
+                                    "Z1": {"strict": "false"},
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        )
+
+        self.assertEqual(config.template_args.get("configure_rules"), None)
+
+    def test_bad_template_structure(self):
+        """test template args"""
+        config = cfnlint.config.TemplateArgs([])
+
+        self.assertEqual(config._template_args, {})
+
+    def test_bad_config_structure(self):
+        """test template args"""
+        config = cfnlint.config.TemplateArgs({"Metadata": {"cfn-lint": {"config": []}}})
+
+        self.assertEqual(config._template_args, {})

testbed/aws-cloudformation__cfn-lint/test/unit/module/context/conditions/test_conditions.py

@@ -0,0 +1,299 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import pytest
+
+from cfnlint.context import create_context_for_template
+from cfnlint.context.conditions._conditions import Conditions
+from cfnlint.context.conditions.exceptions import Unsatisfiable
+from cfnlint.template import Template
+
+
+def template():
+    return {
+        "AWSTemplateFormatVersion": "2010-09-09",
+        "Parameters": {
+            "Environment": {
+                "Type": "String",
+                "Default": "dev",
+                "AllowedValues": ["dev", "prod"],
+            },
+            "Name": {
+                "Type": "String",
+                "Default": "bi",
+                "AllowedValues": ["bi", "ai"],
+            },
+            "AmiId": {
+                "Type": "String",
+                "Default": "",
+            },
+        },
+        "Conditions": {
+            "IsUsEast1": {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]},
+            "IsNotUsEast1": {"Fn::Not": [{"Condition": "IsUsEast1"}]},
+            "IsUsWest2": {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-west-2"]},
+            "IsProd": {"Fn::Equals": [{"Ref": "Environment"}, "prod"]},
+            "IsDev": {"Fn::Equals": [{"Ref": "Environment"}, "dev"]},
+            "IsAmiProvided": {"Fn::Not": [{"Fn::Equals": [{"Ref": "AmiId"}, ""]}]},
+            "IsAi": {"Fn::Equals": [{"Ref": "Name"}, "ai"]},
+            "IsBi": {"Fn::Equals": [{"Ref": "Name"}, "bi"]},
+            "IsUsEast1OrUsWest2": {
+                "Fn::Or": [
+                    {"Condition": "IsUsEast1"},
+                    {"Condition": "IsUsWest2"},
+                ]
+            },
+            "IsUsEast1AndProd": {
+                "Fn::And": [
+                    {"Condition": "IsUsEast1"},
+                    {"Condition": "IsProd"},
+                ]
+            },
+            "IsStaticTrue": {"Fn::Equals": [1, "1"]},
+            "IsStaticFalse": {"Fn::Equals": [1, "2"]},
+            "TwoObjects": {
+                "Fn::Equals": [
+                    {"Ref": "Environment"},
+                    {"Ref": "AWS::Region"},
+                ]
+            },
+            "TwoObjectsSameHash": {
+                "Fn::Equals": [
+                    {"Ref": "AWS::Region"},
+                    {"Ref": "Environment"},
+                ]
+            },
+            "BadAwsFn": {"Ref": "Foo"},
+            "BadFn": {"Key": "Foo"},
+            "BadNotList": {"Fn::And": "Foo"},
+            "UseBadFn": {"Condition": "BadFn"},
+            "UseBadCondition": {"Condition": []},
+            "EqualsTooLong": {"Fn::Equals": ["a", "b", "c"]},
+            "EqualsWrongTypes": {"Fn::Equals": ["a", []]},
+            "NotWithTwoItems": {
+                "Fn::Not": [
+                    {"Condition": "IsAi"},
+                    {"Condition": "IsBi"},
+                ]
+            },
+        },
+    }
+
+
+def test_conditions():
+    cfn = Template(None, template(), regions=["us-east-1"])
+    context = create_context_for_template(cfn)
+
+    assert len(context.conditions.conditions) == 22
+    assert context.conditions.conditions["IsStaticTrue"].fn_equals.is_static is True
+    assert context.conditions.conditions["IsStaticFalse"].fn_equals.is_static is False
+    assert (
+        context.conditions.conditions["TwoObjects"].fn_equals.hash
+        == context.conditions.conditions["TwoObjectsSameHash"].fn_equals.hash
+    )
+    assert context.conditions.conditions["TwoObjects"].fn_equals.is_static is None
+
+    for k in [
+        "IsUsEast1",
+        "IsNotUsEast1",
+        "IsUsWest2",
+        "IsUsEast1OrUsWest2",
+        "IsUsEast1AndProd",
+    ]:
+        assert context.conditions.conditions[k].is_region is True
+
+    for k in ["IsAmiProvided", "IsProd", "IsDev", "IsAi", "IsBi"]:
+        assert context.conditions.conditions[k].is_region is False
+
+    for k in [
+        "BadAwsFn",
+        "BadFn",
+        "BadNotList",
+        "UseBadCondition",
+        "EqualsTooLong",
+        "EqualsWrongTypes",
+        "NotWithTwoItems",
+    ]:
+        assert context.conditions.conditions[k].fn_equals.left.instance is None
+        assert context.conditions.conditions[k].fn_equals.right.instance is None
+        assert context.conditions.conditions[k].fn_equals.is_static is None
+        assert context.conditions.conditions[k].is_region is False
+
+    assert (
+        context.conditions.conditions["UseBadFn"].condition.fn_equals.left.instance
+        is None
+    )
+    assert (
+        context.conditions.conditions["UseBadFn"].condition.fn_equals.right.instance
+        is None
+    )
+    assert (
+        context.conditions.conditions["UseBadFn"].condition.fn_equals.is_static is None
+    )
+
+
+@pytest.mark.parametrize(
+    "current_status,new_status,expected",
+    [
+        ({}, {}, {}),
+        ({"IsUsEast1": True}, {}, {"IsUsEast1": True}),
+        (
+            {"IsUsEast1": True},
+            {"IsUsEast1": False},
+            Unsatisfiable(
+                new_status={"IsUsEast1": False}, current_status={"IsUsEast1": True}
+            ),
+        ),
+        (
+            {"IsUsEast1": True},
+            {"IsNotUsEast1": True},
+            Unsatisfiable(
+                new_status={"IsNotUsEast1": True},
+                current_status={"IsUsEast1": True},
+            ),
+        ),
+        (
+            {"IsUsEast1": False, "IsUsWest2": False},
+            {"IsUsEast1OrUsWest2": True},
+            Unsatisfiable(
+                new_status={"IsUsEast1OrUsWest2": True},
+                current_status={"IsUsEast1": True},
+            ),
+        ),
+        (
+            {"IsDev": False},
+            {"IsProd": False},
+            Unsatisfiable(new_status={"IsProd": False}, current_status={"IsDev": True}),
+        ),
+        ({}, {"BadFn": True}, {"BadFn": True}),
+        ({}, {"BadFn": False}, {"BadFn": False}),
+    ],
+)
+def test_condition_status(current_status, new_status, expected):
+    cfn = Template(None, template(), regions=["us-east-1"])
+    context = create_context_for_template(cfn)
+
+    context = context.evolve(conditions=context.conditions.evolve(current_status))
+
+    if isinstance(expected, Exception):
+        with pytest.raises(ValueError):
+            context.conditions.evolve(new_status)
+    else:
+        context = context.evolve(conditions=context.conditions.evolve(new_status))
+        assert context.conditions.status == expected
+
+
+@pytest.mark.parametrize(
+    "current_status,instance,expected",
+    [
+        ({}, {"Foo": "Bar"}, [({"Foo": "Bar"}, {})]),
+        (
+            {},
+            {"Fn::If": ["IsUsEast1", {"Foo": "Foo"}, {"Bar": "Bar"}]},
+            [
+                ({"Foo": "Foo"}, {"IsUsEast1": True}),
+                ({"Bar": "Bar"}, {"IsUsEast1": False}),
+            ],
+        ),
+        (
+            {
+                "IsUsEast1": True,
+            },
+            {"Fn::If": ["IsUsEast1", {"Foo": "Foo"}, {"Bar": "Bar"}]},
+            [
+                ({"Foo": "Foo"}, {"IsUsEast1": True}),
+            ],
+        ),
+        (
+            {
+                "IsUsEast1": False,
+            },
+            {"Fn::If": ["IsUsEast1", {"Foo": "Foo"}, {"Bar": "Bar"}]},
+            [
+                ({"Bar": "Bar"}, {"IsUsEast1": False}),
+            ],
+        ),
+        (
+            {},
+            {"Ref": "AWS::NoValue"},
+            [
+                (None, {}),
+            ],
+        ),
+        (
+            {},
+            [{"Foo": {"Fn::If": ["IsUsEast1", "Foo", "Bar"]}}],
+            [
+                ([{"Foo": {"Fn::If": ["IsUsEast1", "Foo", "Bar"]}}], {}),
+            ],
+        ),
+        (
+            {},
+            [{"Fn::If": ["IsUsEast1", {"Foo": "Bar"}, {"Ref": "AWS::NoValue"}]}],
+            [
+                ([{"Foo": "Bar"}], {"IsUsEast1": True}),
+                ([], {"IsUsEast1": False}),
+            ],
+        ),
+        (
+            {"IsUsEast1": True, "IsProd": True},
+            {
+                "A": {"Fn::If": ["IsUsEast1AndProd", 1, 2]},
+                "B": {"Fn::If": ["IsAi", 10, 11]},
+            },
+            [
+                (
+                    {"A": 1, "B": 10},
+                    {
+                        "IsUsEast1": True,
+                        "IsProd": True,
+                        "IsUsEast1AndProd": True,
+                        "IsAi": True,
+                    },
+                ),
+                (
+                    {"A": 1, "B": 11},
+                    {
+                        "IsUsEast1": True,
+                        "IsProd": True,
+                        "IsUsEast1AndProd": True,
+                        "IsAi": False,
+                    },
+                ),
+            ],
+        ),
+        (
+            {},
+            {
+                "A": {"Fn::If": ["IsUsEast1AndProd", 1]},
+            },
+            [
+                (
+                    {"A": {"Fn::If": ["IsUsEast1AndProd", 1]}},
+                    {},
+                ),
+            ],
+        ),
+    ],
+)
+def test_evolve_from_instance(current_status, instance, expected):
+    cfn = Template(None, template(), regions=["us-east-1"])
+    context = create_context_for_template(cfn)
+
+    context = context.evolve(
+        conditions=context.conditions.evolve(current_status),
+        functions=["Fn::If", "Ref"],
+    )
+
+    results = list(context.conditions.evolve_from_instance(instance, context))
+    assert len(results) == len(expected)
+    for result, expected_result in zip(results, expected):
+        assert result[0] == expected_result[0]
+        assert result[1].status == expected_result[1]
+
+
+def test_condition_failures():
+    with pytest.raises(ValueError):
+        Conditions.create_from_instance([], {}, {})

testbed/aws-cloudformation__cfn-lint/test/unit/module/context/conditions/test_equals_sort.py

@@ -0,0 +1,105 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import pytest
+
+from cfnlint.context.conditions._equals import _equals_cmp_key
+
+
+@pytest.mark.parametrize(
+    "name,instance,expected",
+    [
+        (
+            "Valid",
+            [
+                "A",
+                "B",
+                {"Ref": "A"},
+                {"Ref": "B"},
+                {"Key": "Value"},
+                {"Fn::FindInMap": ["A", "B", "C"]},
+                {"Fn::FindInMap": ["X", "Y", "Z"]},
+            ],
+            [
+                "A",
+                "B",
+                {"Fn::FindInMap": ["X", "Y", "Z"]},
+                {"Fn::FindInMap": ["A", "B", "C"]},
+                {"Ref": "A"},
+                {"Ref": "B"},
+                {"Key": "Value"},
+            ],
+        ),
+        (
+            "Different order same results",
+            [
+                {"Fn::FindInMap": ["A", "B", "C"]},
+                {"Fn::FindInMap": ["X", "Y", "Z"]},
+                {"Ref": "B"},
+                {"Ref": "A"},
+                {"Key": "Value"},
+                "B",
+                "A",
+            ],
+            [
+                "A",
+                "B",
+                {"Fn::FindInMap": ["X", "Y", "Z"]},
+                {"Fn::FindInMap": ["A", "B", "C"]},
+                {"Ref": "A"},
+                {"Ref": "B"},
+                {"Key": "Value"},
+            ],
+        ),
+        (
+            "Two Refs",
+            [
+                {"Ref": "B"},
+                {"Ref": "A"},
+            ],
+            [
+                {"Ref": "A"},
+                {"Ref": "B"},
+            ],
+        ),
+        (
+            "Ref with non mapping",
+            [
+                {"Ref": "A"},
+                {"Key": "Value"},
+            ],
+            [
+                {"Ref": "A"},
+                {"Key": "Value"},
+            ],
+        ),
+        (
+            "Ref with non mapping backwards",
+            [
+                {"Key": "Value"},
+                {"Ref": "A"},
+            ],
+            [
+                {"Ref": "A"},
+                {"Key": "Value"},
+            ],
+        ),
+        (
+            "None functions",
+            [
+                {"Key": "Foo"},
+                {"Key": "Bar"},
+            ],
+            [
+                {"Key": "Foo"},
+                {"Key": "Bar"},
+            ],
+        ),
+    ],
+)
+def test_sorted(name, instance, expected):
+    assert expected == sorted(
+        instance, key=_equals_cmp_key
+    ), f"{name} got {sorted(instance, key=_equals_cmp_key)}"

testbed/aws-cloudformation__cfn-lint/test/unit/module/context/test_context.py

@@ -0,0 +1,108 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+import unittest
+from collections import deque
+
+from cfnlint.context import Context, Path
+from cfnlint.context.conditions._conditions import Condition, Conditions
+
+
+class TestCfnContext(unittest.TestCase):
+    def test_class(self):
+        context = Context(
+            conditions=Conditions.create_from_instance(
+                conditions={
+                    "Foo": {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]},
+                    "Bar": {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-west-2"]},
+                },
+                rules={},
+                parameters={},
+            ),
+        )
+        self.assertEqual(context.regions, ["us-east-1"])
+        self.assertEqual(
+            context.conditions,
+            Conditions(
+                {
+                    "Foo": Condition.create_from_instance(
+                        {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]}, {}
+                    ),
+                    "Bar": Condition.create_from_instance(
+                        {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-west-2"]}, {}
+                    ),
+                },
+            ),
+        )
+        self.assertEqual(context.path, Path())
+
+        # Test evolve
+        evolved = context.evolve(
+            regions=["us-west-2"],
+            conditions=context.conditions.evolve(
+                {"Foo": False},
+            ),
+            path=Path(path=deque([1])),
+        )
+        self.assertListEqual(evolved.regions, ["us-west-2"])
+        self.assertDictEqual(
+            evolved.conditions.status,
+            {
+                "Foo": False,
+            },
+        )
+        self.assertEqual(evolved.path.path, deque([1]))
+
+        evolved_again = evolved.evolve(
+            path=evolved.path.descend(path=2),
+            conditions=evolved.conditions.evolve(
+                {"Bar": True},
+            ),
+        )
+        self.assertListEqual(evolved_again.regions, ["us-west-2"])
+        self.assertDictEqual(
+            evolved_again.conditions.status, {"Foo": False, "Bar": True}
+        )
+        self.assertEqual(evolved_again.path.path, deque([1, 2]))
+        # no changes to the original
+        self.assertListEqual(context.regions, ["us-east-1"])
+        self.assertEqual(
+            context.conditions,
+            Conditions(
+                {
+                    "Foo": Condition.create_from_instance(
+                        {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]}, {}
+                    ),
+                    "Bar": Condition.create_from_instance(
+                        {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-west-2"]}, {}
+                    ),
+                }
+            ),
+        )
+        self.assertEqual(context.path.path, deque())
+
+        no_path = context.evolve(regions=["us-east-2"])
+        self.assertListEqual(no_path.regions, ["us-east-2"])
+        self.assertEqual(
+            no_path.conditions,
+            Conditions(
+                {
+                    "Foo": Condition.create_from_instance(
+                        {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]}, {}
+                    ),
+                    "Bar": Condition.create_from_instance(
+                        {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-west-2"]}, {}
+                    ),
+                }
+            ),
+        )
+        self.assertEqual(no_path.path.path, deque())
+
+        with self.assertRaises(ValueError):
+            evolved_again.evolve(
+                conditions=evolved_again.conditions.evolve(
+                    {"Foo": True},
+                ),
+            )

testbed/aws-cloudformation__cfn-lint/test/unit/module/context/test_create_context.py

@@ -0,0 +1,115 @@
+"""
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: MIT-0
+"""
+
+from collections import namedtuple
+
+import pytest
+
+from cfnlint import Template
+from cfnlint.context.context import create_context_for_template
+
+_Counts = namedtuple("_Counts", ["resources", "parameters", "conditions", "mappings"])
+
+
+@pytest.mark.parametrize(
+    "name,instance,counts",
+    [
+        (
+            "Valid template",
+            {
+                "Parameters": {
+                    "Env": {
+                        "Type": "String",
+                    }
+                },
+                "Conditions": {
+                    "IsUsEast1": {"Fn::Equals": [{"Ref": "AWS::Region"}, "us-east-1"]}
+                },
+                "Mappings": {"Map": {"us-east-1": {"foo": "bar"}}},
+                "Resources": {
+                    "Bucket": {
+                        "Type": "AWS::S3::Bucket",
+                    },
+                },
+            },
+            _Counts(resources=1, parameters=1, conditions=1, mappings=1),
+        ),
+        (
+            "Bad types in template",
+            {
+                "Parameters": [],
+                "Conditions": [],
+                "Mappings": [],
+                "Resources": [],
+            },
+            _Counts(resources=0, parameters=0, conditions=0, mappings=0),
+        ),
+        (
+            "Invalid type configurations",
+            {
+                "Parameters": {
+                    "BusinessUnit": [],
+                    "Env": {
+                        "Type": "String",
+                    },
+                },
+                "Mappings": {"AnotherMap": [], "Map": {"us-east-1": {"foo": "bar"}}},
+                "Resources": {
+                    "Instance": [],
+                    "Bucket": {
+                        "Type": "AWS::S3::Bucket",
+                    },
+                },
+            },
+            _Counts(resources=1, parameters=1, conditions=0, mappings=2),
+        ),
+        (
+            "Invalid mapping second key",
+            {
+                "Mappings": {
+                    "BadKey": {
+                        "Foo": [],
+                    },
+                    "Map": {"us-east-1": {"foo": "bar"}},
+                },
+            },
+            _Counts(resources=0, parameters=0, conditions=0, mappings=2),
+        ),
+        (
+            "Invalid mapping third key",
+            {
+                "Mappings": {
+                    "BadKey": {
+                        "Foo": {
+                            "Bar": {},
+                        },
+                    },
+                    "Map": {"us-east-1": {"foo": "bar"}},
+                },
+            },
+            _Counts(resources=0, parameters=0, conditions=0, mappings=2),
+        ),
+    ],
+)
+def test_create_context(name, instance, counts):
+    cfn = Template("", instance, ["us-east-1"])
+    context = create_context_for_template(cfn)
+
+    for i in counts._fields:
+        if i == "conditions":
+            assert len(context.conditions.conditions) == getattr(counts, i), (
+                f"Test {name} has {i} {len(getattr(context, i))} "
+                f"and expected {getattr(counts, i)}"
+            )
+        elif i == "mappings":
+            assert len(context.mappings.maps) == getattr(counts, i), (
+                f"Test {name} has {i} {len(context.mappings.maps)} "
+                f"and expected {getattr(counts, i)}"
+            )
+        else:
+            assert len(getattr(context, i)) == getattr(counts, i), (
+                f"Test {name} has {i} {len(getattr(context, i))} "
+                f"and expected {getattr(counts, i)}"
+            )