def test_ref():
template = {"Parameters": {"foo": {"Value": "bar"}}, "Resources": {}}
add_metadata(template, Template.Region)
template = Template(template)
for i in inspect.getmembers(Template):
if not i[0].startswith("_"):
if isinstance(i[1], str):
result = functions.ref(template, f"AWS::{i[0]}")
assert (
result == i[1]
), "Should be able to reference all pseudo variables."
result = functions.ref(template, "foo")
assert result == "bar", "Should reference parameters."
with pytest.raises(Exception) as ex:
result = functions.ref(template, "SomeResource")
assert "not a valid Resource" in str(ex)
fake = "AWS::FakeVar"
with pytest.raises(ValueError) as e:
functions.ref(template, fake)
assert f"Unrecognized AWS Pseduo variable: '{fake}'." in str(e.value)
def test_metadata(t):
region = "us-east-1"
add_metadata(t, region=region)
assert "Metadata" in t
assert region == t["Metadata"]["Cloud-Radar"]["Region"]
def test_find_in_map():
template = {}
add_metadata(template, Template.Region)
template = Template(template)
with pytest.raises(TypeError) as e:
functions.find_in_map(template, {})
assert "must be a List, not dict." in str(e)
with pytest.raises(ValueError) as e:
functions.find_in_map(template, [0])
assert "a MapName, TopLevelKey and SecondLevelKey." in str(e)
map_name = "TestMap"
first_key = "FirstKey"
second_key = "SecondKey"
values = [map_name, first_key, second_key]
with pytest.raises(KeyError) as e:
functions.find_in_map(template, values)
assert "Unable to find Mappings section in template." in str(e)
template.template["Mappings"] = {}
with pytest.raises(KeyError) as e:
functions.find_in_map(template, values)
assert f"Unable to find {map_name} in Mappings section of template." in str(e)
template.template["Mappings"][map_name] = {}
with pytest.raises(KeyError) as e:
functions.find_in_map(template, values)
assert f"Unable to find key {first_key}" in str(e)
template.template["Mappings"][map_name][first_key] = {}
with pytest.raises(KeyError) as e:
functions.find_in_map(template, values)
assert f"Unable to find key {second_key}" in str(e)
expected = "ExpectedValue"
template.template["Mappings"][map_name][first_key][second_key] = expected
result = functions.find_in_map(template, values)
assert result == expected
def test_sub_s():
template_dict = {"Parameters": {"Foo": {"Value": "bar"}}}
template = Template(template_dict)
result = functions.sub_s(template, "Foo ${Foo}")
assert result == "Foo bar", "Should subsuite a parameter."
result = functions.sub_s(template, "not ${!Test}")
assert result == "not ${Test}", "Should return a string literal."
add_metadata(template_dict, "us-east-1")
template = Template(template_dict)
result = functions.sub(template, "${AWS::Region} ${Foo} ${!BASH_VAR}")
assert result == "us-east-1 bar ${BASH_VAR}", "Should render multiple variables."
def test_get_att():
template = {"Resources": {}}
add_metadata(template, Template.Region)
template = Template(template)
with pytest.raises(TypeError) as e:
functions.get_att(template, {})
assert "Fn::GetAtt - The values must be a List, not dict." in str(e)
with pytest.raises(ValueError) as e:
functions.get_att(template, [0])
assert "the logicalNameOfResource and attributeName." in str(e)
with pytest.raises(TypeError) as e:
functions.get_att(template, [0, 0])
assert "logicalNameOfResource and attributeName must be String." in str(e)
resource_name = "TestA"
att = "TestAttribute"
values = [resource_name, att]
with pytest.raises(KeyError) as e:
functions.get_att(template, values)
assert f"{resource_name} not found in template." in str(e)
template.template["Resources"]["TestA"] = {}
result = functions.get_att(template, values)
assert result == f"{resource_name}.{att}"
def test_sub_l():
template_dict = {"Parameters": {"Foo": {"Value": "bar"}}}
add_metadata(template_dict, "us-east-1")
template = Template(template_dict)
with pytest.raises(ValueError) as e:
functions.sub_l(template, [0])
assert "source string and a Map of variables." in str(e)
with pytest.raises(TypeError) as e:
functions.sub_l(template, [0, 0])
assert "String and the second a Map." in str(e)
var_map = {"LocalA": "TestA"}
input_string = "${AWS::Region} ${Foo} ${!BASH_VAR} ${LocalA}"
result = functions.sub_l(template, [input_string, var_map])
assert "us-east-1" in result, "Should render aws pseudo vars."
assert "bar" in result, "Should render parameters."
assert "${BASH_VAR}" in result, "Should allow escaping variables."
assert "TestA" in result, "Should render local variables."
test_string = "SomeString"
result = functions.sub_l(template, [test_string, var_map])
assert result == test_string