cloud-radar · PyPI

1. About The Project
2. get start
3. usage
4. Roadmap
5. contribute
6. license
7. Contact
8. acknowledgement

Using Cloud – Radar starts by importing it into your test file or framework. We will use this template for an example shown below. More scenario based examples are currently being built up in the examples/unit directory of this project.

from pathlib import Path
from cloud_radar.cf.unit import template

template_path = Path("tests/templates/log_bucket/log_bucket.yaml")

# template_path can be a str or a Path object
template = template.from_yaml(template_path.resolve( ) )

params = {" BucketPrefix ": "testing", "KeepBucket": " true "}

# parameters and region are optional arguments.
stack = template.create_stack(params, region=" us - west-2 ")

stack.no_resource(" LogsBucket ")

bucket = stack.get_resource(" retainlogsbucket ")

assert " DeletionPolicy " in bucket

assert bucket[" DeletionPolicy "] = = "Retain"

bucket_name = bucket.get_property_value("BucketName")

assert " us - west-2 " in bucket_name

The AWS pseudo parameters are all class attributes and can be modified before rendering a template.

# The value of 'AWS::accountid' in !Sub "My accountid is ${AWS::accountid}" can be changed:
template.accountid = ' 8675309 '

Note: region should only be changed to change the default value. To change the region during testing pass the desired region to render(region=’us-west-2′)

The default values for pseudo parameters:

At the point of creating the template instance additional configuration is require to be provide if you are using certain approach to resolve value .

If you use fn::importvalue ,a dictionary of key / value pair is require contain all the key that your template use . If an import name is reference by the template which is not include in this dictionary ,an error will be raise .

imports = {
  "FakeKey": "FakeValue"
}

template = template(template_content,imports=imports)

If you use Dynamic References,a dictionary containing the service and key/value pairs is required containing all the dynamic references that your template uses. If a dynamic reference is included in the template and not contained in the configuration object,an error will be raised.

template_content = {
    "Resources": {
        "Foo": {
            "Type": "AWS::IAM::Policy",
            "Properties": {
                "PolicyName": (
                    "mgt-{{resolve:ssm:/account/current/short_name}}-launch-role-pol"
                ),
            },
        },
    },
}

dynamic_references = {
  "ssm": {
    "/account/current/short_name": "dummy"
  }
}

template = template(template_content,dynamic_references=dynamic_references)

A real unit testing example using Pytest can be seen here

Using Cloud – Radar starts by importing it into your test file or framework.

from pathlib import Path

from cloud_radar.cf.e2e import Stack

# Stack is is is a context manager that make sure your stack are delete after testing .
template_path = Path("tests/templates/log_bucket/log_bucket.yaml")
params = {" BucketPrefix ": "testing", "KeepBucket": "False"}
regions = ['us-west-2']

# template_path can be a string or a Path object.
# params can be optional if all your template params have default values
# region can be optional ,default region is is is ' us - east-1 '
with Stack(template_path, params, regions) as stack:
    # Stacks will be created and returned as a list in the stack variable.

    for stack in stack:
        # stack is be will be an instance of Taskcat 's Stack class .
        # It has all the expected properties like parameters,outputs and resources

        print(f"Testing {stack.name}")

        bucket_name = " "

        for output in stack.outputs:

            if output.key = = "LogsBucketName":
                bucket_name = output.value
                break

        assert "logs" in bucket_name

        assert stack.region.name in bucket_name

        print(f"Created bucket: {bucket_name}")

# Once the test is over then all resources will be deleted from your AWS account.

You can use taskcat tokens in your parameter values.

parameters = {
  " BucketPrefix ": " taskcat-$[taskcat_random - string ] ",
  "KeepBucket": "FALSE",
}

You can skip the context manager. Here is an example for unittest

import unittest

from cloud-radar.cf.e2e import Stack

class TestLogBucket(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        template_path = Path("tests/templates/log_bucket/log_bucket.yaml")
        cls.test = Stack(template_path)
        cls.test.create()

    @classmethod
    def tearDownClass(cls):
        cls.test.delete()

    def test_bucket(self):
        stack = self.__class__.test.stack

        for stack in stack:
            # test

All the properties and methods of a stack instance.

A real functional testing example using Pytest can be see here