def rule_runner(request: SubRequest, config_options: Namespace) -> RunFromText:
"""Return runner for a specific rule class."""
rule_class = request.param
config_options.enable_list.append(rule_class().id)
collection = RulesCollection(options=config_options)
collection.register(rule_class())
return RunFromText(collection)
def test_file(self):
collection = RulesCollection()
collection.register(AdminByDefault())
file_name = 'testResources/ansible-smell/adminbydefault.yml'
good_runner = Runner(playbook=file_name, rules=collection)
# print(good_runner.run())
assert 3 == len(good_runner.run())
def test_file(self):
collection = RulesCollection()
collection.register(HardCodedSecrets())
file_name = 'testResources/ansible-smell/create.yml'
good_runner = Runner(rules=collection, playbook=file_name)
# print(good_runner.run())
assert 1 == len(good_runner.run())
def lint_error_lines(test_playbook: str) -> List[int]:
"""Get VarHasSpacesRules linting results on test_playbook."""
collection = RulesCollection()
collection.register(VariableHasSpacesRule())
lintable = Lintable(test_playbook)
results = Runner(lintable, rules=collection).run()
return list(map(lambda item: item.linenumber, results))
def test_file(self):
collection = RulesCollection()
collection.register(DepreciatedStatementUsage())
file_name = 'testResources/ansible-smell/adminbydefault.yml'
good_runner = Runner(playbook=file_name, rules=collection)
print(good_runner.run())
def test_file(self):
collection = RulesCollection()
collection.register(EmptyPassword0())
file_name = 'testResources/ansible-smell/adminbydefault.yml'
good_runner = Runner(playbook=file_name, rules=collection)
print(good_runner.run())
print(len(good_runner.run()))
assert 0 == len(good_runner.run())
def test_file(self):
collection = RulesCollection()
collection.register(HardCodePassword())
file_name = 'testResources/ansible-smell/hardcodepassword.yml'
good_runner = Runner(playbook=file_name, rules=collection)
print(good_runner.run())
print(type(good_runner.run()))
print(len(good_runner.run()))
assert 0 == len(good_runner.run())
def test_206() -> None:
"""Verify rule."""
collection = RulesCollection()
collection.register(VariableHasSpacesRule())
lintable = Lintable("examples/playbooks/206.yml")
results = Runner(collection, lintable=lintable).run()
assert len(results) == 3
def test_var_spacing() -> None:
"""Verify rule."""
collection = RulesCollection()
collection.register(VariableHasSpacesRule())
lintable = Lintable("examples/playbooks/var-spacing.yml")
results = Runner(lintable, rules=collection).run()
assert len(results) == 3
def test_file(self):
collection = RulesCollection()
collection.register(InvalidIPaddressbinding())
file_name = 'testResources/ansible-smell/invalidIPaddressbinding.yml'
good_runner = Runner(playbook=file_name, rules=collection)
result = good_runner.run()
print(result)
print(type(result))
print(len(result))
assert 0 == len(good_runner.run())
def list_rule_ids_itr() -> typing.Iterator[str]:
"""
Yield custom rule IDs using ansiblelint.rules.RulesCollection.
"""
rdirs = (DEFAULT_RULES_DIR, RULES_DIR)
try:
for rdir in rdirs:
for rule in RulesCollection.create_from_directory(rdir):
yield rule.id
except AttributeError: # newer ansiblelint
for rule in RulesCollection(rdirs):
yield rule.id
def setUp(self):
"""Initialize lint rules collection.
"""
if not self.rule or not self.name:
return
# Collect the default rules and add the rule to test.
self.rules = RulesCollection()
self.rules.register(self.rule)
if callable(self.clear_fn):
self.clear_fn() # pylint: disable=not-callable
def test_tags(
test_rules_collection: RulesCollection,
ematchtestfile: Lintable,
bracketsmatchtestfile: Lintable,
) -> None:
matches = test_rules_collection.run(ematchtestfile, tags={'test1'})
assert len(matches) == 3
matches = test_rules_collection.run(ematchtestfile, tags={'test2'})
assert len(matches) == 0
matches = test_rules_collection.run(bracketsmatchtestfile, tags={'test1'})
assert len(matches) == 0
matches = test_rules_collection.run(bracketsmatchtestfile, tags={'test2'})
assert len(matches) == 2
def test_skip_id(
test_rules_collection: RulesCollection,
ematchtestfile: Lintable,
bracketsmatchtestfile: Lintable,
) -> None:
matches = test_rules_collection.run(ematchtestfile, skip_list=['TEST0001'])
assert len(matches) == 0
matches = test_rules_collection.run(ematchtestfile, skip_list=['TEST0002'])
assert len(matches) == 3
matches = test_rules_collection.run(bracketsmatchtestfile,
skip_list=['TEST0001'])
assert len(matches) == 2
matches = test_rules_collection.run(bracketsmatchtestfile,
skip_list=['TEST0002'])
assert len(matches) == 0
def test_rule_no_handler() -> None:
"""Verify rule."""
collection = RulesCollection()
collection.register(UseHandlerRatherThanWhenChangedRule())
lintable = Lintable('examples/playbooks/rule-no-handler.yml')
results = Runner(lintable, rules=collection).run()
assert len(results) == 3
assert results[0].filename == 'examples/playbooks/roles/a-role/tasks/main.yml'
assert results[0].linenumber == 3
assert results[1].filename == 'examples/playbooks/rule-no-handler.yml'
assert results[1].linenumber == 14
assert results[2].filename == 'examples/playbooks/rule-no-handler.yml'
assert results[2].linenumber == 18
def test_file(self):
collection = RulesCollection()
collection.register(DuplicateEntity())
file_name = 'testResources/ansible-smell/hardcodepassword5.yml'
good_runner = Runner(playbook=file_name, rules=collection)
name_list = []
for item in good_runner.run():
name_list.append(str(item).split('matched')[0])
if len(name_list) != 0:
print([
item for item, count in collections.Counter(name_list).items()
if count > 1
])
class TestComparisonToLiteralBoolRule(unittest.TestCase):
collection = RulesCollection()
collection.register(ComparisonToLiteralBoolRule())
def setUp(self) -> None:
self.runner = RunFromText(self.collection)
def test_when(self) -> None:
results = self.runner.run_role_tasks_main(PASS_WHEN)
self.assertEqual(0, len(results))
def test_when_not_false(self) -> None:
results = self.runner.run_role_tasks_main(PASS_WHEN_NOT_FALSE)
self.assertEqual(0, len(results))
def test_when_not_null(self) -> None:
results = self.runner.run_role_tasks_main(PASS_WHEN_NOT_NULL)
self.assertEqual(0, len(results))
def test_literal_true(self) -> None:
results = self.runner.run_role_tasks_main(FAIL_LITERAL_TRUE)
self.assertEqual(1, len(results))
def test_literal_false(self) -> None:
results = self.runner.run_role_tasks_main(FAIL_LITERAL_FALSE)
assert len(results) == 2, results
class TestWithSkipTagId(unittest.TestCase):
collection = RulesCollection()
collection.register(TrailingWhitespaceRule())
file = 'test/with-skip-tag-id.yml'
def test_negative_no_param(self):
bad_runner = Runner(self.collection, self.file, [], [], [])
errs = bad_runner.run()
self.assertGreater(len(errs), 0)
def test_negative_with_id(self):
with_id = '201'
bad_runner = Runner(self.collection, self.file, [with_id], [], [])
errs = bad_runner.run()
self.assertGreater(len(errs), 0)
def test_negative_with_tag(self):
with_tag = 'ANSIBLE0002'
bad_runner = Runner(self.collection, self.file, [with_tag], [], [])
errs = bad_runner.run()
self.assertGreater(len(errs), 0)
def test_positive_skip_id(self):
skip_id = '201'
good_runner = Runner(self.collection, self.file, [], [skip_id], [])
self.assertEqual([], good_runner.run())
def test_positive_skip_tag(self):
skip_tag = 'ANSIBLE0002'
good_runner = Runner(self.collection, self.file, [], [skip_tag], [])
self.assertEqual([], good_runner.run())
class TestMetaMainHasInfo(unittest.TestCase):
collection = RulesCollection()
collection.register(MetaMainHasInfoRule())
def setUp(self):
self.runner = RunFromText(self.collection)
def test_no_galaxy_info(self):
results = self.runner.run_role_meta_main(NO_GALAXY_INFO)
assert len(results) == 1
self.assertIn("No 'galaxy_info' found", str(results))
def test_missing_info(self):
results = self.runner.run_role_meta_main(MISSING_INFO)
assert len(results) == 3
self.assertIn("Role info should contain author", str(results))
self.assertIn("Role info should contain min_ansible_version",
str(results))
self.assertIn("Platform should contain name", str(results))
def test_bad_types(self):
results = self.runner.run_role_meta_main(BAD_TYPES)
assert len(results) == 3
self.assertIn("author should be a string", str(results))
self.assertIn("description should be a string", str(results))
self.assertIn("Platforms should be a list of dictionaries",
str(results))
def test_platform_list_of_str(self):
results = self.runner.run_role_meta_main(PLATFORMS_LIST_OF_STR)
assert len(results) == 1
self.assertIn("Platforms should be a list of dictionaries",
str(results))
def test_rules_id_format() -> None:
"""Assure all our rules have consistent format."""
rule_id_re = re.compile("^[a-z-]{4,30}$")
rules = RulesCollection([os.path.abspath('./src/ansiblelint/rules')])
for rule in rules:
assert rule_id_re.match(
rule.id), f"R rule id {rule.id} did not match our required format."
assert len(rules) == 37
def run(self) -> List[nodes.Node]:
"""Generate a node tree in place of the directive."""
self.env.note_reread() # rebuild the current RST doc unconditionally
default_rules = RulesCollection([DEFAULT_RULESDIR])
rst_rules_table = rules_as_rst(default_rules)
return _nodes_from_rst(state=self.state, rst_source=rst_rules_table)
class RuleTestCase(unittest.TestCase):
"""Base class to test ansible-lint rules.
"""
name = None
rule = None
clear_fn: typing.Optional[typing.Callable] = None
def setUp(self):
"""Initialize lint rules collection.
"""
if not self.rule or not self.name:
return
# Collect the default rules and add the rule to test.
self.rules = RulesCollection()
self.rules.register(self.rule)
if callable(self.clear_fn):
self.clear_fn() # pylint: disable=not-callable
def list_resources(
self,
success: bool = True,
search: typing.Optional[str] = None) -> typing.List[str]:
return list_resources(self.name, success=success, search=search)
def lint(self, success: bool = True, search: typing.Optional[str] = None):
"""
Run the lint rule's check to given resource data files.
"""
if not self.rule or not self.name:
return
for filepath in self.list_resources(success, search=search):
runner = Runner(self.rules, filepath, [], [], [])
res = runner.run()
if success:
self.assertEqual(0, len(res), res) # No errors
else:
self.assertTrue(len(res) > 0, res) # Something went wrong
def test_10_ok_cases(self):
self.lint()
def test_20_ng_cases(self):
self.lint(False)
class TestOctalPermissionsRuleWithFile(unittest.TestCase):
collection = RulesCollection()
VALID_MODES = [
0o777, 0o775, 0o770, 0o755, 0o750, 0o711, 0o710, 0o700, 0o666, 0o664,
0o660, 0o644, 0o640, 0o600, 0o555, 0o551, 0o550, 0o511, 0o510, 0o500,
0o444, 0o440, 0o400
]
INVALID_MODES = [
777,
775,
770,
755,
750,
711,
710,
700,
666,
664,
660,
644,
640,
622,
620,
600,
555,
551,
550, # 511 == 0o777, 510 == 0o776, 500 == 0o764
444,
440,
400
]
def setUp(self):
self.rule = OctalPermissionsRule()
self.collection.register(self.rule)
self.runner = RunFromText(self.collection)
def test_success(self):
results = self.runner.run_playbook(SUCCESS_TASKS)
self.assertEqual(0, len(results))
def test_fail(self):
results = self.runner.run_playbook(FAIL_TASKS)
self.assertEqual(4, len(results))
def test_valid_modes(self):
for mode in self.VALID_MODES:
self.assertFalse(self.rule.is_invalid_permission(mode),
msg="0o%o should be a valid mode" % mode)
def test_invalid_modes(self):
for mode in self.INVALID_MODES:
self.assertTrue(self.rule.is_invalid_permission(mode),
msg="%d should be an invalid mode" % mode)
class TestVariableHasSpaces(unittest.TestCase):
collection = RulesCollection()
collection.register(VariableHasSpacesRule())
def setUp(self):
self.runner = RunFromText(self.collection)
def test_variable_has_spaces(self):
results = self.runner.run_role_tasks_main(TASK_VARIABLES)
self.assertEqual(3, len(results))
class TestLineTooLongRule(unittest.TestCase):
collection = RulesCollection()
collection.register(LineTooLongRule())
def setUp(self):
self.runner = RunFromText(self.collection)
def test_long_line(self):
results = self.runner.run_role_tasks_main(LONG_LINE)
self.assertEqual(1, len(results))
class TestTaskNoLocalAction(unittest.TestCase):
collection = RulesCollection()
collection.register(TaskNoLocalAction())
def setUp(self):
self.runner = RunFromText(self.collection)
def test_local_action(self):
results = self.runner.run_role_tasks_main(TASK_LOCAL_ACTION)
self.assertEqual(1, len(results))
class TestInconsistentNaming(unittest.TestCase):
collection = RulesCollection()
def setUp(self):
self.collection.register(InconsistentNaming())
def test_file(self):
file_name = 'testResources/ansible-smell/unnamedconstructs.yml'
good_runner = Runner(playbook=file_name, rules=self.collection)
print(good_runner.run())
class TestRoleHandlers(unittest.TestCase):
collection = RulesCollection()
def setUp(self):
self.collection.register(UseHandlerRatherThanWhenChangedRule())
def test_role_handler_positive(self):
success = 'test/role-with-handler/main.yml'
good_runner = Runner(self.collection, success, [], [], [])
self.assertEqual([], good_runner.run())
def test_rules_id_format() -> None:
"""Assure all our rules have consistent format."""
rule_id_re = re.compile("^[a-z-]{4,30}$")
options.enable_list = ['no-same-owner', 'no-log-password', 'no-same-owner']
rules = RulesCollection([os.path.abspath('./src/ansiblelint/rules')],
options=options)
for rule in rules:
assert rule_id_re.match(
rule.id), f"Rule id {rule.id} did not match our required format."
assert len(rules) == 40
class TestInvalidPropertyValue(unittest.TestCase):
collection = RulesCollection()
def setUp(self):
self.collection.register(InvalidPropertyValue())
def test_file(self):
file_name = 'testResources/ansible-smell/httpwithouttls3.yml'
good_runner = Runner(playbook=file_name, rules=self.collection)
print(good_runner.run())
