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())