class TestYamlParse(BaseTestCase):
"""Test YAML Parsing """
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.create_from_directory(rulesdir)
self.filenames = {
"config_rule": {
"filename":
'test/fixtures/templates/public/lambda-poller.yaml',
"failures": 0
},
"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 = []
matches.extend(self.rules.run(filename, cfn))
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 = '-'
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))
assert len(
matches
) == failures, 'Expected {} failures, got {} on {}'.format(
failures, len(matches), values.get('filename'))
class TestYamlParse(BaseTestCase):
"""Test YAML Parsing """
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(RulesCollection.create_from_directory(rulesdir))
self.filenames = {
"config_rule": {
"filename": 'fixtures/templates/public/lambda-poller.yaml',
"failures": 0
}
}
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_yaml.load(filename)
cfn = Template(filename, template, ['us-east-1'])
matches = list()
matches.extend(self.rules.run(filename, cfn))
assert len(
matches
) == failures, 'Expected {} failures, got {} on {}'.format(
failures, len(matches), filename)
class TestTemplate(BaseTestCase):
"""Test Template RulesCollection in cfnlint """
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(RulesCollection.create_from_directory(rulesdir))
def test_rule_ids_unique(self):
"""Test Rule IDs are Unique"""
existing_rules = []
for rule in self.rules:
self.assertFalse(rule.id in existing_rules)
existing_rules.append(rule.id)
def test_success_run(self):
""" Test Run Logic"""
filename = 'templates/good/generic.yaml'
template = cfnlint.cfn_yaml.load(filename)
cfn = Template(template, ['us-east-1'])
matches = list()
matches.extend(self.rules.run(filename, cfn))
assert (matches == [])
def test_fail_run(self):
"""Test failure run"""
filename = 'templates/bad/generic.yaml'
template = cfnlint.cfn_yaml.load(filename)
cfn = Template(template, ['us-east-1'])
matches = list()
matches.extend(self.rules.run(filename, cfn))
assert len(matches) == 27, 'Expected {} failures, got {}'.format(
27, len(matches))
def test_fail_sub_properties_run(self):
"""Test failure run"""
filename = 'templates/bad/properties_onlyone.yaml'
template = cfnlint.cfn_yaml.load(filename)
cfn = Template(template, ['us-east-1'])
matches = list()
matches.extend(self.rules.run(filename, cfn))
assert len(matches) == 3, 'Expected {} failures, got {}'.format(
2, len(matches))
class TestCfnJson(BaseTestCase):
"""Test JSON Parsing """
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(RulesCollection.create_from_directory(rulesdir))
self.filenames = {
"config_rule": {
"filename": 'templates/quickstart/config-rules.json',
"failures": 0
},
"iam": {
"filename": 'templates/quickstart/iam.json',
"failures": 0
},
"nat_instance": {
"filename": 'templates/quickstart/nat-instance.json',
"failures": 2
},
"vpc_management": {
"filename": 'templates/quickstart/vpc-management.json',
"failures": 16
},
"vpc": {
"filename": 'templates/quickstart/vpc.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 = json.load(open(filename),
cls=cfnlint.cfn_json.CfnJSONDecoder)
cfn = Template(template, ['us-east-1'])
matches = list()
matches.extend(self.rules.run(filename, cfn, []))
assert len(
matches) == failures, 'Expected {} failures, got {}'.format(
failures, len(matches))
def test_fail_run(self):
"""Test failure run"""
filename = 'templates/bad/json_parse.json'
try:
json.load(open(filename), cls=cfnlint.cfn_json.CfnJSONDecoder)
except cfnlint.cfn_json.JSONDecodeError:
assert (True)
return
assert (False)
class TestTemplate(BaseTestCase):
"""Test Template RulesCollection in cfnlint """
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection()
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(RulesCollection.create_from_directory(rulesdir))
def test_rule_ids_unique(self):
"""Test Rule IDs are Unique"""
existing_rules = []
for rule in self.rules:
self.assertFalse(rule.id in existing_rules)
existing_rules.append(rule.id)
def test_rule_ids_are_formatted_correctly(self):
"""Test Rule IDs are property formmated"""
for rule in self.rules:
self.assertIn(rule.id[0], ['W', 'I', 'E'])
self.assertEqual(len(rule.id), 5)
self.assertTrue(isinstance(int(rule.id[1:]), int))
def test_success_run(self):
""" Test Run Logic"""
filename = 'test/fixtures/templates/good/generic.yaml'
template = cfnlint.decode.cfn_yaml.load(filename)
cfn = Template(filename, template, ['us-east-1'])
matches = []
matches.extend(self.rules.run(filename, cfn))
assert (matches == [])
def test_fail_run(self):
"""Test failure run"""
filename = 'test/fixtures/templates/bad/generic.yaml'
template = cfnlint.decode.cfn_yaml.load(filename)
cfn = Template(filename, template, ['us-east-1'])
expected_err_count = 35
matches = []
matches.extend(self.rules.run(filename, cfn))
assert len(
matches
) == expected_err_count, 'Expected {} failures, got {}'.format(
expected_err_count, len(matches))
def test_fail_sub_properties_run(self):
"""Test failure run"""
filename = 'test/fixtures/templates/bad/properties_onlyone.yaml'
template = cfnlint.decode.cfn_yaml.load(filename)
cfn = Template(filename, template, ['us-east-1'])
matches = []
matches.extend(self.rules.run(filename, cfn))
assert len(matches) == 3, 'Expected {} failures, got {}'.format(
2, len(matches))
def test_success_filtering_of_rules_default(self):
"""Test extend function"""
class rule_e0000(CloudFormationLintRule):
"""Error Rule"""
id = 'E0000'
class rule_w0000(CloudFormationLintRule):
"""Warning Rule"""
id = 'W0000'
class rule_i0000(CloudFormationLintRule):
"""Info Rule"""
id = 'I0000'
rules_to_add = [rule_e0000, rule_w0000, rule_i0000]
rules = RulesCollection(ignore_rules=None, include_rules=None)
rules.extend(rules_to_add)
self.assertEqual(len(rules), 2)
for rule in rules:
self.assertIn(rule.id, ['W0000', 'E0000'])
def test_success_filtering_of_rules_include_info(self):
"""Test extend function"""
class rule_e0000(CloudFormationLintRule):
"""Error Rule"""
id = 'E0000'
class rule_w0000(CloudFormationLintRule):
"""Warning Rule"""
id = 'W0000'
class rule_i0000(CloudFormationLintRule):
"""Info Rule"""
id = 'I0000'
rules_to_add = [rule_e0000, rule_w0000, rule_i0000]
rules = RulesCollection(ignore_rules=None, include_rules=['I'])
rules.extend(rules_to_add)
self.assertEqual(len(rules), 3)
for rule in rules:
self.assertIn(rule.id, ['I0000', 'W0000', 'E0000'])
def test_success_filtering_of_rules_exclude(self):
"""Test extend function"""
class rule_e0000(CloudFormationLintRule):
"""Error Rule"""
id = 'E0000'
class rule_w0000(CloudFormationLintRule):
"""Warning Rule"""
id = 'W0000'
class rule_i0000(CloudFormationLintRule):
"""Info Rule"""
id = 'I0000'
rules_to_add = [rule_e0000, rule_w0000, rule_i0000]
rules = RulesCollection(ignore_rules=['E'])
rules.extend(rules_to_add)
self.assertEqual(len(rules), 1)
for rule in rules:
self.assertIn(rule.id, ['W0000'])
def test_success_filtering_of_rules_exclude_long(self):
"""Test extend function"""
class rule_e0000(CloudFormationLintRule):
"""Error Rule"""
id = 'E0000'
class rule_e0010(CloudFormationLintRule):
"""Error Rule"""
id = 'E0010'
class rule_e0002(CloudFormationLintRule):
"""Error Rule"""
id = 'E0002'
rules_to_add = [rule_e0000, rule_e0010, rule_e0002]
rules = RulesCollection(ignore_rules=['E000'])
rules.extend(rules_to_add)
self.assertEqual(len(rules), 1)
for rule in rules:
self.assertIn(rule.id, ['E0010'])
def test_success_filtering_of_rules_exclude_longer(self):
"""Test extend function"""
class rule_e0000(CloudFormationLintRule):
"""Error Rule"""
id = 'E0000'
class rule_e0010(CloudFormationLintRule):
"""Error Rule"""
id = 'E0010'
class rule_e0002(CloudFormationLintRule):
"""Error Rule"""
id = 'E0002'
rules_to_add = [rule_e0000, rule_e0010, rule_e0002]
rules = RulesCollection(ignore_rules=['E0002'])
rules.extend(rules_to_add)
self.assertEqual(len(rules), 2)
for rule in rules:
self.assertIn(rule.id, ['E0000', 'E0010'])
class TestCfnJson(BaseTestCase):
"""Test JSON Parsing """
def setUp(self):
""" SetUp template object"""
self.rules = RulesCollection(include_experimental=True)
rulesdirs = [DEFAULT_RULESDIR]
for rulesdir in rulesdirs:
self.rules.extend(
RulesCollection.create_from_directory(rulesdir))
self.filenames = {
"config_rule": {
"filename": 'test/fixtures/templates/quickstart/config-rules.json',
"failures": 4
},
"iam": {
"filename": 'test/fixtures/templates/quickstart/iam.json',
"failures": 5
},
"nat_instance": {
"filename": 'test/fixtures/templates/quickstart/nat-instance.json',
"failures": 2
},
"vpc_management": {
"filename": 'test/fixtures/templates/quickstart/vpc-management.json',
"failures": 33
},
"vpc": {
"filename": 'test/fixtures/templates/quickstart/vpc.json',
"failures": 40
},
"poller": {
"filename": 'test/fixtures/templates/public/lambda-poller.json',
"failures": 0
}
}
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 = []
matches.extend(self.rules.run(filename, cfn))
assert len(matches) == failures, 'Expected {} failures, got {} on {}'.format(failures, len(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 = []
matches.extend(self.rules.run(filename, cfn))
assert len(matches) == failures, 'Expected {} failures, got {} on {}'.format(failures, len(matches), filename)
def test_success_parse_stdin(self):
"""Test Successful JSON Parsing through stdin"""
for _, values in self.filenames.items():
filename = '-'
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 = []
matches.extend(self.rules.run(filename, cfn))
assert len(matches) == failures, 'Expected {} failures, got {} on {}'.format(failures, len(matches), filename)
def test_fail_run(self):
"""Test failure run"""
filename = 'test/fixtures/templates/bad/json_parse.json'
try:
template = cfnlint.decode.cfn_json.load(filename)
except cfnlint.decode.cfn_json.JSONDecodeError:
assert(True)
return
assert(False)
