diff options
Diffstat (limited to 'test')
180 files changed, 4896 insertions, 0 deletions
diff --git a/test/TestAlwaysRunRule.py b/test/TestAlwaysRunRule.py new file mode 100644 index 0000000..011a258 --- /dev/null +++ b/test/TestAlwaysRunRule.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.AlwaysRunRule import AlwaysRunRule +from ansiblelint.runner import Runner + + +class TestAlwaysRun(unittest.TestCase): + collection = RulesCollection() + + def setUp(self): + self.collection.register(AlwaysRunRule()) + + def test_file_positive(self): + success = 'test/always-run-success.yml' + good_runner = Runner(self.collection, success, [], [], []) + self.assertEqual([], good_runner.run()) + + def test_file_negative(self): + failure = 'test/always-run-failure.yml' + bad_runner = Runner(self.collection, failure, [], [], []) + errs = bad_runner.run() + self.assertEqual(1, len(errs)) diff --git a/test/TestAnsibleLintRule.py b/test/TestAnsibleLintRule.py new file mode 100644 index 0000000..f8bc6d1 --- /dev/null +++ b/test/TestAnsibleLintRule.py @@ -0,0 +1,7 @@ +from ansiblelint.rules import AnsibleLintRule + + +def test_unjinja(): + input = "{{ a }} {% b %} {# try to confuse parsing inside a comment { {{}} } #}" + output = "JINJA_EXPRESSION JINJA_STATEMENT JINJA_COMMENT" + assert AnsibleLintRule.unjinja(input) == output diff --git a/test/TestAnsibleSyntax.py b/test/TestAnsibleSyntax.py new file mode 100644 index 0000000..8103b61 --- /dev/null +++ b/test/TestAnsibleSyntax.py @@ -0,0 +1,16 @@ +"""Test Ansible Syntax. + +This module contains tests that validate that linter does not produce errors +when encountering what counts as valid Ansible syntax. +""" + +PB_WITH_NULL_TASKS = ''' +- hosts: all + tasks: +''' + + +def test_null_tasks(default_text_runner): + """Assure we do not fail when encountering null tasks.""" + results = default_text_runner.run_playbook(PB_WITH_NULL_TASKS) + assert not results diff --git a/test/TestBaseFormatter.py b/test/TestBaseFormatter.py new file mode 100644 index 0000000..c6ba7fb --- /dev/null +++ b/test/TestBaseFormatter.py @@ -0,0 +1,46 @@ +# -*- coding: utf-8; -*- +from pathlib import Path + +import pytest + +from ansiblelint.formatters import BaseFormatter + + +@pytest.mark.parametrize(('base_dir', 'relative_path'), ( + (None, True), + ('/whatever', False), + (Path('/whatever'), False), +)) +@pytest.mark.parametrize('path', ('/whatever/string', Path('/whatever/string'))) +def test_base_formatter_when_base_dir(base_dir, relative_path, path): + # Given + base_formatter = BaseFormatter(base_dir, relative_path) + + # When + output_path = base_formatter._format_path(path) + + # Then + assert isinstance(output_path, str) + assert base_formatter._base_dir is None or isinstance(base_formatter._base_dir, str) + assert output_path == str(path) + + +@pytest.mark.parametrize('base_dir', ( + Path('/whatever'), + '/whatever', +)) +@pytest.mark.parametrize('path', ('/whatever/string', Path('/whatever/string'))) +def test_base_formatter_when_base_dir_is_given_and_relative_is_true(path, base_dir): + # Given + base_formatter = BaseFormatter(base_dir, True) + + # When + output_path = base_formatter._format_path(path) + + # Then + assert isinstance(output_path, str) + assert isinstance(base_formatter._base_dir, str) + assert output_path == Path(path).name + + +# vim: et:sw=4:syntax=python:ts=4: diff --git a/test/TestBecomeUserWithoutBecome.py b/test/TestBecomeUserWithoutBecome.py new file mode 100644 index 0000000..066e52f --- /dev/null +++ b/test/TestBecomeUserWithoutBecome.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.BecomeUserWithoutBecomeRule import BecomeUserWithoutBecomeRule +from ansiblelint.runner import Runner + + +class TestBecomeUserWithoutBecome(unittest.TestCase): + collection = RulesCollection() + + def setUp(self): + self.collection.register(BecomeUserWithoutBecomeRule()) + + def test_file_positive(self): + success = 'test/become-user-without-become-success.yml' + good_runner = Runner(self.collection, success, [], [], []) + self.assertEqual([], good_runner.run()) + + def test_file_negative(self): + failure = 'test/become-user-without-become-failure.yml' + bad_runner = Runner(self.collection, failure, [], [], []) + errs = bad_runner.run() + self.assertEqual(3, len(errs)) diff --git a/test/TestCliRolePaths.py b/test/TestCliRolePaths.py new file mode 100644 index 0000000..a459df2 --- /dev/null +++ b/test/TestCliRolePaths.py @@ -0,0 +1,134 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import os +import unittest +from pathlib import Path + +import pytest + +from ansiblelint.testing import run_ansible_lint + + +class TestCliRolePaths(unittest.TestCase): + def setUp(self): + self.local_test_dir = os.path.dirname(os.path.realpath(__file__)) + + def test_run_single_role_path_no_trailing_slash_module(self): + cwd = self.local_test_dir + role_path = 'test-role' + + result = run_ansible_lint(role_path, cwd=cwd) + self.assertIn('Use shell only when shell functionality is required', + result.stdout) + + def test_run_single_role_path_no_trailing_slash_script(self): + cwd = self.local_test_dir + role_path = 'test-role' + + result = run_ansible_lint(role_path, cwd=cwd, bin="ansible-lint") + self.assertIn('Use shell only when shell functionality is required', + result.stdout) + + def test_run_single_role_path_with_trailing_slash(self): + cwd = self.local_test_dir + role_path = 'test-role/' + + result = run_ansible_lint(role_path, cwd=cwd) + self.assertIn('Use shell only when shell functionality is required', + result.stdout) + + def test_run_multiple_role_path_no_trailing_slash(self): + cwd = self.local_test_dir + role_path = 'roles/test-role' + + result = run_ansible_lint(role_path, cwd=cwd) + self.assertIn('Use shell only when shell functionality is required', + result.stdout) + + def test_run_multiple_role_path_with_trailing_slash(self): + cwd = self.local_test_dir + role_path = 'roles/test-role/' + + result = run_ansible_lint(role_path, cwd=cwd) + self.assertIn('Use shell only when shell functionality is required', + result.stdout) + + def test_run_inside_role_dir(self): + cwd = os.path.join(self.local_test_dir, 'test-role/') + role_path = '.' + + result = run_ansible_lint(role_path, cwd=cwd) + self.assertIn('Use shell only when shell functionality is required', + result.stdout) + + def test_run_role_three_dir_deep(self): + cwd = self.local_test_dir + role_path = 'testproject/roles/test-role' + + result = run_ansible_lint(role_path, cwd=cwd) + self.assertIn('Use shell only when shell functionality is required', + result.stdout) + + def test_run_playbook(self): + """Call ansible-lint the way molecule does.""" + top_src_dir = os.path.dirname(self.local_test_dir) + cwd = os.path.join(top_src_dir, 'test/roles/test-role') + role_path = 'molecule/default/include-import-role.yml' + + env = os.environ.copy() + env['ANSIBLE_ROLES_PATH'] = os.path.dirname(cwd) + + result = run_ansible_lint(role_path, cwd=cwd, env=env) + self.assertIn('Use shell only when shell functionality is required', result.stdout) + + def test_run_role_name_invalid(self): + cwd = self.local_test_dir + role_path = 'roles/invalid-name' + + result = run_ansible_lint(role_path, cwd=cwd) + assert '106 Role name invalid-name does not match' in result.stdout + + def test_run_role_name_with_prefix(self): + cwd = self.local_test_dir + role_path = 'roles/ansible-role-foo' + + result = run_ansible_lint(role_path, cwd=cwd) + assert len(result.stdout) == 0 + assert len(result.stderr) == 0 + assert result.returncode == 0 + + def test_run_role_name_from_meta(self): + cwd = self.local_test_dir + role_path = 'roles/valid-due-to-meta' + + result = run_ansible_lint(role_path, cwd=cwd) + assert len(result.stdout) == 0 + assert len(result.stderr) == 0 + assert result.returncode == 0 + + def test_run_invalid_role_name_from_meta(self): + cwd = self.local_test_dir + role_path = 'roles/invalid_due_to_meta' + + result = run_ansible_lint(role_path, cwd=cwd) + assert '106 Role name invalid-due-to-meta does not match' in result.stdout + + +@pytest.mark.parametrize(('result', 'env'), ( + (True, { + "GITHUB_ACTIONS": "true", + "GITHUB_WORKFLOW": "foo" + }), + (False, None)), + ids=("on", "off")) +def test_run_playbook_github(result, env): + """Call ansible-lint simulating GitHub Actions environment.""" + cwd = str(Path(__file__).parent.parent.resolve()) + role_path = 'examples/example.yml' + + result_gh = run_ansible_lint(role_path, cwd=cwd, env=env) + + expected = ( + '::error file=examples/example.yml,line=47,severity=MEDIUM::[E101] ' + 'Deprecated always_run' + ) + assert (expected in result_gh.stdout) is result diff --git a/test/TestCommandHasChangesCheck.py b/test/TestCommandHasChangesCheck.py new file mode 100644 index 0000000..da0aa08 --- /dev/null +++ b/test/TestCommandHasChangesCheck.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.CommandHasChangesCheckRule import CommandHasChangesCheckRule +from ansiblelint.runner import Runner + + +class TestCommandHasChangesCheck(unittest.TestCase): + collection = RulesCollection() + + def setUp(self): + self.collection.register(CommandHasChangesCheckRule()) + + def test_command_changes_positive(self): + success = 'test/command-check-success.yml' + good_runner = Runner(self.collection, success, [], [], []) + self.assertEqual([], good_runner.run()) + + def test_command_changes_negative(self): + failure = 'test/command-check-failure.yml' + bad_runner = Runner(self.collection, failure, [], [], []) + errs = bad_runner.run() + self.assertEqual(2, len(errs)) diff --git a/test/TestCommandLineInvocationSameAsConfig.py b/test/TestCommandLineInvocationSameAsConfig.py new file mode 100644 index 0000000..a5368fa --- /dev/null +++ b/test/TestCommandLineInvocationSameAsConfig.py @@ -0,0 +1,137 @@ +import os +import sys +from pathlib import Path + +import pytest + +from ansiblelint import cli + + +@pytest.fixture +def base_arguments(): + return ['../test/skiptasks.yml'] + + +@pytest.mark.parametrize(('args', 'config'), ( + (["-p"], "test/fixtures/parseable.yml"), + (["-q"], "test/fixtures/quiet.yml"), + (["-r", "test/fixtures/rules/"], + "test/fixtures/rulesdir.yml"), + (["-R", "-r", "test/fixtures/rules/"], + "test/fixtures/rulesdir-defaults.yml"), + (["-t", "skip_ansible_lint"], + "test/fixtures/tags.yml"), + (["-v"], "test/fixtures/verbosity.yml"), + (["-x", "bad_tag"], + "test/fixtures/skip-tags.yml"), + (["--exclude", "test/"], + "test/fixtures/exclude-paths.yml"), + (["--show-relpath"], + "test/fixtures/show-abspath.yml"), + ([], + "test/fixtures/show-relpath.yml"), + )) +def test_ensure_config_are_equal(base_arguments, args, config, monkeypatch): + command = base_arguments + args + cli_parser = cli.get_cli_parser() + + _real_pathlib_resolve = Path.resolve + + def _fake_pathlib_resolve(self): + try: + return _real_pathlib_resolve(self) + except FileNotFoundError: + if self != Path(args[-1]): + raise + return Path.cwd() / self + + with monkeypatch.context() as mp_ctx: + if ( + sys.version_info[:2] < (3, 6) and + args[-2:] == ["-r", "test/fixtures/rules/"] + ): + mp_ctx.setattr(Path, 'resolve', _fake_pathlib_resolve) + options = cli_parser.parse_args(command) + + file_config = cli.load_config(config) + + for key, val in file_config.items(): + if key in {'exclude_paths', 'rulesdir'}: + val = [Path(p) for p in val] + assert val == getattr(options, key) + + +def test_config_can_be_overridden(base_arguments): + no_override = cli.get_config(base_arguments + ["-t", "bad_tag"]) + + overridden = cli.get_config(base_arguments + + ["-t", "bad_tag", + "-c", "test/fixtures/tags.yml"]) + + assert no_override.tags + ["skip_ansible_lint"] == overridden.tags + + +def test_different_config_file(base_arguments): + """Ensures an alternate config_file can be used.""" + diff_config = cli.get_config(base_arguments + + ["-c", "test/fixtures/ansible-config.yml"]) + no_config = cli.get_config(base_arguments + ["-v"]) + + assert diff_config.verbosity == no_config.verbosity + + +def test_expand_path_user_and_vars_config_file(base_arguments): + """Ensure user and vars are expanded when specified as exclude_paths.""" + config1 = cli.get_config(base_arguments + + ["-c", "test/fixtures/exclude-paths-with-expands.yml"]) + config2 = cli.get_config(base_arguments + [ + "--exclude", "~/.ansible/roles", + "--exclude", "$HOME/.ansible/roles" + ]) + + assert str(config1.exclude_paths[0]) == os.path.expanduser("~/.ansible/roles") + assert str(config2.exclude_paths[0]) == os.path.expanduser("~/.ansible/roles") + assert str(config1.exclude_paths[1]) == os.path.expandvars("$HOME/.ansible/roles") + assert str(config2.exclude_paths[1]) == os.path.expandvars("$HOME/.ansible/roles") + + +def test_path_from_config_do_not_depend_on_cwd(monkeypatch): # Issue 572 + config1 = cli.load_config("test/fixtures/config-with-relative-path.yml") + monkeypatch.chdir('test') + config2 = cli.load_config("fixtures/config-with-relative-path.yml") + + assert config1['exclude_paths'].sort() == config2['exclude_paths'].sort() + + +def test_path_from_cli_depend_on_cwd(base_arguments, monkeypatch, tmp_path): + # Issue 572 + arguments = base_arguments + ["--exclude", + "test/fixtures/config-with-relative-path.yml"] + + options1 = cli.get_cli_parser().parse_args(arguments) + assert 'test/test' not in str(options1.exclude_paths[0]) + + test_dir = 'test' + if sys.version_info[:2] < (3, 6): + test_dir = tmp_path / 'test' / 'test' / 'fixtures' + test_dir.mkdir(parents=True) + (test_dir / 'config-with-relative-path.yml').write_text('') + test_dir = test_dir / '..' / '..' + monkeypatch.chdir(test_dir) + options2 = cli.get_cli_parser().parse_args(arguments) + + assert 'test/test' in str(options2.exclude_paths[0]) + + +@pytest.mark.parametrize( + "config_file", + ( + pytest.param("test/fixtures/ansible-config-invalid.yml", id="invalid"), + pytest.param("/dev/null/ansible-config-missing.yml", id="missing") + ), +) +def test_config_failure(base_arguments, config_file): + """Ensures specific config files produce error code 2.""" + with pytest.raises(SystemExit, match="^2$"): + cli.get_config(base_arguments + + ["-c", config_file]) diff --git a/test/TestComparisonToEmptyString.py b/test/TestComparisonToEmptyString.py new file mode 100644 index 0000000..cdbd0fa --- /dev/null +++ b/test/TestComparisonToEmptyString.py @@ -0,0 +1,39 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.ComparisonToEmptyStringRule import ComparisonToEmptyStringRule +from ansiblelint.testing import RunFromText + +SUCCESS_TASKS = ''' +- name: shut down + command: /sbin/shutdown -t now + when: ansible_os_family +''' + +FAIL_TASKS = ''' +- hosts: all + tasks: + - name: shut down + command: /sbin/shutdown -t now + when: ansible_os_family == "" + - name: shut down + command: /sbin/shutdown -t now + when: ansible_os_family !="" +''' + + +class TestComparisonToEmptyStringRule(unittest.TestCase): + collection = RulesCollection() + collection.register(ComparisonToEmptyStringRule()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + def test_success(self): + results = self.runner.run_role_tasks_main(SUCCESS_TASKS) + self.assertEqual(0, len(results)) + + def test_fail(self): + results = self.runner.run_playbook(FAIL_TASKS) + self.assertEqual(2, len(results)) diff --git a/test/TestComparisonToLiteralBool.py b/test/TestComparisonToLiteralBool.py new file mode 100644 index 0000000..041ca1b --- /dev/null +++ b/test/TestComparisonToLiteralBool.py @@ -0,0 +1,69 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.ComparisonToLiteralBoolRule import ComparisonToLiteralBoolRule +from ansiblelint.testing import RunFromText + +PASS_WHEN = ''' +- name: example task + debug: + msg: test + when: my_var +''' + +PASS_WHEN_NOT_FALSE = ''' +- name: example task + debug: + msg: test + when: not my_var +''' + +PASS_WHEN_NOT_NULL = ''' +- name: example task + debug: + msg: test + when: my_var not None +''' + +FAIL_LITERAL_TRUE = ''' +- name: example task + debug: + msg: test + when: my_var == True +''' + +FAIL_LITERAL_FALSE = ''' +- name: example task + debug: + msg: test + when: my_var == false +''' + + +class TestComparisonToLiteralBoolRule(unittest.TestCase): + collection = RulesCollection() + collection.register(ComparisonToLiteralBoolRule()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + def test_when(self): + results = self.runner.run_role_tasks_main(PASS_WHEN) + self.assertEqual(0, len(results)) + + def test_when_not_false(self): + results = self.runner.run_role_tasks_main(PASS_WHEN_NOT_FALSE) + self.assertEqual(0, len(results)) + + def test_when_not_null(self): + results = self.runner.run_role_tasks_main(PASS_WHEN_NOT_NULL) + self.assertEqual(0, len(results)) + + def test_literal_true(self): + results = self.runner.run_role_tasks_main(FAIL_LITERAL_TRUE) + self.assertEqual(1, len(results)) + + def test_literal_false(self): + results = self.runner.run_role_tasks_main(FAIL_LITERAL_FALSE) + self.assertEqual(1, len(results)) diff --git a/test/TestDependenciesInMeta.py b/test/TestDependenciesInMeta.py new file mode 100644 index 0000000..d272120 --- /dev/null +++ b/test/TestDependenciesInMeta.py @@ -0,0 +1,22 @@ +import pytest + +from ansiblelint.runner import Runner + + +@pytest.mark.parametrize( + 'filename', + ( + 'bitbucket', + 'galaxy', + 'github', + 'webserver', + 'gitlab', + ), +) +def test_external_dependency_is_ok(default_rules_collection, filename): + playbook_path = ( + 'test/dependency-in-meta/{filename}.yml'. + format_map(locals()) + ) + good_runner = Runner(default_rules_collection, playbook_path, [], [], []) + assert [] == good_runner.run() diff --git a/test/TestDeprecatedModule.py b/test/TestDeprecatedModule.py new file mode 100644 index 0000000..6741ed4 --- /dev/null +++ b/test/TestDeprecatedModule.py @@ -0,0 +1,32 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +import pytest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.DeprecatedModuleRule import DeprecatedModuleRule +from ansiblelint.testing import ANSIBLE_MAJOR_VERSION, RunFromText + +MODULE_DEPRECATED = ''' +- name: task example + docker: + debug: test +''' + + +class TestDeprecatedModuleRule(unittest.TestCase): + collection = RulesCollection() + collection.register(DeprecatedModuleRule()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + @pytest.mark.xfail( + ANSIBLE_MAJOR_VERSION > (2, 9), + reason='Ansible devel has changed so ansible-lint needs fixing. ' + 'Ref: https://github.com/ansible/ansible-lint/issues/675', + raises=SystemExit, strict=True, + ) + def test_module_deprecated(self): + results = self.runner.run_role_tasks_main(MODULE_DEPRECATED) + self.assertEqual(1, len(results)) diff --git a/test/TestEnvVarsInCommand.py b/test/TestEnvVarsInCommand.py new file mode 100644 index 0000000..e3a1d84 --- /dev/null +++ b/test/TestEnvVarsInCommand.py @@ -0,0 +1,90 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.EnvVarsInCommandRule import EnvVarsInCommandRule +from ansiblelint.testing import RunFromText + +SUCCESS_PLAY_TASKS = ''' +- hosts: localhost + + tasks: + - name: actual use of environment + shell: echo $HELLO + environment: + HELLO: hello + + - name: use some key-value pairs + command: chdir=/tmp creates=/tmp/bobbins warn=no touch bobbins + + - name: commands can have flags + command: abc --xyz=def blah + + - name: commands can have equals in them + command: echo "===========" + + - name: commands with cmd + command: + cmd: + echo "-------" + + - name: command with stdin (ansible > 2.4) + command: /bin/cat + args: + stdin: "Hello, world!" + + - name: use argv to send the command as a list + command: + argv: + - /bin/echo + - Hello + - World + + - name: another use of argv + command: + args: + argv: + - echo + - testing + + - name: environment variable with shell + shell: HELLO=hello echo $HELLO + + - name: command with stdin_add_newline (ansible > 2.8) + command: /bin/cat + args: + stdin: "Hello, world!" + stdin_add_newline: false + + - name: command with strip_empty_ends (ansible > 2.8) + command: echo + args: + strip_empty_ends: false +''' + +FAIL_PLAY_TASKS = ''' +- hosts: localhost + + tasks: + - name: environment variable with command + command: HELLO=hello echo $HELLO + + - name: typo some stuff + command: cerates=/tmp/blah warn=no touch /tmp/blah +''' + + +class TestEnvVarsInCommand(unittest.TestCase): + collection = RulesCollection() + collection.register(EnvVarsInCommandRule()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + def test_success(self): + results = self.runner.run_playbook(SUCCESS_PLAY_TASKS) + self.assertEqual(0, len(results)) + + def test_fail(self): + results = self.runner.run_playbook(FAIL_PLAY_TASKS) + self.assertEqual(2, len(results)) diff --git a/test/TestExamples.py b/test/TestExamples.py new file mode 100644 index 0000000..48a89d3 --- /dev/null +++ b/test/TestExamples.py @@ -0,0 +1,8 @@ +"""Assure samples produced desire outcomes.""" +from ansiblelint.runner import Runner + + +def test_example(default_rules_collection): + """example.yml is expected to have 5 match errors inside.""" + result = Runner(default_rules_collection, 'examples/example.yml', [], [], []).run() + assert len(result) == 5 diff --git a/test/TestFormatter.py b/test/TestFormatter.py new file mode 100644 index 0000000..fd4f122 --- /dev/null +++ b/test/TestFormatter.py @@ -0,0 +1,46 @@ +# Copyright (c) 2016 Will Thames <will@thames.id.au> +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import pathlib +import unittest + +from ansiblelint.errors import MatchError +from ansiblelint.formatters import Formatter +from ansiblelint.rules import AnsibleLintRule + + +class TestFormatter(unittest.TestCase): + + def setUp(self): + self.rule = AnsibleLintRule() + self.rule.id = "TCF0001" + self.formatter = Formatter(pathlib.Path.cwd(), True) + + def test_format_coloured_string(self): + match = MatchError("message", 1, "hello", "filename.yml", self.rule) + self.formatter.format(match, True) + + def test_unicode_format_string(self): + match = MatchError(u'\U0001f427', 1, "hello", "filename.yml", self.rule) + self.formatter.format(match, False) + + def test_dict_format_line(self): + match = MatchError("xyz", 1, {'hello': 'world'}, "filename.yml", self.rule,) + self.formatter.format(match, True) diff --git a/test/TestImportIncludeRole.py b/test/TestImportIncludeRole.py new file mode 100644 index 0000000..8b581ff --- /dev/null +++ b/test/TestImportIncludeRole.py @@ -0,0 +1,103 @@ +import pytest + +from ansiblelint.runner import Runner + +ROLE_TASKS_MAIN = ''' +- name: shell instead of command + shell: echo hello world +''' + +ROLE_TASKS_WORLD = ''' +- command: echo this is a task without a name +''' + +PLAY_IMPORT_ROLE = ''' +- hosts: all + + tasks: + - import_role: + name: test-role +''' + +PLAY_IMPORT_ROLE_INCOMPLETE = ''' +- hosts: all + + tasks: + - import_role: + foo: bar +''' + +PLAY_IMPORT_ROLE_INLINE = ''' +- hosts: all + + tasks: + - import_role: name=test-role +''' + +PLAY_INCLUDE_ROLE = ''' +- hosts: all + + tasks: + - include_role: + name: test-role + tasks_from: world +''' + +PLAY_INCLUDE_ROLE_INLINE = ''' +- hosts: all + + tasks: + - include_role: name=test-role tasks_from=world +''' + + +@pytest.fixture +def playbook_path(request, tmp_path): + playbook_text = request.param + role_tasks_dir = tmp_path / 'test-role' / 'tasks' + role_tasks_dir.mkdir(parents=True) + (role_tasks_dir / 'main.yml').write_text(ROLE_TASKS_MAIN) + (role_tasks_dir / 'world.yml').write_text(ROLE_TASKS_WORLD) + play_path = tmp_path / 'playbook.yml' + play_path.write_text(playbook_text) + return str(play_path) + + +@pytest.mark.parametrize(('playbook_path', 'messages'), ( + pytest.param(PLAY_IMPORT_ROLE, + ['only when shell functionality is required'], + id='IMPORT_ROLE', + ), + pytest.param(PLAY_IMPORT_ROLE_INLINE, + ['only when shell functionality is require'], + id='IMPORT_ROLE_INLINE', + ), + pytest.param(PLAY_INCLUDE_ROLE, + ['only when shell functionality is require', + 'All tasks should be named'], + id='INCLUDE_ROLE', + ), + pytest.param(PLAY_INCLUDE_ROLE_INLINE, + ['only when shell functionality is require', + 'All tasks should be named'], + id='INCLUDE_ROLE_INLINE', + ), +), indirect=('playbook_path', )) +def test_import_role2(default_rules_collection, playbook_path, messages): + runner = Runner(default_rules_collection, playbook_path, [], [], []) + results = runner.run() + for message in messages: + assert message in str(results) + + +@pytest.mark.parametrize(('playbook_path', 'messages'), ( + pytest.param(PLAY_IMPORT_ROLE_INCOMPLETE, + ["Failed to find required 'name' key in import_role"], + id='IMPORT_ROLE_INCOMPLETE', + ), +), indirect=('playbook_path', )) +def test_invalid_import_role(default_rules_collection, playbook_path, messages): + runner = Runner(default_rules_collection, playbook_path, [], [], []) + results = runner.run() + for message in messages: + assert message in str(results) diff --git a/test/TestImportPlaybook.py b/test/TestImportPlaybook.py new file mode 100644 index 0000000..06492e3 --- /dev/null +++ b/test/TestImportPlaybook.py @@ -0,0 +1,17 @@ +"""Test ability to import playbooks.""" +from ansiblelint.runner import Runner + + +def test_task_hook_import_playbook(default_rules_collection): + """Assures import_playbook includes are recognized.""" + playbook_path = 'test/playbook-import/playbook_parent.yml' + runner = Runner(default_rules_collection, playbook_path, [], [], []) + results = runner.run() + + results_text = str(results) + assert len(runner.playbooks) == 2 + assert len(results) == 2 + # Assures we detected the issues from imported playbook + assert 'Commands should not change things' in results_text + assert '502' in results_text + assert 'All tasks should be named' in results_text diff --git a/test/TestImportWithMalformed.py b/test/TestImportWithMalformed.py new file mode 100644 index 0000000..4f5425c --- /dev/null +++ b/test/TestImportWithMalformed.py @@ -0,0 +1,65 @@ +from collections import namedtuple + +import pytest + +from ansiblelint.runner import Runner + +PlayFile = namedtuple('PlayFile', ['name', 'content']) + + +IMPORT_TASKS_MAIN = PlayFile('import-tasks-main.yml', ''' +- oops this is invalid +''') + +IMPORT_SHELL_PIP = PlayFile('import-tasks-main.yml', ''' +- shell: pip +''') + +PLAY_IMPORT_TASKS = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - import_tasks: import-tasks-main.yml +''') + + +@pytest.fixture +def play_file_path(tmp_path): + p = tmp_path / 'playbook.yml' + return str(p) + + +@pytest.fixture +def runner(play_file_path, default_rules_collection): + return Runner(default_rules_collection, play_file_path, [], [], []) + + +@pytest.fixture +def _play_files(tmp_path, request): + if request.param is None: + return + for play_file in request.param: + p = tmp_path / play_file.name + p.write_text(play_file.content) + + +@pytest.mark.parametrize( + '_play_files', + ( + pytest.param([IMPORT_SHELL_PIP, PLAY_IMPORT_TASKS], id='Import shell w/ pip'), + pytest.param( + [IMPORT_TASKS_MAIN, PLAY_IMPORT_TASKS], + id='import_tasks w/ malformed import', + marks=pytest.mark.xfail( + reason='Garbage non-tasks sequence is not being ' + 'properly processed. Ref: ' + 'https://github.com/ansible/ansible-lint/issues/707', + raises=AttributeError, + ), + ), + ), + indirect=['_play_files'] +) +@pytest.mark.usefixtures('_play_files') +def test_import_tasks_with_malformed_import(runner): + results = str(runner.run()) + assert 'only when shell functionality is required' in results diff --git a/test/TestIncludeMissFileWithRole.py b/test/TestIncludeMissFileWithRole.py new file mode 100644 index 0000000..126e095 --- /dev/null +++ b/test/TestIncludeMissFileWithRole.py @@ -0,0 +1,122 @@ +import os +from collections import namedtuple + +import pytest + +from ansiblelint.runner import Runner + +PlayFile = namedtuple('PlayFile', ['name', 'content']) + + +PLAY_IN_THE_PLACE = PlayFile('playbook.yml', u''' +- hosts: all + roles: + - include_in_the_place +''') + +PLAY_RELATIVE = PlayFile('playbook.yml', u''' +- hosts: all + roles: + - include_relative +''') + +PLAY_MISS_INCLUDE = PlayFile('playbook.yml', u''' +- hosts: all + roles: + - include_miss +''') + +PLAY_ROLE_INCLUDED_IN_THE_PLACE = PlayFile('roles/include_in_the_place/tasks/main.yml', u''' +--- +- include_tasks: included_file.yml +''') + +PLAY_ROLE_INCLUDED_RELATIVE = PlayFile('roles/include_relative/tasks/main.yml', u''' +--- +- include_tasks: tasks/included_file.yml +''') + +PLAY_ROLE_INCLUDED_MISS = PlayFile('roles/include_miss/tasks/main.yml', u''' +--- +- include_tasks: tasks/noexist_file.yml +''') + +PLAY_INCLUDED_IN_THE_PLACE = PlayFile('roles/include_in_the_place/tasks/included_file.yml', u''' +- debug: + msg: 'was found & included' +''') + +PLAY_INCLUDED_RELATIVE = PlayFile('roles/include_relative/tasks/included_file.yml', u''' +- debug: + msg: 'was found & included' +''') + + +@pytest.fixture +def play_file_path(tmp_path): + p = tmp_path / 'playbook.yml' + return str(p) + + +@pytest.fixture +def runner(play_file_path, default_rules_collection): + return Runner(default_rules_collection, play_file_path, [], [], []) + + +@pytest.fixture +def _play_files(tmp_path, request): + if request.param is None: + return + for play_file in request.param: + print(play_file.name) + p = tmp_path / play_file.name + os.makedirs(os.path.dirname(p), exist_ok=True) + p.write_text(play_file.content) + + +@pytest.mark.parametrize( + '_play_files', + ( + pytest.param([PLAY_MISS_INCLUDE, + PLAY_ROLE_INCLUDED_MISS], + id='no exist file include'), + ), + indirect=['_play_files'] +) +@pytest.mark.usefixtures('_play_files') +def test_cases_warning_message(runner, caplog): + runner.run() + noexist_message_count = 0 + + for record in caplog.records: + print(record) + if "Couldn't open" in str(record): + noexist_message_count += 1 + + assert noexist_message_count == 3 # 3 retries + + +@pytest.mark.parametrize( + '_play_files', + ( + pytest.param([PLAY_IN_THE_PLACE, + PLAY_ROLE_INCLUDED_IN_THE_PLACE, + PLAY_INCLUDED_IN_THE_PLACE], + id='in the place include'), + pytest.param([PLAY_RELATIVE, + PLAY_ROLE_INCLUDED_RELATIVE, + PLAY_INCLUDED_RELATIVE], + id='relative include') + ), + indirect=['_play_files'] +) +@pytest.mark.usefixtures('_play_files') +def test_cases_that_do_not_report(runner, caplog): + runner.run() + noexist_message_count = 0 + + for record in caplog.records: + if "Couldn't open" in str(record): + noexist_message_count += 1 + + assert noexist_message_count == 0 diff --git a/test/TestIncludeMissingFileRule.py b/test/TestIncludeMissingFileRule.py new file mode 100644 index 0000000..7248fdc --- /dev/null +++ b/test/TestIncludeMissingFileRule.py @@ -0,0 +1,88 @@ +from collections import namedtuple + +import pytest + +from ansiblelint.runner import Runner + +PlayFile = namedtuple('PlayFile', ['name', 'content']) + + +PLAY_INCLUDING_PLAIN = PlayFile('playbook.yml', u''' +- hosts: all + tasks: + - include: some_file.yml +''') + +PLAY_INCLUDING_JINJA2 = PlayFile('playbook.yml', u''' +- hosts: all + tasks: + - include: "{{ some_path }}/some_file.yml" +''') + +PLAY_INCLUDING_NOQA = PlayFile('playbook.yml', u''' +- hosts: all + tasks: + - include: some_file.yml # noqa 505 +''') + +PLAY_INCLUDED = PlayFile('some_file.yml', u''' +- debug: + msg: 'was found & included' +''') + +PLAY_HAVING_TASK = PlayFile('playbook.yml', u''' +- name: Play + hosts: all + pre_tasks: + tasks: + - name: Ping + ping: +''') + + +@pytest.fixture +def play_file_path(tmp_path): + p = tmp_path / 'playbook.yml' + return str(p) + + +@pytest.fixture +def runner(play_file_path, default_rules_collection): + return Runner(default_rules_collection, play_file_path, [], [], []) + + +@pytest.fixture +def _play_files(tmp_path, request): + if request.param is None: + return + for play_file in request.param: + p = tmp_path / play_file.name + p.write_text(play_file.content) + + +@pytest.mark.parametrize( + '_play_files', (pytest.param([PLAY_INCLUDING_PLAIN], id='referenced file missing'), ), + indirect=['_play_files'] +) +@pytest.mark.usefixtures('_play_files') +def test_include_file_missing(runner): + results = str(runner.run()) + assert 'referenced missing file in' in results + assert 'playbook.yml' in results + assert 'some_file.yml' in results + + +@pytest.mark.parametrize( + '_play_files', + ( + pytest.param([PLAY_INCLUDING_PLAIN, PLAY_INCLUDED], id='File Exists'), + pytest.param([PLAY_INCLUDING_JINJA2], id='JINJA2 in reference'), + pytest.param([PLAY_INCLUDING_NOQA], id='NOQA was used'), + pytest.param([PLAY_HAVING_TASK], id='Having a task') + ), + indirect=['_play_files'] +) +@pytest.mark.usefixtures('_play_files') +def test_cases_that_do_not_report(runner): + results = str(runner.run()) + assert 'referenced missing file in' not in results diff --git a/test/TestLineNumber.py b/test/TestLineNumber.py new file mode 100644 index 0000000..9355daa --- /dev/null +++ b/test/TestLineNumber.py @@ -0,0 +1,36 @@ +# Copyright (c) 2020 Albin Vass <albin.vass@gmail.com> +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +from ansiblelint.rules.SudoRule import SudoRule + +TEST_TASKLIST = """ +- debug: + msg: test + +- command: echo test + sudo: true +""" + + +def test_rule_linenumber(monkeypatch): + """Check that SudoRule offense contains a line number.""" + rule = SudoRule() + matches = rule.matchyaml(dict(path="", type='tasklist'), TEST_TASKLIST) + assert matches[0].linenumber == 5 diff --git a/test/TestLineTooLong.py b/test/TestLineTooLong.py new file mode 100644 index 0000000..be8c6f7 --- /dev/null +++ b/test/TestLineTooLong.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.LineTooLongRule import LineTooLongRule +from ansiblelint.testing import RunFromText + +LONG_LINE = ''' +- name: task example + debug: + msg: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua tempor incididunt ut labore et dolore' +''' # noqa 501 + + +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)) diff --git a/test/TestLintRule.py b/test/TestLintRule.py new file mode 100644 index 0000000..7377443 --- /dev/null +++ b/test/TestLintRule.py @@ -0,0 +1,45 @@ +# Copyright (c) 2013-2014 Will Thames <will@thames.id.au> +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from .rules import EMatcherRule, UnsetVariableMatcherRule + + +class TestRule(unittest.TestCase): + + def test_rule_matching(self): + text = "" + filename = 'test/ematchtest.yml' + with open(filename) as f: + text = f.read() + ematcher = EMatcherRule.EMatcherRule() + matches = ematcher.matchlines(dict(path=filename, type='playbooks'), text) + self.assertEqual(len(matches), 3) + + def test_rule_postmatching(self): + text = "" + filename = 'test/bracketsmatchtest.yml' + with open(filename) as f: + text = f.read() + rule = UnsetVariableMatcherRule.UnsetVariableMatcherRule() + matches = rule.matchlines(dict(path=filename, type='playbooks'), text) + self.assertEqual(len(matches), 2) diff --git a/test/TestLocalContent.py b/test/TestLocalContent.py new file mode 100644 index 0000000..e78aab4 --- /dev/null +++ b/test/TestLocalContent.py @@ -0,0 +1,42 @@ +"""Test playbooks with local content.""" +import pytest + +from ansiblelint.runner import Runner + + +def test_local_collection(default_rules_collection): + """Assures local collections are found.""" + playbook_path = 'test/local-content/test-collection.yml' + runner = Runner(default_rules_collection, playbook_path, [], [], []) + results = runner.run() + + assert len(runner.playbooks) == 1 + assert len(results) == 0 + + +def test_roles_local_content(default_rules_collection): + """Assures local content in roles is found.""" + playbook_path = 'test/local-content/test-roles-success/test.yml' + runner = Runner(default_rules_collection, playbook_path, [], [], []) + results = runner.run() + + assert len(runner.playbooks) == 4 + assert len(results) == 0 + + +def test_roles_local_content_failure(default_rules_collection): + """Assures local content in roles is found, even if Ansible itself has trouble.""" + playbook_path = 'test/local-content/test-roles-failed/test.yml' + runner = Runner(default_rules_collection, playbook_path, [], [], []) + results = runner.run() + + assert len(runner.playbooks) == 4 + assert len(results) == 0 + + +def test_roles_local_content_failure_complete(default_rules_collection): + """Role with local content that is not found.""" + playbook_path = 'test/local-content/test-roles-failed-complete/test.yml' + runner = Runner(default_rules_collection, playbook_path, [], [], []) + with pytest.raises(SystemExit, match="^3$"): + runner.run() diff --git a/test/TestMatchError.py b/test/TestMatchError.py new file mode 100644 index 0000000..f17d865 --- /dev/null +++ b/test/TestMatchError.py @@ -0,0 +1,178 @@ +"""Tests for MatchError.""" + +import operator + +import pytest + +from ansiblelint.errors import MatchError +from ansiblelint.rules import AnsibleLintRule +from ansiblelint.rules.AlwaysRunRule import AlwaysRunRule +from ansiblelint.rules.BecomeUserWithoutBecomeRule import BecomeUserWithoutBecomeRule + + +class DummyTestObject: + """A dummy object for equality tests.""" + + def __repr__(self): + """Return a dummy object representation for parmetrize.""" + return '{self.__class__.__name__}()'.format(self=self) + + def __eq__(self, other): + """Report the equality check failure with any object.""" + return False + + def __ne__(self, other): + """Report the confirmation of inequality with any object.""" + return True + + +class DummySentinelTestObject: + """A dummy object for equality protocol tests with sentinel.""" + + def __eq__(self, other): + """Return sentinel as result of equality check w/ anything.""" + return 'EQ_SENTINEL' + + def __ne__(self, other): + """Return sentinel as result of inequality check w/ anything.""" + return 'NE_SENTINEL' + + def __lt__(self, other): + """Return sentinel as result of less than check w/ anything.""" + return 'LT_SENTINEL' + + def __gt__(self, other): + """Return sentinel as result of greater than chk w/ anything.""" + return 'GT_SENTINEL' + + +@pytest.mark.parametrize( + ('left_match_error', 'right_match_error'), + ( + (MatchError("foo"), MatchError("foo")), + (MatchError("a", details="foo"), MatchError("a", details="foo")), + ), +) +def test_matcherror_compare(left_match_error, right_match_error): + """Check that MatchError instances with similar attrs are equivalent.""" + assert left_match_error == right_match_error + + +class AnsibleLintRuleWithStringId(AnsibleLintRule): + id = "ANSIBLE200" + + +def test_matcherror_invalid(): + """Ensure that MatchError requires message or rule.""" + expected_err = r"^MatchError\(\) missing a required argument: one of 'message' or 'rule'$" + with pytest.raises(TypeError, match=expected_err): + MatchError() + + +@pytest.mark.parametrize( + ('left_match_error', 'right_match_error'), ( + # sorting by message + (MatchError("z"), MatchError("a")), + # filenames takes priority in sorting + (MatchError("a", filename="b"), MatchError("a", filename="a")), + # rule id 501 > rule id 101 + (MatchError(rule=BecomeUserWithoutBecomeRule), MatchError(rule=AlwaysRunRule)), + # rule id "200" > rule id 101 + (MatchError(rule=AnsibleLintRuleWithStringId), MatchError(rule=AlwaysRunRule)), + # details are taken into account + (MatchError("a", details="foo"), MatchError("a", details="bar")), + )) +class TestMatchErrorCompare: + + def test_match_error_less_than(self, left_match_error, right_match_error): + """Check 'less than' protocol implementation in MatchError.""" + assert right_match_error < left_match_error + + def test_match_error_greater_than(self, left_match_error, right_match_error): + """Check 'greater than' protocol implementation in MatchError.""" + assert left_match_error > right_match_error + + def test_match_error_not_equal(self, left_match_error, right_match_error): + """Check 'not equals' protocol implementation in MatchError.""" + assert left_match_error != right_match_error + + +@pytest.mark.parametrize( + 'other', + ( + None, + "foo", + 42, + Exception("foo"), + ), + ids=repr, +) +@pytest.mark.parametrize( + ('operation', 'operator_char'), + ( + pytest.param(operator.le, '<=', id='<='), + pytest.param(operator.gt, '>', id='>'), + ), +) +def test_matcherror_compare_no_other_fallback(other, operation, operator_char): + """Check that MatchError comparison with other types causes TypeError.""" + expected_error = ( + r'^(' + r'unsupported operand type\(s\) for {operator!s}:|' + r"'{operator!s}' not supported between instances of" + r") 'MatchError' and '{other_type!s}'$". + format(other_type=type(other).__name__, operator=operator_char) + ) + with pytest.raises(TypeError, match=expected_error): + operation(MatchError("foo"), other) + + +@pytest.mark.parametrize( + 'other', + ( + None, + 'foo', + 42, + Exception('foo'), + DummyTestObject(), + ), + ids=repr, +) +@pytest.mark.parametrize( + ('operation', 'expected_value'), + ( + (operator.eq, False), + (operator.ne, True), + ), + ids=('==', '!=') +) +def test_matcherror_compare_with_other_fallback( + other, + operation, + expected_value, +): + """Check that MatchError comparison runs other types fallbacks.""" + assert operation(MatchError("foo"), other) is expected_value + + +@pytest.mark.parametrize( + ('operation', 'expected_value'), + ( + (operator.eq, 'EQ_SENTINEL'), + (operator.ne, 'NE_SENTINEL'), + # NOTE: these are swapped because when we do `x < y`, and `x.__lt__(y)` + # NOTE: returns `NotImplemented`, Python will reverse the check into + # NOTE: `y > x`, and so `y.__gt__(x) is called. + # Ref: https://docs.python.org/3/reference/datamodel.html#object.__lt__ + (operator.lt, 'GT_SENTINEL'), + (operator.gt, 'LT_SENTINEL'), + ), + ids=('==', '!=', '<', '>'), +) +def test_matcherror_compare_with_dummy_sentinel(operation, expected_value): + """Check that MatchError comparison runs other types fallbacks.""" + dummy_obj = DummySentinelTestObject() + # NOTE: This assertion abuses the CPython property to cache short string + # NOTE: objects because the identity check is more presice and we don't + # NOTE: want extra operator protocol methods to influence the test. + assert operation(MatchError("foo"), dummy_obj) is expected_value diff --git a/test/TestMetaChangeFromDefault.py b/test/TestMetaChangeFromDefault.py new file mode 100644 index 0000000..911553a --- /dev/null +++ b/test/TestMetaChangeFromDefault.py @@ -0,0 +1,33 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.MetaChangeFromDefaultRule import MetaChangeFromDefaultRule +from ansiblelint.testing import RunFromText + +DEFAULT_GALAXY_INFO = ''' +galaxy_info: + author: your name + description: your description + company: your company (optional) + license: license (GPLv2, CC-BY, etc) +''' + + +class TestMetaChangeFromDefault(unittest.TestCase): + collection = RulesCollection() + collection.register(MetaChangeFromDefaultRule()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + def test_default_galaxy_info(self): + results = self.runner.run_role_meta_main(DEFAULT_GALAXY_INFO) + self.assertIn("Should change default metadata: author", + str(results)) + self.assertIn("Should change default metadata: description", + str(results)) + self.assertIn("Should change default metadata: company", + str(results)) + self.assertIn("Should change default metadata: license", + str(results)) diff --git a/test/TestMetaMainHasInfo.py b/test/TestMetaMainHasInfo.py new file mode 100644 index 0000000..757a4df --- /dev/null +++ b/test/TestMetaMainHasInfo.py @@ -0,0 +1,94 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.MetaMainHasInfoRule import MetaMainHasInfoRule +from ansiblelint.testing import RunFromText + +NO_GALAXY_INFO = ''' +author: the author +description: this meta/main.yml has no galaxy_info +''' + +MISSING_INFO = ''' +galaxy_info: + # author: the author + description: Testing if meta contains values + company: Not applicable + + license: MIT + + # min_ansible_version: 2.5 + + platforms: + - name: Fedora + versions: + - 25 + - missing_name: No name + versions: + - 25 +''' + +BAD_TYPES = ''' +galaxy_info: + author: 007 + description: ['Testing meta'] + company: Not applicable + + license: MIT + + min_ansible_version: 2.5 + + platforms: Fedora +''' + +PLATFORMS_LIST_OF_STR = ''' +galaxy_info: + author: '007' + description: 'Testing meta' + company: Not applicable + + license: MIT + + min_ansible_version: 2.5 + + platforms: ['Fedora', 'EL'] +''' + + +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)) diff --git a/test/TestMetaVideoLinks.py b/test/TestMetaVideoLinks.py new file mode 100644 index 0000000..4d61891 --- /dev/null +++ b/test/TestMetaVideoLinks.py @@ -0,0 +1,35 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.MetaVideoLinksRule import MetaVideoLinksRule +from ansiblelint.testing import RunFromText + +META_VIDEO_LINKS = ''' +galaxy_info: + video_links: + - url: https://youtu.be/aWmRepTSFKs + title: Proper format + - https://youtu.be/this_is_not_a_dictionary + - my_bad_key: https://youtu.be/aWmRepTSFKs + title: This has a bad key + - url: www.myvid.com/vid + title: Bad format of url +''' + + +class TestMetaVideoLinks(unittest.TestCase): + collection = RulesCollection() + collection.register(MetaVideoLinksRule()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + def test_video_links(self): + results = self.runner.run_role_meta_main(META_VIDEO_LINKS) + self.assertIn("Expected item in 'video_links' to be a dictionary", + str(results)) + self.assertIn("'video_links' to contain only keys 'url' and 'title'", + str(results)) + self.assertIn("URL format 'www.myvid.com/vid' is not recognized", + str(results)) diff --git a/test/TestMissingFilePermissionsRule.py b/test/TestMissingFilePermissionsRule.py new file mode 100644 index 0000000..0a67ae1 --- /dev/null +++ b/test/TestMissingFilePermissionsRule.py @@ -0,0 +1,110 @@ +# Copyright (c) 2020 Sorin Sbarnea <sorin.sbarnea@gmail.com> +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +"""MissingFilePermissionsRule tests.""" +import pytest + +from ansiblelint.rules.MissingFilePermissionsRule import MissingFilePermissionsRule + +SUCCESS_TASKS = ''' +--- +- hosts: hosts + tasks: + - name: permissions not missing and numeric + file: + path: foo + mode: 0600 + - name: permissions missing while state is absent is fine + file: + path: foo + state: absent + - name: permissions missing while state is file (default) is fine + file: + path: foo + - name: permissions missing while state is link is fine + file: + path: foo2 + src: foo + state: link + - name: file edit when create is false + lineinfile: + path: foo + create: false + line: some content here + - name: replace should not require mode + replace: + path: foo +''' + +FAIL_TASKS = ''' +--- +- hosts: hosts + tasks: + - name: file does not allow preserve value for mode + file: + path: foo + mode: preserve + - name: permissions missing and might create file + file: + path: foo + state: touch + - name: permissions missing and might create directory + file: + path: foo + state: directory + - name: permissions needed if create is used + ini_file: + path: foo + create: true + - name: lineinfile when create is true + lineinfile: + path: foo + create: true + line: some content here + - name: replace does not allow preserve mode + replace: + path: foo + mode: preserve + - name: ini_file does not accept preserve mode + ini_file: + path: foo + create: true + mode: preserve +''' + + +@pytest.mark.parametrize('rule_runner', (MissingFilePermissionsRule, ), indirect=['rule_runner']) +def test_success(rule_runner): + """Validate that mode presence avoids hitting the rule.""" + results = rule_runner.run_playbook(SUCCESS_TASKS) + assert len(results) == 0 + + +@pytest.mark.parametrize('rule_runner', (MissingFilePermissionsRule, ), indirect=['rule_runner']) +def test_fail(rule_runner): + """Validate that missing mode triggers the rule.""" + results = rule_runner.run_playbook(FAIL_TASKS) + assert len(results) == 7 + assert results[0].linenumber == 5 + assert results[1].linenumber == 9 + assert results[2].linenumber == 13 + assert results[3].linenumber == 17 + assert results[4].linenumber == 21 + assert results[5].linenumber == 26 + assert results[6].linenumber == 30 diff --git a/test/TestNestedJinjaRule.py b/test/TestNestedJinjaRule.py new file mode 100644 index 0000000..f8367b0 --- /dev/null +++ b/test/TestNestedJinjaRule.py @@ -0,0 +1,208 @@ +# -*- coding: utf-8 -*- +# Author: Adrián Tóth <adtoth@redhat.com> +# +# Copyright (c) 2020, Red Hat, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +from collections import namedtuple + +import pytest + +from ansiblelint.runner import Runner + +PlayFile = namedtuple('PlayFile', ['name', 'content']) + + +FAIL_TASK_1LN = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: one-level nesting + set_fact: + var_one: "2*(1+2) is {{ 2 * {{ 1 + 2 }} }}" +''') + +FAIL_TASK_1LN_M = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: one-level multiline nesting + set_fact: + var_one_ml: > + 2*(1+2) is {{ 2 * + {{ 1 + 2 }} + }} +''') + +FAIL_TASK_2LN = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: two-level nesting + set_fact: + var_two: "2*(1+(3-1)) is {{ 2 * {{ 1 + {{ 3 - 1 }} }} }}" +''') + +FAIL_TASK_2LN_M = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: two-level multiline nesting + set_fact: + var_two_ml: > + 2*(1+(3-1)) is {{ 2 * + {{ 1 + + {{ 3 - 1 }} + }} }} +''') + +FAIL_TASK_W_5LN = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: five-level wild nesting + set_fact: + var_three_wld: "{{ {{ {{ {{ {{ 234 }} }} }} }} }}" +''') + +FAIL_TASK_W_5LN_M = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: five-level wild multiline nesting + set_fact: + var_three_wld_ml: > + {{ + {{ + {{ + {{ + {{ 234 }} + }} + }} + }} + }} +''') + +SUCCESS_TASK_P = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: non-nested example + set_fact: + var_one: "number for 'one' is {{ 2 * 1 }}" +''') + +SUCCESS_TASK_P_M = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: multiline non-nested example + set_fact: + var_one_ml: > + number for 'one' is {{ + 2 * 1 }} +''') + +SUCCESS_TASK_2P = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: nesting far from each other + set_fact: + var_two: "number for 'two' is {{ 2 * 1 }} and number for 'three' is {{ 4 - 1 }}" +''') + +SUCCESS_TASK_2P_M = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: multiline nesting far from each other + set_fact: + var_two_ml: > + number for 'two' is {{ 2 * 1 + }} and number for 'three' is {{ + 4 - 1 }} +''') + +SUCCESS_TASK_C_2P = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: nesting close to each other + set_fact: + var_three: "number for 'ten' is {{ 2 - 1 }}{{ 3 - 3 }}" +''') + +SUCCESS_TASK_C_2P_M = PlayFile('playbook.yml', ''' +- hosts: all + tasks: + - name: multiline nesting close to each other + set_fact: + var_three_ml: > + number for 'ten' is {{ + 2 - 1 + }}{{ 3 - 3 }} +''') + + +@pytest.fixture +def runner(tmp_path, default_rules_collection): + return Runner( + default_rules_collection, + str(tmp_path / 'playbook.yml'), + [], [], [], + ) + + +@pytest.fixture +def _playbook_file(tmp_path, request): + if request.param is None: + return + for play_file in request.param: + p = tmp_path / play_file.name + p.write_text(play_file.content) + + +@pytest.mark.parametrize( + '_playbook_file', + ( + pytest.param([FAIL_TASK_1LN], id='file includes one-level nesting'), + pytest.param([FAIL_TASK_1LN_M], id='file includes one-level multiline nesting'), + pytest.param([FAIL_TASK_2LN], id='file includes two-level nesting'), + pytest.param([FAIL_TASK_2LN_M], id='file includes two-level multiline nesting'), + pytest.param([FAIL_TASK_W_5LN], id='file includes five-level wild nesting'), + pytest.param([FAIL_TASK_W_5LN_M], id='file includes five-level wild multiline nesting'), + ), + indirect=['_playbook_file'], +) +@pytest.mark.usefixtures('_playbook_file') +def test_including_wrong_nested_jinja(runner): + rule_violations = runner.run() + assert rule_violations[0].rule.id == '207' + + +@pytest.mark.parametrize( + '_playbook_file', + ( + pytest.param([SUCCESS_TASK_P], id='file includes non-nested example'), + pytest.param([SUCCESS_TASK_P_M], id='file includes multiline non-nested example'), + pytest.param([SUCCESS_TASK_2P], id='file includes nesting far from each other'), + pytest.param([SUCCESS_TASK_2P_M], id='file includes multiline nesting far from each other'), + pytest.param([SUCCESS_TASK_C_2P], id='file includes nesting close to each other'), + pytest.param( + [SUCCESS_TASK_C_2P_M], + id='file includes multiline nesting close to each other', + ), + ), + indirect=['_playbook_file'], +) +@pytest.mark.usefixtures('_playbook_file') +def test_including_proper_nested_jinja(runner): + rule_violations = runner.run() + assert not rule_violations diff --git a/test/TestNoFormattingInWhenRule.py b/test/TestNoFormattingInWhenRule.py new file mode 100644 index 0000000..f9fde4a --- /dev/null +++ b/test/TestNoFormattingInWhenRule.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.NoFormattingInWhenRule import NoFormattingInWhenRule +from ansiblelint.runner import Runner + + +class TestNoFormattingInWhenRule(unittest.TestCase): + collection = RulesCollection() + + def setUp(self): + self.collection.register(NoFormattingInWhenRule()) + + def test_file_positive(self): + success = 'test/jinja2-when-success.yml' + good_runner = Runner(self.collection, success, [], [], []) + self.assertEqual([], good_runner.run()) + + def test_file_negative(self): + failure = 'test/jinja2-when-failure.yml' + bad_runner = Runner(self.collection, failure, [], [], []) + errs = bad_runner.run() + self.assertEqual(2, len(errs)) diff --git a/test/TestOctalPermissions.py b/test/TestOctalPermissions.py new file mode 100644 index 0000000..ed8c79c --- /dev/null +++ b/test/TestOctalPermissions.py @@ -0,0 +1,112 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.OctalPermissionsRule import OctalPermissionsRule +from ansiblelint.testing import RunFromText + +SUCCESS_TASKS = ''' +--- +- hosts: hosts + vars: + varset: varset + tasks: + - name: octal permissions test success (0600) + file: + path: foo + mode: 0600 + + - name: octal permissions test success (0000) + file: + path: foo + mode: 0000 + + - name: octal permissions test success (02000) + file: + path: bar + mode: 02000 + + - name: octal permissions test success (02751) + file: + path: bar + mode: 02751 + + - name: octal permissions test success (0777) + file: path=baz mode=0777 + + - name: octal permissions test success (0711) + file: path=baz mode=0711 + + - name: permissions test success (0777) + file: path=baz mode=u+rwx + + - name: octal permissions test success (777) + file: path=baz mode=777 + + - name: octal permissions test success (733) + file: path=baz mode=733 +''' + +FAIL_TASKS = ''' +--- +- hosts: hosts + vars: + varset: varset + tasks: + - name: octal permissions test fail (600) + file: + path: foo + mode: 600 + + - name: octal permissions test fail (710) + file: + path: foo + mode: 710 + + - name: octal permissions test fail (123) + file: + path: foo + mode: 123 + + - name: octal permissions test fail (2000) + file: + path: bar + mode: 2000 +''' + + +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) diff --git a/test/TestPackageIsNotLatest.py b/test/TestPackageIsNotLatest.py new file mode 100644 index 0000000..91bf24c --- /dev/null +++ b/test/TestPackageIsNotLatest.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.PackageIsNotLatestRule import PackageIsNotLatestRule +from ansiblelint.runner import Runner + + +class TestPackageIsNotLatestRule(unittest.TestCase): + collection = RulesCollection() + + def setUp(self): + self.collection.register(PackageIsNotLatestRule()) + + def test_package_not_latest_positive(self): + success = 'test/package-check-success.yml' + good_runner = Runner(self.collection, success, [], [], []) + self.assertEqual([], good_runner.run()) + + def test_package_not_latest_negative(self): + failure = 'test/package-check-failure.yml' + bad_runner = Runner(self.collection, failure, [], [], []) + errs = bad_runner.run() + self.assertEqual(3, len(errs)) diff --git a/test/TestRoleHandlers.py b/test/TestRoleHandlers.py new file mode 100644 index 0000000..9f38320 --- /dev/null +++ b/test/TestRoleHandlers.py @@ -0,0 +1,20 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.UseHandlerRatherThanWhenChangedRule import ( + UseHandlerRatherThanWhenChangedRule, +) +from ansiblelint.runner import Runner + + +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()) diff --git a/test/TestRoleNames.py b/test/TestRoleNames.py new file mode 100644 index 0000000..9441a50 --- /dev/null +++ b/test/TestRoleNames.py @@ -0,0 +1,82 @@ +"""Test the RoleNames rule.""" + +import pytest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.RoleNames import RoleNames +from ansiblelint.runner import Runner + +ROLE_NAME_VALID = 'test_role' + +TASK_MINIMAL = """ +- name: Some task + ping: +""" + +ROLE_MINIMAL = { + 'tasks': { + 'main.yml': TASK_MINIMAL + } +} +ROLE_META_EMPTY = { + 'meta': { + 'main.yml': '' + } +} + +ROLE_WITH_EMPTY_META = {**ROLE_MINIMAL, **ROLE_META_EMPTY} + +PLAY_INCLUDE_ROLE = f""" +- hosts: all + roles: + - {ROLE_NAME_VALID} +""" + + +@pytest.fixture +def test_rules_collection(): + """Instantiate a roles collection for tests.""" + collection = RulesCollection() + collection.register(RoleNames()) + return collection + + +def dict_to_files(parent_dir, file_dict): + """Write a nested dict to a file and directory structure below parent_dir.""" + for file, content in file_dict.items(): + if isinstance(content, dict): + directory = parent_dir / file + directory.mkdir() + dict_to_files(directory, content) + else: + (parent_dir / file).write_text(content) + + +@pytest.fixture +def playbook_path(request, tmp_path): + """Create a playbook with a role in a temporary directory.""" + playbook_text = request.param[0] + role_name = request.param[1] + role_layout = request.param[2] + role_path = tmp_path / role_name + role_path.mkdir() + dict_to_files(role_path, role_layout) + play_path = tmp_path / 'playbook.yml' + play_path.write_text(playbook_text) + return str(play_path) + + +@pytest.mark.parametrize(('playbook_path', 'messages'), ( + pytest.param((PLAY_INCLUDE_ROLE, ROLE_NAME_VALID, ROLE_WITH_EMPTY_META), + [], + id='ROLE_EMPTY_META', + ), +), indirect=('playbook_path',)) +def test_role_name(test_rules_collection, playbook_path, messages): + """Lint a playbook and compare the expected messages with the actual messages.""" + runner = Runner(test_rules_collection, playbook_path, [], [], []) + results = runner.run() + assert len(results) == len(messages) + results_text = str(results) + for message in messages: + assert message in results_text diff --git a/test/TestRoleRelativePath.py b/test/TestRoleRelativePath.py new file mode 100644 index 0000000..6c3163b --- /dev/null +++ b/test/TestRoleRelativePath.py @@ -0,0 +1,52 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.RoleRelativePath import RoleRelativePath +from ansiblelint.testing import RunFromText + +FAIL_TASKS = ''' +- name: template example + template: + src: ../templates/foo.j2 + dest: /etc/file.conf +- name: copy example + copy: + src: ../files/foo.conf + dest: /etc/foo.conf +- name: win_template example + win_template: + src: ../win_templates/file.conf.j2 + dest: file.conf +- name: win_copy example + win_copy: + src: ../files/foo.conf + dest: renamed-foo.conf +''' + +SUCCESS_TASKS = ''' +- name: content example with no src + copy: + content: '# This file was moved to /etc/other.conf' + dest: /etc/mine.conf +- name: content example with no src + win_copy: + content: '# This file was moved to /etc/other.conf' + dest: /etc/mine.conf +''' + + +class TestRoleRelativePath(unittest.TestCase): + collection = RulesCollection() + collection.register(RoleRelativePath()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + def test_fail(self): + results = self.runner.run_role_tasks_main(FAIL_TASKS) + self.assertEqual(4, len(results)) + + def test_success(self): + results = self.runner.run_role_tasks_main(SUCCESS_TASKS) + self.assertEqual(0, len(results)) diff --git a/test/TestRuleProperties.py b/test/TestRuleProperties.py new file mode 100644 index 0000000..41f40e0 --- /dev/null +++ b/test/TestRuleProperties.py @@ -0,0 +1,11 @@ +def test_serverity_valid(default_rules_collection): + valid_severity_values = [ + 'VERY_HIGH', + 'HIGH', + 'MEDIUM', + 'LOW', + 'VERY_LOW', + 'INFO', + ] + for rule in default_rules_collection: + assert rule.severity in valid_severity_values diff --git a/test/TestRulesCollection.py b/test/TestRulesCollection.py new file mode 100644 index 0000000..52d7dc6 --- /dev/null +++ b/test/TestRulesCollection.py @@ -0,0 +1,112 @@ +# Copyright (c) 2013-2014 Will Thames <will@thames.id.au> +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +import collections +import os + +import pytest + +from ansiblelint.rules import RulesCollection +from ansiblelint.testing import run_ansible_lint + + +@pytest.fixture +def test_rules_collection(): + return RulesCollection([os.path.abspath('./test/rules')]) + + +@pytest.fixture +def ematchtestfile(): + return dict(path='test/ematchtest.yml', type='playbook') + + +@pytest.fixture +def bracketsmatchtestfile(): + return dict(path='test/bracketsmatchtest.yml', type='playbook') + + +def test_load_collection_from_directory(test_rules_collection): + assert len(test_rules_collection) == 2 + + +def test_run_collection(test_rules_collection, ematchtestfile): + matches = test_rules_collection.run(ematchtestfile) + assert len(matches) == 3 + + +def test_tags(test_rules_collection, ematchtestfile, bracketsmatchtestfile): + 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) == 1 + matches = test_rules_collection.run(bracketsmatchtestfile, tags=['test2']) + assert len(matches) == 2 + + +def test_skip_tags(test_rules_collection, ematchtestfile, bracketsmatchtestfile): + matches = test_rules_collection.run(ematchtestfile, skip_list=['test1']) + assert len(matches) == 0 + matches = test_rules_collection.run(ematchtestfile, skip_list=['test2']) + assert len(matches) == 3 + matches = test_rules_collection.run(bracketsmatchtestfile, skip_list=['test1']) + assert len(matches) == 2 + matches = test_rules_collection.run(bracketsmatchtestfile, skip_list=['test2']) + assert len(matches) == 1 + + +def test_skip_id(test_rules_collection, ematchtestfile, bracketsmatchtestfile): + 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) == 1 + + +def test_skip_non_existent_id(test_rules_collection, ematchtestfile): + matches = test_rules_collection.run(ematchtestfile, skip_list=['DOESNOTEXIST']) + assert len(matches) == 3 + + +def test_no_duplicate_rule_ids(test_rules_collection): + real_rules = RulesCollection([os.path.abspath('./lib/ansiblelint/rules')]) + rule_ids = [rule.id for rule in real_rules] + assert not any(y > 1 for y in collections.Counter(rule_ids).values()) + + +def test_rich_rule_listing(): + """Test that rich list format output is rendered as a table. + + This check also offers the contract of having rule id, short and long + descriptions in the console output. + """ + rules_path = os.path.abspath('./test/rules') + result = run_ansible_lint("-r", rules_path, "-f", "rich", "-L") + assert result.returncode == 0 + + for rule in RulesCollection([rules_path]): + assert rule.id in result.stdout + assert rule.shortdesc in result.stdout + # description could wrap inside table, so we do not check full length + assert rule.description[:30] in result.stdout diff --git a/test/TestRunner.py b/test/TestRunner.py new file mode 100644 index 0000000..59740bd --- /dev/null +++ b/test/TestRunner.py @@ -0,0 +1,86 @@ +# Copyright (c) 2013-2014 Will Thames <will@thames.id.au> +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +import os + +import pytest + +from ansiblelint import formatters +from ansiblelint.cli import abspath +from ansiblelint.runner import Runner + +LOTS_OF_WARNINGS_PLAYBOOK = abspath('examples/lots_of_warnings.yml', os.getcwd()) + + +@pytest.mark.parametrize(('playbook', 'exclude', 'length'), ( + ('test/nomatchestest.yml', [], 0), + ('test/unicode.yml', [], 1), + (LOTS_OF_WARNINGS_PLAYBOOK, [LOTS_OF_WARNINGS_PLAYBOOK], 0), + ('test/block.yml', [], 0), + ('test/become.yml', [], 0), + ('test/emptytags.yml', [], 0), + ('test/contains_secrets.yml', [], 0), +)) +def test_runner(default_rules_collection, playbook, exclude, length): + runner = Runner(default_rules_collection, playbook, [], [], exclude) + + matches = runner.run() + + assert len(matches) == length + + +@pytest.mark.parametrize(('formatter_cls', 'format_kwargs'), ( + pytest.param(formatters.Formatter, {}, id='Formatter-plain'), + pytest.param(formatters.ParseableFormatter, + {'colored': True}, + id='ParseableFormatter-colored'), + pytest.param(formatters.QuietFormatter, + {'colored': True}, + id='QuietFormatter-colored'), + pytest.param(formatters.Formatter, + {'colored': True}, + id='Formatter-colored'), +)) +def test_runner_unicode_format(default_rules_collection, formatter_cls, format_kwargs): + formatter = formatter_cls(os.getcwd(), True) + runner = Runner(default_rules_collection, 'test/unicode.yml', [], [], []) + + matches = runner.run() + + formatter.format(matches[0], **format_kwargs) + + +@pytest.mark.parametrize('directory_name', ('test/', os.path.abspath('test'))) +def test_runner_with_directory(default_rules_collection, directory_name): + runner = Runner(default_rules_collection, directory_name, [], [], []) + assert list(runner.playbooks)[0][1] == 'role' + + +def test_files_not_scanned_twice(default_rules_collection): + checked_files = set() + + filename = os.path.abspath('test/common-include-1.yml') + runner = Runner(default_rules_collection, filename, [], [], [], 0, checked_files) + run1 = runner.run() + + filename = os.path.abspath('test/common-include-2.yml') + runner = Runner(default_rules_collection, filename, [], [], [], 0, checked_files) + run2 = runner.run() + + assert (len(run1) + len(run2)) == 1 diff --git a/test/TestShellWithoutPipefail.py b/test/TestShellWithoutPipefail.py new file mode 100644 index 0000000..c0c8545 --- /dev/null +++ b/test/TestShellWithoutPipefail.py @@ -0,0 +1,84 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.ShellWithoutPipefail import ShellWithoutPipefail +from ansiblelint.testing import RunFromText + +FAIL_TASKS = ''' +--- +- hosts: localhost + become: no + tasks: + - name: pipeline without pipefail + shell: false | cat + + - name: pipeline with or and pipe, no pipefail + shell: false || true | cat + + - shell: | + df | grep '/dev' +''' + +SUCCESS_TASKS = ''' +--- +- hosts: localhost + become: no + tasks: + - name: pipeline with pipefail + shell: set -o pipefail && false | cat + + - name: pipeline with pipefail, multi-line + shell: | + set -o pipefail + false | cat + + - name: pipeline with pipefail, complex set + shell: | + set -e -x -o pipefail + false | cat + + - name: pipeline with pipefail, complex set + shell: | + set -e -x -o pipefail + false | cat + + - name: pipeline with pipefail, complex set + shell: | + set -eo pipefail + false | cat + + - name: pipeline without pipefail, ignoring errors + shell: false | cat + ignore_errors: true + + - name: non-pipeline without pipefail + shell: "true" + + - name: command without pipefail + command: "true" + + - name: shell with or + shell: + false || true + + - shell: | + set -o pipefail + df | grep '/dev' +''' + + +class TestShellWithoutPipeFail(unittest.TestCase): + collection = RulesCollection() + collection.register(ShellWithoutPipefail()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + def test_fail(self): + results = self.runner.run_playbook(FAIL_TASKS) + self.assertEqual(3, len(results)) + + def test_success(self): + results = self.runner.run_playbook(SUCCESS_TASKS) + self.assertEqual(0, len(results)) diff --git a/test/TestSkipImportPlaybook.py b/test/TestSkipImportPlaybook.py new file mode 100644 index 0000000..66e8520 --- /dev/null +++ b/test/TestSkipImportPlaybook.py @@ -0,0 +1,35 @@ +import pytest + +from ansiblelint.runner import Runner + +IMPORTED_PLAYBOOK = ''' +- hosts: all + tasks: + - name: success + fail: msg="fail" + when: False +''' + +MAIN_PLAYBOOK = ''' +- hosts: all + + tasks: + - name: should be shell # noqa 305 301 + shell: echo lol + +- import_playbook: imported_playbook.yml +''' + + +@pytest.fixture +def playbook(tmp_path): + playbook_path = tmp_path / 'playbook.yml' + playbook_path.write_text(MAIN_PLAYBOOK) + (tmp_path / 'imported_playbook.yml').write_text(IMPORTED_PLAYBOOK) + return str(playbook_path) + + +def test_skip_import_playbook(default_rules_collection, playbook): + runner = Runner(default_rules_collection, playbook, [], [], []) + results = runner.run() + assert len(results) == 0 diff --git a/test/TestSkipInsideYaml.py b/test/TestSkipInsideYaml.py new file mode 100644 index 0000000..a2abde2 --- /dev/null +++ b/test/TestSkipInsideYaml.py @@ -0,0 +1,122 @@ +import pytest + +ROLE_TASKS = ''' +--- +- name: test 303 + command: git log + changed_when: False +- name: test 303 (skipped) + command: git log # noqa 303 + changed_when: False +''' + +ROLE_TASKS_WITH_BLOCK = ''' +--- +- name: bad git 1 # noqa 401 + action: git a=b c=d +- name: bad git 2 + action: git a=b c=d +- name: Block with rescue and always section + block: + - name: bad git 3 # noqa 401 + action: git a=b c=d + - name: bad git 4 + action: git a=b c=d + rescue: + - name: bad git 5 # noqa 401 + action: git a=b c=d + - name: bad git 6 + action: git a=b c=d + always: + - name: bad git 7 # noqa 401 + action: git a=b c=d + - name: bad git 8 + action: git a=b c=d +''' + +PLAYBOOK = ''' +- hosts: all + tasks: + - name: test 402 + action: hg + - name: test 402 (skipped) # noqa 402 + action: hg + + - name: test 401 and 501 + become_user: alice + action: git + - name: test 401 and 501 (skipped) # noqa 401 501 + become_user: alice + action: git + + - name: test 204 and 206 + get_url: + url: http://example.com/really_long_path/really_long_path/really_long_path/really_long_path/really_long_path/really_long_path/really_long_path/really_long_path/file.conf + dest: "{{dest_proj_path}}/foo.conf" + - name: test 204 and 206 (skipped) + get_url: + url: http://example.com/really_long_path/really_long_path/really_long_path/really_long_path/really_long_path/really_long_path/really_long_path/really_long_path/file.conf # noqa 204 + dest: "{{dest_proj_path}}/foo.conf" # noqa 206 + + - name: test 302 + command: creates=B chmod 644 A + - name: test 302 + command: warn=yes creates=B chmod 644 A + - name: test 302 (skipped via no warn) + command: warn=no creates=B chmod 644 A + - name: test 302 (skipped via skip_ansible_lint) + command: creates=B chmod 644 A + tags: + - skip_ansible_lint + + - name: test invalid action (skipped) + foo: bar + tags: + - skip_ansible_lint +''' + +ROLE_META = ''' +galaxy_info: # noqa 701 + author: your name # noqa 703 + description: missing min_ansible_version and platforms. author default not changed + license: MIT +''' + +ROLE_TASKS_WITH_BLOCK_BECOME = ''' +- hosts: + tasks: + - name: foo + become: true + block: + - name: bar + become_user: jonhdaa + command: "/etc/test.sh" +''' + + +def test_role_tasks(default_text_runner): + results = default_text_runner.run_role_tasks_main(ROLE_TASKS) + assert len(results) == 1 + + +def test_role_tasks_with_block(default_text_runner): + results = default_text_runner.run_role_tasks_main(ROLE_TASKS_WITH_BLOCK) + assert len(results) == 4 + + +@pytest.mark.parametrize( + ('playbook_src', 'results_num'), + ( + (PLAYBOOK, 7), + (ROLE_TASKS_WITH_BLOCK_BECOME, 0), + ), + ids=('generic', 'with block become inheritance'), +) +def test_playbook(default_text_runner, playbook_src, results_num): + results = default_text_runner.run_playbook(playbook_src) + assert len(results) == results_num + + +def test_role_meta(default_text_runner): + results = default_text_runner.run_role_meta_main(ROLE_META) + assert len(results) == 0 diff --git a/test/TestSkipPlaybookItems.py b/test/TestSkipPlaybookItems.py new file mode 100644 index 0000000..5564ff2 --- /dev/null +++ b/test/TestSkipPlaybookItems.py @@ -0,0 +1,99 @@ +import pytest + +PLAYBOOK_PRE_TASKS = ''' +- hosts: all + tasks: + - name: bad git 1 # noqa 401 + action: git a=b c=d + - name: bad git 2 + action: git a=b c=d + pre_tasks: + - name: bad git 3 # noqa 401 + action: git a=b c=d + - name: bad git 4 + action: git a=b c=d +''' + +PLAYBOOK_POST_TASKS = ''' +- hosts: all + tasks: + - name: bad git 1 # noqa 401 + action: git a=b c=d + - name: bad git 2 + action: git a=b c=d + post_tasks: + - name: bad git 3 # noqa 401 + action: git a=b c=d + - name: bad git 4 + action: git a=b c=d +''' + +PLAYBOOK_HANDLERS = ''' +- hosts: all + tasks: + - name: bad git 1 # noqa 401 + action: git a=b c=d + - name: bad git 2 + action: git a=b c=d + handlers: + - name: bad git 3 # noqa 401 + action: git a=b c=d + - name: bad git 4 + action: git a=b c=d +''' + +PLAYBOOK_TWO_PLAYS = ''' +- hosts: all + tasks: + - name: bad git 1 # noqa 401 + action: git a=b c=d + - name: bad git 2 + action: git a=b c=d + +- hosts: all + tasks: + - name: bad git 3 # noqa 401 + action: git a=b c=d + - name: bad git 4 + action: git a=b c=d +''' + +PLAYBOOK_WITH_BLOCK = ''' +- hosts: all + tasks: + - name: bad git 1 # noqa 401 + action: git a=b c=d + - name: bad git 2 + action: git a=b c=d + - name: Block with rescue and always section + block: + - name: bad git 3 # noqa 401 + action: git a=b c=d + - name: bad git 4 + action: git a=b c=d + rescue: + - name: bad git 5 # noqa 401 + action: git a=b c=d + - name: bad git 6 + action: git a=b c=d + always: + - name: bad git 7 # noqa 401 + action: git a=b c=d + - name: bad git 8 + action: git a=b c=d +''' + + +@pytest.mark.parametrize(('playbook', 'length'), ( + pytest.param(PLAYBOOK_PRE_TASKS, 2, id='PRE_TASKS'), + pytest.param(PLAYBOOK_POST_TASKS, 2, id='POST_TASKS'), + pytest.param(PLAYBOOK_HANDLERS, 2, id='HANDLERS'), + pytest.param(PLAYBOOK_TWO_PLAYS, 2, id='TWO_PLAYS'), + pytest.param(PLAYBOOK_WITH_BLOCK, 4, id='WITH_BLOCK'), +)) +def test_pre_tasks(default_text_runner, playbook, length): + # When + results = default_text_runner.run_playbook(playbook) + + # Then + assert len(results) == length diff --git a/test/TestSudoRule.py b/test/TestSudoRule.py new file mode 100644 index 0000000..a105854 --- /dev/null +++ b/test/TestSudoRule.py @@ -0,0 +1,67 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.SudoRule import SudoRule +from ansiblelint.testing import RunFromText + +ROLE_2_ERRORS = ''' +- name: test + debug: + msg: 'test message' + sudo: yes + sudo_user: nobody +''' + +ROLE_0_ERRORS = ''' +- name: test + debug: + msg: 'test message' + become: yes + become_user: somebody +''' + +PLAY_4_ERRORS = ''' +- hosts: all + sudo: yes + sudo_user: somebody + tasks: + - name: test + debug: + msg: 'test message' + sudo: yes + sudo_user: nobody +''' + +PLAY_1_ERROR = ''' +- hosts: all + tasks: + - name: test + debug: + msg: 'test message' + sudo: yes +''' + + +class TestSudoRule(unittest.TestCase): + collection = RulesCollection() + collection.register(SudoRule()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + def test_run_role_fail(self): + results = self.runner.run_role_tasks_main(ROLE_2_ERRORS) + self.assertEqual(2, len(results)) + + def test_run_role_pass(self): + results = self.runner.run_role_tasks_main(ROLE_0_ERRORS) + self.assertEqual(0, len(results)) + + def test_play_root_and_task_fail(self): + results = self.runner.run_playbook(PLAY_4_ERRORS) + self.assertEqual(4, len(results)) + + def test_play_task_fail(self): + results = self.runner.run_playbook(PLAY_1_ERROR) + self.assertEqual(1, len(results)) diff --git a/test/TestTaskHasName.py b/test/TestTaskHasName.py new file mode 100644 index 0000000..3a35f29 --- /dev/null +++ b/test/TestTaskHasName.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.TaskHasNameRule import TaskHasNameRule +from ansiblelint.runner import Runner + + +class TestTaskHasNameRule(unittest.TestCase): + collection = RulesCollection() + + def setUp(self): + self.collection.register(TaskHasNameRule()) + + def test_file_positive(self): + success = 'test/task-has-name-success.yml' + good_runner = Runner(self.collection, success, [], [], []) + self.assertEqual([], good_runner.run()) + + def test_file_negative(self): + failure = 'test/task-has-name-failure.yml' + bad_runner = Runner(self.collection, failure, [], [], []) + errs = bad_runner.run() + self.assertEqual(2, len(errs)) diff --git a/test/TestTaskIncludes.py b/test/TestTaskIncludes.py new file mode 100644 index 0000000..a3506bd --- /dev/null +++ b/test/TestTaskIncludes.py @@ -0,0 +1,34 @@ +import pytest + +from ansiblelint.runner import Runner + + +@pytest.mark.parametrize( + ('filename', 'playbooks_count'), + ( + pytest.param('blockincludes', 4, id='block included tasks'), + pytest.param( + 'blockincludes2', 4, + id='block included tasks with rescue and always', + ), + pytest.param('taskincludes', 4, id='included tasks'), + pytest.param( + 'taskincludes_2_4_style', 4, + id='include tasks 2.4 style', + ), + pytest.param('taskimports', 4, id='import tasks 2 4 style'), + pytest.param( + 'include-in-block', 3, + id='include tasks with block include', + ), + pytest.param( + 'include-import-tasks-in-role', 4, + id='include tasks in role', + ), + ), +) +def test_included_tasks(default_rules_collection, filename, playbooks_count): + playbook_path = 'test/{filename}.yml'.format(**locals()) + runner = Runner(default_rules_collection, playbook_path, [], [], []) + runner.run() + assert len(runner.playbooks) == playbooks_count diff --git a/test/TestTaskNoLocalAction.py b/test/TestTaskNoLocalAction.py new file mode 100644 index 0000000..74be24c --- /dev/null +++ b/test/TestTaskNoLocalAction.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.TaskNoLocalAction import TaskNoLocalAction +from ansiblelint.testing import RunFromText + +TASK_LOCAL_ACTION = ''' +- name: task example + local_action: + module: boto3_facts +''' + + +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)) diff --git a/test/TestUseCommandInsteadOfShell.py b/test/TestUseCommandInsteadOfShell.py new file mode 100644 index 0000000..d7e44a2 --- /dev/null +++ b/test/TestUseCommandInsteadOfShell.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.UseCommandInsteadOfShellRule import UseCommandInsteadOfShellRule +from ansiblelint.runner import Runner + + +class TestUseCommandInsteadOfShell(unittest.TestCase): + collection = RulesCollection() + + def setUp(self): + self.collection.register(UseCommandInsteadOfShellRule()) + + def test_file_positive(self): + success = 'test/command-instead-of-shell-success.yml' + good_runner = Runner(self.collection, success, [], [], []) + self.assertEqual([], good_runner.run()) + + def test_file_negative(self): + failure = 'test/command-instead-of-shell-failure.yml' + bad_runner = Runner(self.collection, failure, [], [], []) + errs = bad_runner.run() + self.assertEqual(2, len(errs)) diff --git a/test/TestUseHandlerRatherThanWhenChanged.py b/test/TestUseHandlerRatherThanWhenChanged.py new file mode 100644 index 0000000..5306e2f --- /dev/null +++ b/test/TestUseHandlerRatherThanWhenChanged.py @@ -0,0 +1,88 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.UseHandlerRatherThanWhenChangedRule import ( + UseHandlerRatherThanWhenChangedRule, +) +from ansiblelint.testing import RunFromText + +SUCCESS_TASKS = ''' +- name: print helpful error message + debug: + var: result + when: result.failed + +- name: do something when hello is output + debug: + msg: why isn't this a handler + when: result.stdout == "hello" + +- name: never actually debug + debug: + var: result + when: False + +- name: Dont execute this step + debug: + msg: "debug message" + when: + - false + +- name: check when with a list + debug: + var: result + when: + - conditionA + - conditionB +''' + + +FAIL_TASKS = ''' +- name: execute command + command: echo hello + register: result + +- name: this should be a handler + debug: + msg: why isn't this a handler + when: result.changed + +- name: this should be a handler 2 + debug: + msg: why isn't this a handler + when: result|changed + +- name: this should be a handler 3 + debug: + msg: why isn't this a handler + when: result.changed == true + +- name: this should be a handler 4 + debug: + msg: why isn't this a handler + when: result['changed'] == true + +- name: this should be a handler 5 + debug: + msg: why isn't this a handler + when: + - result['changed'] == true + - another_condition +''' + + +class TestUseHandlerRatherThanWhenChanged(unittest.TestCase): + collection = RulesCollection() + collection.register(UseHandlerRatherThanWhenChangedRule()) + + def setUp(self): + self.runner = RunFromText(self.collection) + + def test_success(self): + results = self.runner.run_role_tasks_main(SUCCESS_TASKS) + self.assertEqual(0, len(results)) + + def test_fail(self): + results = self.runner.run_role_tasks_main(FAIL_TASKS) + self.assertEqual(5, len(results)) diff --git a/test/TestUsingBareVariablesIsDeprecated.py b/test/TestUsingBareVariablesIsDeprecated.py new file mode 100644 index 0000000..42c3b4d --- /dev/null +++ b/test/TestUsingBareVariablesIsDeprecated.py @@ -0,0 +1,24 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.UsingBareVariablesIsDeprecatedRule import UsingBareVariablesIsDeprecatedRule +from ansiblelint.runner import Runner + + +class TestUsingBareVariablesIsDeprecated(unittest.TestCase): + collection = RulesCollection() + + def setUp(self): + self.collection.register(UsingBareVariablesIsDeprecatedRule()) + + def test_file_positive(self): + success = 'test/using-bare-variables-success.yml' + good_runner = Runner(self.collection, success, [], [], []) + self.assertEqual([], good_runner.run()) + + def test_file_negative(self): + failure = 'test/using-bare-variables-failure.yml' + bad_runner = Runner(self.collection, failure, [], [], []) + errs = bad_runner.run() + self.assertEqual(14, len(errs)) diff --git a/test/TestUtils.py b/test/TestUtils.py new file mode 100644 index 0000000..58824b0 --- /dev/null +++ b/test/TestUtils.py @@ -0,0 +1,317 @@ +# -*- coding: utf-8 -*- + +# Copyright (c) 2013-2014 Will Thames <will@thames.id.au> +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +"""Tests for generic utilitary functions.""" + +import logging +import os +import os.path +import subprocess +import sys +from pathlib import Path + +import pytest + +from ansiblelint import cli, constants, utils +from ansiblelint.__main__ import initialize_logger +from ansiblelint.file_utils import normpath + + +@pytest.mark.parametrize(('string', 'expected_cmd', 'expected_args', 'expected_kwargs'), ( + pytest.param('', '', [], {}, id='blank'), + pytest.param('vars:', 'vars', [], {}, id='single_word'), + pytest.param('hello: a=1', 'hello', [], {'a': '1'}, id='string_module_and_arg'), + pytest.param('action: hello a=1', 'hello', [], {'a': '1'}, id='strips_action'), + pytest.param('action: whatever bobbins x=y z=x c=3', + 'whatever', + ['bobbins', 'x=y', 'z=x', 'c=3'], + {}, + id='more_than_one_arg'), + pytest.param('action: command chdir=wxy creates=zyx tar xzf zyx.tgz', + 'command', + ['tar', 'xzf', 'zyx.tgz'], + {'chdir': 'wxy', 'creates': 'zyx'}, + id='command_with_args'), +)) +def test_tokenize(string, expected_cmd, expected_args, expected_kwargs): + """Test that tokenize works for different input types.""" + (cmd, args, kwargs) = utils.tokenize(string) + assert cmd == expected_cmd + assert args == expected_args + assert kwargs == expected_kwargs + + +@pytest.mark.parametrize(('reference_form', 'alternate_forms'), ( + pytest.param(dict(name='hello', action='command chdir=abc echo hello world'), + (dict(name="hello", command="chdir=abc echo hello world"), ), + id='simple_command'), + pytest.param({'git': {'version': 'abc'}, 'args': {'repo': 'blah', 'dest': 'xyz'}}, + ({'git': {'version': 'abc', 'repo': 'blah', 'dest': 'xyz'}}, + {"git": 'version=abc repo=blah dest=xyz'}, + {"git": None, "args": {'repo': 'blah', 'dest': 'xyz', 'version': 'abc'}}, + ), + id='args') +)) +def test_normalize(reference_form, alternate_forms): + """Test that tasks specified differently are normalized same way.""" + normal_form = utils.normalize_task(reference_form, 'tasks.yml') + + for form in alternate_forms: + assert normal_form == utils.normalize_task(form, 'tasks.yml') + + +def test_normalize_complex_command(): + """Test that tasks specified differently are normalized same way.""" + task1 = dict(name="hello", action={'module': 'pip', + 'name': 'df', + 'editable': 'false'}) + task2 = dict(name="hello", pip={'name': 'df', + 'editable': 'false'}) + task3 = dict(name="hello", pip="name=df editable=false") + task4 = dict(name="hello", action="pip name=df editable=false") + assert utils.normalize_task(task1, 'tasks.yml') == utils.normalize_task(task2, 'tasks.yml') + assert utils.normalize_task(task2, 'tasks.yml') == utils.normalize_task(task3, 'tasks.yml') + assert utils.normalize_task(task3, 'tasks.yml') == utils.normalize_task(task4, 'tasks.yml') + + +def test_extract_from_list(): + """Check that tasks get extracted from blocks if present.""" + block = { + 'block': [{'tasks': {'name': 'hello', 'command': 'whoami'}}], + 'test_none': None, + 'test_string': 'foo', + } + blocks = [block] + + test_list = utils.extract_from_list(blocks, ['block']) + test_none = utils.extract_from_list(blocks, ['test_none']) + + assert list(block['block']) == test_list + assert list() == test_none + with pytest.raises(RuntimeError): + utils.extract_from_list(blocks, ['test_string']) + + +@pytest.mark.parametrize(('template', 'output'), ( + pytest.param('{{ playbook_dir }}', '/a/b/c', id='simple'), + pytest.param("{{ 'hello' | doesnotexist }}", + "{{ 'hello' | doesnotexist }}", + id='unknown_filter'), + pytest.param('{{ hello | to_json }}', + '{{ hello | to_json }}', + id='to_json_filter_on_undefined_variable'), + pytest.param('{{ hello | to_nice_yaml }}', + '{{ hello | to_nice_yaml }}', + id='to_nice_yaml_filter_on_undefined_variable'), +)) +def test_template(template, output): + """Verify that resolvable template vars and filters get rendered.""" + result = utils.template('/base/dir', template, dict(playbook_dir='/a/b/c')) + assert result == output + + +def test_task_to_str_unicode(): + """Ensure that extracting messages from tasks preserves Unicode.""" + task = dict(fail=dict(msg=u"unicode é ô à")) + result = utils.task_to_str(utils.normalize_task(task, 'filename.yml')) + assert result == u"fail msg=unicode é ô à" + + +@pytest.mark.parametrize('path', ( + pytest.param(Path('a/b/../'), id='pathlib.Path'), + pytest.param('a/b/../', id='str'), +)) +def test_normpath_with_path_object(path): + """Ensure that relative parent dirs are normalized in paths.""" + assert normpath(path) == "a" + + +def test_expand_path_vars(monkeypatch): + """Ensure that tilde and env vars are expanded in paths.""" + test_path = '/test/path' + monkeypatch.setenv('TEST_PATH', test_path) + assert utils.expand_path_vars('~') == os.path.expanduser('~') + assert utils.expand_path_vars('$TEST_PATH') == test_path + + +@pytest.mark.parametrize(('test_path', 'expected'), ( + pytest.param(Path('$TEST_PATH'), "/test/path", id='pathlib.Path'), + pytest.param('$TEST_PATH', "/test/path", id='str'), + pytest.param(' $TEST_PATH ', "/test/path", id='stripped-str'), + pytest.param('~', os.path.expanduser('~'), id='home'), +)) +def test_expand_paths_vars(test_path, expected, monkeypatch): + """Ensure that tilde and env vars are expanded in paths lists.""" + monkeypatch.setenv('TEST_PATH', '/test/path') + assert utils.expand_paths_vars([test_path]) == [expected] + + +@pytest.mark.parametrize( + ('reset_env_var', 'message_prefix'), + ( + ('PATH', + "Failed to locate command: "), + ('GIT_DIR', + "Failed to discover yaml files to lint using git: ") + ), + ids=('no Git installed', 'outside Git repository'), +) +def test_get_yaml_files_git_verbose( + reset_env_var, + message_prefix, + monkeypatch, + caplog +): + """Ensure that autodiscovery lookup failures are logged.""" + options = cli.get_config(['-v']) + initialize_logger(options.verbosity) + monkeypatch.setenv(reset_env_var, '') + utils.get_yaml_files(options) + + expected_info = ( + "ansiblelint.utils", + logging.INFO, + 'Discovering files to lint: git ls-files *.yaml *.yml') + + assert expected_info in caplog.record_tuples + assert any(m.startswith(message_prefix) for m in caplog.messages) + + +@pytest.mark.parametrize( + 'is_in_git', + (True, False), + ids=('in Git', 'outside Git'), +) +def test_get_yaml_files_silent(is_in_git, monkeypatch, capsys): + """Verify that no stderr output is displayed while discovering yaml files. + + (when the verbosity is off, regardless of the Git or Git-repo presence) + + Also checks expected number of files are detected. + """ + options = cli.get_config([]) + test_dir = Path(__file__).resolve().parent + lint_path = test_dir / 'roles' / 'test-role' + if not is_in_git: + monkeypatch.setenv('GIT_DIR', '') + + yaml_count = ( + len(list(lint_path.glob('**/*.yml'))) + len(list(lint_path.glob('**/*.yaml'))) + ) + + monkeypatch.chdir(str(lint_path)) + files = utils.get_yaml_files(options) + stderr = capsys.readouterr().err + assert not stderr, 'No stderr output is expected when the verbosity is off' + assert len(files) == yaml_count, ( + "Expected to find {yaml_count} yaml files in {lint_path}".format_map( + locals(), + ) + ) + + +def test_logger_debug(caplog): + """Test that the double verbosity arg causes logger to be DEBUG.""" + options = cli.get_config(['-vv']) + initialize_logger(options.verbosity) + + expected_info = ( + "ansiblelint.__main__", + logging.DEBUG, + 'Logging initialized to level 10', + ) + + assert expected_info in caplog.record_tuples + + +@pytest.mark.xfail +def test_cli_auto_detect(capfd): + """Test that run without arguments it will detect and lint the entire repository.""" + cmd = sys.executable, "-m", "ansiblelint", "-v", "-p", "--nocolor" + result = subprocess.run(cmd, check=False).returncode + + # We de expect to fail on our own repo due to test examples we have + # TODO(ssbarnea) replace it with exact return code once we document them + assert result != 0 + + out, err = capfd.readouterr() + + # Confirmation that it runs in auto-detect mode + assert "Discovering files to lint: git ls-files *.yaml *.yml" in err + # Expected failure to detect file type" + assert "Unknown file type: test/fixtures/unknown-type.yml" in err + # An expected rule match from our examples + assert "examples/roles/bobbins/tasks/main.yml:2: " \ + "[E401] Git checkouts must contain explicit version" in out + # assures that our .ansible-lint exclude was effective in excluding github files + assert "Unknown file type: .github/" not in out + # assures that we can parse playbooks as playbooks + assert "Unknown file type: test/test/always-run-success.yml" not in err + + +@pytest.mark.xfail +def test_is_playbook(): + """Verify that we can detect a playbook as a playbook.""" + assert utils.is_playbook("test/test/always-run-success.yml") + + +def test_auto_detect_exclude(monkeypatch): + """Verify that exclude option can be used to narrow down detection.""" + options = cli.get_config(['--exclude', 'foo']) + + def mockreturn(options): + return ['foo/playbook.yml', 'bar/playbook.yml'] + + monkeypatch.setattr(utils, 'get_yaml_files', mockreturn) + result = utils.get_playbooks_and_roles(options) + assert result == ['bar/playbook.yml'] + + +_DEFAULT_RULEDIRS = [constants.DEFAULT_RULESDIR] +_CUSTOM_RULESDIR = Path(__file__).parent / "custom_rules" +_CUSTOM_RULEDIRS = [ + str(_CUSTOM_RULESDIR / "example_inc"), + str(_CUSTOM_RULESDIR / "example_com") +] + + +@pytest.mark.parametrize(("user_ruledirs", "use_default", "expected"), ( + ([], True, _DEFAULT_RULEDIRS), + ([], False, _DEFAULT_RULEDIRS), + (_CUSTOM_RULEDIRS, True, _CUSTOM_RULEDIRS + _DEFAULT_RULEDIRS), + (_CUSTOM_RULEDIRS, False, _CUSTOM_RULEDIRS) +)) +def test_get_rules_dirs(user_ruledirs, use_default, expected): + """Test it returns expected dir lists.""" + assert utils.get_rules_dirs(user_ruledirs, use_default) == expected + + +@pytest.mark.parametrize(("user_ruledirs", "use_default", "expected"), ( + ([], True, sorted(_CUSTOM_RULEDIRS) + _DEFAULT_RULEDIRS), + ([], False, sorted(_CUSTOM_RULEDIRS) + _DEFAULT_RULEDIRS), + (_CUSTOM_RULEDIRS, True, + _CUSTOM_RULEDIRS + sorted(_CUSTOM_RULEDIRS) + _DEFAULT_RULEDIRS), + (_CUSTOM_RULEDIRS, False, _CUSTOM_RULEDIRS) +)) +def test_get_rules_dirs_with_custom_rules(user_ruledirs, use_default, expected, monkeypatch): + """Test it returns expected dir lists when custom rules exist.""" + monkeypatch.setenv(constants.CUSTOM_RULESDIR_ENVVAR, str(_CUSTOM_RULESDIR)) + assert utils.get_rules_dirs(user_ruledirs, use_default) == expected diff --git a/test/TestVariableHasSpaces.py b/test/TestVariableHasSpaces.py new file mode 100644 index 0000000..01b12c9 --- /dev/null +++ b/test/TestVariableHasSpaces.py @@ -0,0 +1,54 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.VariableHasSpacesRule import VariableHasSpacesRule +from ansiblelint.testing import RunFromText + +TASK_VARIABLES = ''' +- name: good variable format + debug: + msg: "{{ good_format }}" +- name: good variable format + debug: + msg: "Value: {{ good_format }}" +- name: jinja escaping allowed + debug: + msg: "{{ '{{' }}" +- name: jinja escaping allowed + shell: docker info --format '{{ '{{' }}json .Swarm.LocalNodeState{{ '}}' }}' | tr -d '"' +- name: jinja whitespace control allowed + debug: + msg: | + {{ good_format }}/ + {{- good_format }} + {{- good_format -}} +- name: bad variable format + debug: + msg: "{{bad_format}}" +- name: bad variable format + debug: + msg: "Value: {{ bad_format}}" +- name: bad variable format + debug: + msg: "{{bad_format }}" +- name: not a jinja variable + debug: + msg: "test" + example: "data = ${lookup{$local_part}lsearch{/etc/aliases}}" +- name: JSON inside jinja is valid + debug: + msg: "{{ {'test': {'subtest': variable}} }}" +''' + + +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)) diff --git a/test/TestWithSkipTagId.py b/test/TestWithSkipTagId.py new file mode 100644 index 0000000..129a00d --- /dev/null +++ b/test/TestWithSkipTagId.py @@ -0,0 +1,39 @@ +# pylint: disable=preferred-module # FIXME: remove once migrated per GH-725 +import unittest + +from ansiblelint.rules import RulesCollection +from ansiblelint.rules.TrailingWhitespaceRule import TrailingWhitespaceRule +from ansiblelint.runner import Runner + + +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()) diff --git a/test/__init__.py b/test/__init__.py new file mode 100644 index 0000000..124a757 --- /dev/null +++ b/test/__init__.py @@ -0,0 +1 @@ +"""Use ansiblelint.testing instead for test reusables.""" diff --git a/test/always-run-failure.yml b/test/always-run-failure.yml new file mode 100644 index 0000000..c9ff225 --- /dev/null +++ b/test/always-run-failure.yml @@ -0,0 +1,6 @@ +- hosts: localhost + + tasks: + - name: always_run is deprecated + debug: msg="always_run is deprecated" + always_run: yes diff --git a/test/always-run-success.yml b/test/always-run-success.yml new file mode 100644 index 0000000..30559e0 --- /dev/null +++ b/test/always-run-success.yml @@ -0,0 +1,6 @@ +- hosts: localhost + + tasks: + - name: always_run is deprecated + debug: msg="always_run is deprecated" + check_mode: yes diff --git a/test/bar.txt b/test/bar.txt new file mode 100644 index 0000000..e22f90b --- /dev/null +++ b/test/bar.txt @@ -0,0 +1 @@ +Bar file diff --git a/test/become-user-without-become-failure.yml b/test/become-user-without-become-failure.yml new file mode 100644 index 0000000..a4051f0 --- /dev/null +++ b/test/become-user-without-become-failure.yml @@ -0,0 +1,26 @@ +- hosts: localhost + name: become_user without become play + become_user: root + + tasks: + - debug: + msg: hello + +- hosts: localhost + + tasks: + - name: become_user without become task + command: whoami + become_user: postgres + +- hosts: localhost + + tasks: + - name: a block with become and become_user on different tasks + block: + - name: become + become: true + command: whoami + - name: become_user + become_user: postgres + command: whoami diff --git a/test/become-user-without-become-success.yml b/test/become-user-without-become-success.yml new file mode 100644 index 0000000..a8d64da --- /dev/null +++ b/test/become-user-without-become-success.yml @@ -0,0 +1,30 @@ +- hosts: localhost + become_user: root + become: true + + tasks: + - debug: + msg: hello + +- hosts: localhost + + tasks: + - command: whoami + become_user: postgres + become: true + +- hosts: localhost + become: true + + tasks: + - name: Accepts a become from higher scope + command: whoami + become_user: postgres + +- hosts: localhost + become_user: postgres + + tasks: + - name: Accepts a become from a lower scope + command: whoami + become: true diff --git a/test/become.yml b/test/become.yml new file mode 100644 index 0000000..f2ea524 --- /dev/null +++ b/test/become.yml @@ -0,0 +1,14 @@ +- hosts: all + + tasks: + - name: clone content repository + git: + repo: '{{ archive_services_repo_url }}' + dest: '/home/www' + accept_hostkey: yes + version: master + update: no + become: yes + become_user: nobody + notify: + - restart apache2 diff --git a/test/block.yml b/test/block.yml new file mode 100644 index 0000000..1aac26e --- /dev/null +++ b/test/block.yml @@ -0,0 +1,26 @@ +--- +- hosts: all + + pre_tasks: + - { include: 'doesnotexist.yml' } + + tasks: + - block: + - name: successful debug message + debug: msg='i execute normally' + - name: failure command + command: /bin/false + changed_when: False + - name: never reached debug message + debug: msg='i never execute, cause ERROR!' + rescue: + - name: exception debug message + debug: msg='I caught an error' + - name: another failure command + command: /bin/false + changed_when: False + - name: another missed debug message + debug: msg='I also never execute :-(' + always: + - name: always reached debug message + debug: msg="this always executes" diff --git a/test/blockincludes.yml b/test/blockincludes.yml new file mode 100644 index 0000000..5bea9be --- /dev/null +++ b/test/blockincludes.yml @@ -0,0 +1,13 @@ +--- +- hosts: webservers + vars: + varset: varset + tasks: + - block: + - include: nestedincludes.yml tags=nested + - block: + - include: "{{ varnotset }}.yml" + - block: + - include: "{{ varset }}.yml" + - block: + - include: "directory with spaces/main.yml" diff --git a/test/blockincludes2.yml b/test/blockincludes2.yml new file mode 100644 index 0000000..03d7a75 --- /dev/null +++ b/test/blockincludes2.yml @@ -0,0 +1,13 @@ +--- +- hosts: webservers + vars: + varset: varset + tasks: + - block: + - include: nestedincludes.yml tags=nested + - block: + - include: "{{ varnotset }}.yml" + rescue: + - include: "{{ varset }}.yml" + always: + - include: "directory with spaces/main.yml" diff --git a/test/brackets-do-not-match-test.yml b/test/brackets-do-not-match-test.yml new file mode 100644 index 0000000..dfa5ff8 --- /dev/null +++ b/test/brackets-do-not-match-test.yml @@ -0,0 +1,22 @@ +--- +- hosts: foo + roles: + - ../../../roles/base_os + - ../../../roles/repos + - { + role: ../../../roles/openshift_master, + oo_minion_ips: "{ hostvars['localhost'].oo_minion_ips | default(['']) }}", + oo_bind_ip: "{{ hostvars[inventory_hostname].ansible_eth0.ipv4.address | default(['']) }}" + } + - ../../../roles/pods + +- name: "Set Origin specific facts on localhost (for later use)" + hosts: localhost + gather_facts: no + tasks: + - name: Setting oo_minion_ips fact on localhost + set_fact: + oo_minion_ips: "{{ hostvars + | oo_select_keys(groups['tag_env-host-type-' + oo_env + '-openshift-minion']) + | oo_collect(attribute='ansible_eth0.ipv4.address') }" + when: groups['tag_env-host-type-' + oo_env + '-openshift-minion'] is defined diff --git a/test/bracketsmatchtest.yml b/test/bracketsmatchtest.yml new file mode 100644 index 0000000..46b213d --- /dev/null +++ b/test/bracketsmatchtest.yml @@ -0,0 +1,3 @@ +val1: "{{dest}}" +val2: worry +val3: "{{victory}}" diff --git a/test/command-check-failure.yml b/test/command-check-failure.yml new file mode 100644 index 0000000..d58c09d --- /dev/null +++ b/test/command-check-failure.yml @@ -0,0 +1,11 @@ +- hosts: localhost + tasks: + - name: command without checks + command: echo blah + args: + chdir: X + + - name: shell without checks + shell: echo blah + args: + chdir: X diff --git a/test/command-check-success.yml b/test/command-check-success.yml new file mode 100644 index 0000000..24266ff --- /dev/null +++ b/test/command-check-success.yml @@ -0,0 +1,61 @@ +- hosts: localhost + tasks: + - name: command with creates check + command: echo blah + args: + creates: Z + + - name: command with removes check + command: echo blah + args: + removes: Z + + - name: command with changed_when + command: echo blah + changed_when: False + + - name: command with inline creates + command: creates=Z echo blah + + - name: command with inline removes + command: removes=Z echo blah + + - name: command with cmd + command: + cmd: + echo blah + args: + creates: Z + + - name: shell with creates check + shell: echo blah + args: + creates: Z + + - name: shell with removes check + shell: echo blah + args: + removes: Z + + - name: shell with changed_when + shell: echo blah + changed_when: False + + - name: shell with inline creates + shell: creates=Z echo blah + + - name: shell with inline removes + shell: removes=Z echo blah + + - name: shell with cmd + shell: + cmd: + echo blah + args: + creates: Z + +- hosts: localhost + handlers: + - name: restart something + command: do something + - include: included-handlers.yml diff --git a/test/command-instead-of-shell-failure.yml b/test/command-instead-of-shell-failure.yml new file mode 100644 index 0000000..7b8d829 --- /dev/null +++ b/test/command-instead-of-shell-failure.yml @@ -0,0 +1,8 @@ +--- +- hosts: localhost + tasks: + - name: shell no pipe + shell: echo hello + + - name: shell with jinja filter + shell: echo {{"hello"|upper}} diff --git a/test/command-instead-of-shell-success.yml b/test/command-instead-of-shell-success.yml new file mode 100644 index 0000000..410ff97 --- /dev/null +++ b/test/command-instead-of-shell-success.yml @@ -0,0 +1,37 @@ +- hosts: localhost + tasks: + - name: shell with pipe + shell: echo hello | true + + - name: shell with redirect + shell: echo hello > /tmp/hello + + - name: chain two shell commands + shell: echo hello && echo goodbye + + - name: run commands in succession + shell: echo hello ; echo goodbye + + - name: use variables + shell: echo $HOME $USER + + - name: use * for globbing + shell: ls foo* + + - name: use ? for globbing + shell: ls foo? + + - name: use [] for globbing + shell: ls foo[1,2,3] + + - name: use shell generator + shell: ls foo{.txt,.xml} + + - name: use backticks + shell: ls `ls foo*` + + - name: use shell with cmd + shell: + cmd: | + set -x + ls foo? diff --git a/test/common-include-1.yml b/test/common-include-1.yml new file mode 100644 index 0000000..287df85 --- /dev/null +++ b/test/common-include-1.yml @@ -0,0 +1,4 @@ +--- +- hosts: webservers + tasks: + - include: included-with-lint.yml diff --git a/test/common-include-2.yml b/test/common-include-2.yml new file mode 100644 index 0000000..287df85 --- /dev/null +++ b/test/common-include-2.yml @@ -0,0 +1,4 @@ +--- +- hosts: webservers + tasks: + - include: included-with-lint.yml diff --git a/test/contains_secrets.yml b/test/contains_secrets.yml new file mode 100644 index 0000000..aed5a0e --- /dev/null +++ b/test/contains_secrets.yml @@ -0,0 +1,14 @@ +- hosts: localhost + vars: + plain: hello123 + # just 'hello123' encrypted with 'letmein' for test purposes + secret: !vault | + $ANSIBLE_VAULT;1.1;AES256 + 63346434613163653866303630313238626164313961613935373137323639636333393338386232 + 3735313061316666343839343665383036623237353263310a623639336530383433343833653138 + 30393032393534316164613834393864616566646164363830316664623636643731383164376163 + 3736653037356435310a303533383533353739323834343637366438633766666163656330343631 + 3066 + tasks: + - name: just a debug task + debug: msg="hello world" diff --git a/test/custom_rules/__init__.py b/test/custom_rules/__init__.py new file mode 100644 index 0000000..09a0f04 --- /dev/null +++ b/test/custom_rules/__init__.py @@ -0,0 +1 @@ +"""Dummy test module.""" diff --git a/test/custom_rules/example_com/ExampleComRule.py b/test/custom_rules/example_com/ExampleComRule.py new file mode 100644 index 0000000..0ce9c1c --- /dev/null +++ b/test/custom_rules/example_com/ExampleComRule.py @@ -0,0 +1,28 @@ +# Copyright (c) 2020, Ansible Project +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +"""A dummy custom rule module #2.""" + +import ansiblelint.rules.AlwaysRunRule + + +class ExampleComRule(ansiblelint.rules.AlwaysRunRule.AlwaysRunRule): + """A dummy custom rule class.""" + + id = '100002' diff --git a/test/custom_rules/example_com/__init__.py b/test/custom_rules/example_com/__init__.py new file mode 100644 index 0000000..a633c75 --- /dev/null +++ b/test/custom_rules/example_com/__init__.py @@ -0,0 +1 @@ +"""A dummy test module #2.""" diff --git a/test/custom_rules/example_inc/CustomAlwaysRunRule.py b/test/custom_rules/example_inc/CustomAlwaysRunRule.py new file mode 100644 index 0000000..1bff62d --- /dev/null +++ b/test/custom_rules/example_inc/CustomAlwaysRunRule.py @@ -0,0 +1,28 @@ +# Copyright (c) 2020, Ansible Project +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +"""Dummy custom rule module.""" + +import ansiblelint.rules.AlwaysRunRule + + +class CustomAlwaysRunRule(ansiblelint.rules.AlwaysRunRule.AlwaysRunRule): + """Dummy custom rule class.""" + + id = '100001' diff --git a/test/custom_rules/example_inc/__init__.py b/test/custom_rules/example_inc/__init__.py new file mode 100644 index 0000000..09a0f04 --- /dev/null +++ b/test/custom_rules/example_inc/__init__.py @@ -0,0 +1 @@ +"""Dummy test module.""" diff --git a/test/dependency-in-meta/bitbucket.yml b/test/dependency-in-meta/bitbucket.yml new file mode 100644 index 0000000..b696809 --- /dev/null +++ b/test/dependency-in-meta/bitbucket.yml @@ -0,0 +1,10 @@ +--- + +dependencies: + # from Bitbucket + - src: git+http://bitbucket.org/willthames/git-ansible-galaxy + version: v1.4 + + # from Bitbucket, alternative syntax and caveats + - src: http://bitbucket.org/willthames/hg-ansible-galaxy + scm: hg diff --git a/test/dependency-in-meta/galaxy.yml b/test/dependency-in-meta/galaxy.yml new file mode 100644 index 0000000..7f2c343 --- /dev/null +++ b/test/dependency-in-meta/galaxy.yml @@ -0,0 +1,5 @@ +--- + +dependencies: + # from galaxy + - src: yatesr.timezone diff --git a/test/dependency-in-meta/github.yml b/test/dependency-in-meta/github.yml new file mode 100644 index 0000000..234c85a --- /dev/null +++ b/test/dependency-in-meta/github.yml @@ -0,0 +1,10 @@ +--- + +dependencies: + # from GitHub + - src: https://github.com/bennojoy/nginx + + # from GitHub, overriding the name and specifying a specific tag + - src: https://github.com/bennojoy/nginx + version: master + name: nginx_role diff --git a/test/dependency-in-meta/gitlab.yml b/test/dependency-in-meta/gitlab.yml new file mode 100644 index 0000000..03b741e --- /dev/null +++ b/test/dependency-in-meta/gitlab.yml @@ -0,0 +1,7 @@ +--- + +dependencies: + # from GitLab or other git-based scm + - src: git@gitlab.company.com:mygroup/ansible-base.git + scm: git + version: "0.1" # quoted, so YAML doesn't parse this as a floating-point value diff --git a/test/dependency-in-meta/webserver.yml b/test/dependency-in-meta/webserver.yml new file mode 100644 index 0000000..2209ee2 --- /dev/null +++ b/test/dependency-in-meta/webserver.yml @@ -0,0 +1,6 @@ +--- + +dependencies: + # from a webserver, where the role is packaged in a tar.gz + - src: https://some.webserver.example.com/files/master.tar.gz + name: http-role diff --git a/test/directory with spaces/main.yml b/test/directory with spaces/main.yml new file mode 100644 index 0000000..1969c6e --- /dev/null +++ b/test/directory with spaces/main.yml @@ -0,0 +1 @@ +- debug: msg="tasks in directory with spaces included" diff --git a/test/ematchtest.yml b/test/ematchtest.yml new file mode 100644 index 0000000..333526c --- /dev/null +++ b/test/ematchtest.yml @@ -0,0 +1,5 @@ +hello +nothing +exciting +is +happening diff --git a/test/emptytags.yml b/test/emptytags.yml new file mode 100644 index 0000000..26758dc --- /dev/null +++ b/test/emptytags.yml @@ -0,0 +1,7 @@ +--- +- hosts: all + + tasks: + - name: hello world + debug: msg="hello world" + tags: diff --git a/test/fixtures/ansible-config-invalid.yml b/test/fixtures/ansible-config-invalid.yml new file mode 100644 index 0000000..ca8c431 --- /dev/null +++ b/test/fixtures/ansible-config-invalid.yml @@ -0,0 +1,3 @@ +# invalid .ansible-lint config file +- foo +- bar diff --git a/test/fixtures/ansible-config.yml b/test/fixtures/ansible-config.yml new file mode 100644 index 0000000..4c94267 --- /dev/null +++ b/test/fixtures/ansible-config.yml @@ -0,0 +1,4 @@ +--- +verbosity: 1 + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/config-with-relative-path.yml b/test/fixtures/config-with-relative-path.yml new file mode 100644 index 0000000..51ac404 --- /dev/null +++ b/test/fixtures/config-with-relative-path.yml @@ -0,0 +1,5 @@ +--- +exclude_paths: +- ../test-role/ + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/exclude-paths-with-expands.yml b/test/fixtures/exclude-paths-with-expands.yml new file mode 100644 index 0000000..20c742d --- /dev/null +++ b/test/fixtures/exclude-paths-with-expands.yml @@ -0,0 +1,6 @@ +--- +exclude_paths: +- ~/.ansible/roles +- $HOME/.ansible/roles + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/exclude-paths.yml b/test/fixtures/exclude-paths.yml new file mode 100644 index 0000000..a8bb938 --- /dev/null +++ b/test/fixtures/exclude-paths.yml @@ -0,0 +1,5 @@ +--- +exclude_paths: +- ../ + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/parseable.yml b/test/fixtures/parseable.yml new file mode 100644 index 0000000..4603267 --- /dev/null +++ b/test/fixtures/parseable.yml @@ -0,0 +1,4 @@ +--- +parseable: true + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/quiet.yml b/test/fixtures/quiet.yml new file mode 100644 index 0000000..583556f --- /dev/null +++ b/test/fixtures/quiet.yml @@ -0,0 +1,4 @@ +--- +quiet: true + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/rulesdir-defaults.yml b/test/fixtures/rulesdir-defaults.yml new file mode 100644 index 0000000..9eb30c6 --- /dev/null +++ b/test/fixtures/rulesdir-defaults.yml @@ -0,0 +1,6 @@ +--- +rulesdir: +- ./rules +use_default_rules: true + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/rulesdir.yml b/test/fixtures/rulesdir.yml new file mode 100644 index 0000000..6ecd43d --- /dev/null +++ b/test/fixtures/rulesdir.yml @@ -0,0 +1,5 @@ +--- +rulesdir: +- ./rules + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/show-abspath.yml b/test/fixtures/show-abspath.yml new file mode 100644 index 0000000..1945d2e --- /dev/null +++ b/test/fixtures/show-abspath.yml @@ -0,0 +1,4 @@ +--- +display_relative_path: false + +# vim: et:sw=2:syntax=2:ts=2: diff --git a/test/fixtures/show-relpath.yml b/test/fixtures/show-relpath.yml new file mode 100644 index 0000000..7e7c3e6 --- /dev/null +++ b/test/fixtures/show-relpath.yml @@ -0,0 +1,4 @@ +--- +display_relative_path: true + +# vim: et:sw=2:syntax=2:ts=2: diff --git a/test/fixtures/skip-tags.yml b/test/fixtures/skip-tags.yml new file mode 100644 index 0000000..1f64b00 --- /dev/null +++ b/test/fixtures/skip-tags.yml @@ -0,0 +1,5 @@ +--- +skip_list: +- "bad_tag" + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/tags.yml b/test/fixtures/tags.yml new file mode 100644 index 0000000..39f444a --- /dev/null +++ b/test/fixtures/tags.yml @@ -0,0 +1,5 @@ +--- +tags: + - skip_ansible_lint + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/fixtures/unknown-type.yml b/test/fixtures/unknown-type.yml new file mode 100644 index 0000000..54c6d2b --- /dev/null +++ b/test/fixtures/unknown-type.yml @@ -0,0 +1,2 @@ +--- +some: map diff --git a/test/fixtures/verbosity.yml b/test/fixtures/verbosity.yml new file mode 100644 index 0000000..4c94267 --- /dev/null +++ b/test/fixtures/verbosity.yml @@ -0,0 +1,4 @@ +--- +verbosity: 1 + +# vim: et:sw=2:syntax=yaml:ts=2: diff --git a/test/foo.txt b/test/foo.txt new file mode 100644 index 0000000..94f8f1a --- /dev/null +++ b/test/foo.txt @@ -0,0 +1 @@ +Foo file diff --git a/test/include-import-role.yml b/test/include-import-role.yml new file mode 100644 index 0000000..7050ed1 --- /dev/null +++ b/test/include-import-role.yml @@ -0,0 +1,17 @@ +- hosts: all + vars: + var_is_set: no + + tasks: + - import_role: + name: test-role + +- hosts: all + vars: + var_is_set: no + + tasks: + - include_role: + name: test-role + tasks_from: world + when: "{{ var_is_set }}" diff --git a/test/include-import-tasks-in-role.yml b/test/include-import-tasks-in-role.yml new file mode 100644 index 0000000..313fc28 --- /dev/null +++ b/test/include-import-tasks-in-role.yml @@ -0,0 +1,3 @@ +- hosts: all + roles: + - role-with-included-imported-tasks diff --git a/test/include-in-block-inner.yml b/test/include-in-block-inner.yml new file mode 100644 index 0000000..be491a1 --- /dev/null +++ b/test/include-in-block-inner.yml @@ -0,0 +1,5 @@ +--- + +- block: + - include: simpletask.yml + tags: ['foo'] diff --git a/test/include-in-block.yml b/test/include-in-block.yml new file mode 100644 index 0000000..74f1f99 --- /dev/null +++ b/test/include-in-block.yml @@ -0,0 +1,5 @@ +--- +- hosts: all + + tasks: + - include: include-in-block-inner.yml diff --git a/test/included-handlers.yml b/test/included-handlers.yml new file mode 100644 index 0000000..322b347 --- /dev/null +++ b/test/included-handlers.yml @@ -0,0 +1,6 @@ +--- +- name: restart xyz + service: name=xyz state=restarted +# see Issue #165 +- name: command handler issue 165 + command: do something diff --git a/test/included-with-lint.yml b/test/included-with-lint.yml new file mode 100644 index 0000000..d92af1a --- /dev/null +++ b/test/included-with-lint.yml @@ -0,0 +1,4 @@ +# missing a task name +- yum: + name: ansible + until: result|success diff --git a/test/includedoesnotexist.yml b/test/includedoesnotexist.yml new file mode 100644 index 0000000..b123339 --- /dev/null +++ b/test/includedoesnotexist.yml @@ -0,0 +1,3 @@ +--- +- pre_tasks: + - include: "doesnotexist.yml" diff --git a/test/jinja2-when-failure.yml b/test/jinja2-when-failure.yml new file mode 100644 index 0000000..aec7269 --- /dev/null +++ b/test/jinja2-when-failure.yml @@ -0,0 +1,10 @@ +- hosts: all + tasks: + - name: test when with jinja2 + debug: msg=text + when: "{{ false }}" + +- hosts: all + roles: + - role: test + when: "{{ '1' = '1' }}" diff --git a/test/jinja2-when-success.yml b/test/jinja2-when-success.yml new file mode 100644 index 0000000..20d3db9 --- /dev/null +++ b/test/jinja2-when-success.yml @@ -0,0 +1,8 @@ +- hosts: all + tasks: + - name: test when + debug: msg=text + when: true + - name: test when 2 + debug: msg=text2 + when: 1 = 1 diff --git a/test/local-content/README.md b/test/local-content/README.md new file mode 100644 index 0000000..2b6322a --- /dev/null +++ b/test/local-content/README.md @@ -0,0 +1,6 @@ +The reason that every roles test gets its own directory is that while they +use the same three roles, the way the tests work makes sure that when the +second one runs, the roles and their local plugins from the first test are +still known to Ansible. For that reason, their names reflect the directory +they are in to make sure that tests don't use modules/plugins found by +other tests. diff --git a/test/local-content/collections/ansible_collections/testns/testcoll/galaxy.yml b/test/local-content/collections/ansible_collections/testns/testcoll/galaxy.yml new file mode 100644 index 0000000..43dd2e9 --- /dev/null +++ b/test/local-content/collections/ansible_collections/testns/testcoll/galaxy.yml @@ -0,0 +1,3 @@ +namespace: testns +name: testcoll +version: 0.1.0 diff --git a/test/local-content/collections/ansible_collections/testns/testcoll/plugins/filter/test_filter.py b/test/local-content/collections/ansible_collections/testns/testcoll/plugins/filter/test_filter.py new file mode 100644 index 0000000..ac9e854 --- /dev/null +++ b/test/local-content/collections/ansible_collections/testns/testcoll/plugins/filter/test_filter.py @@ -0,0 +1,16 @@ +"""A filter plugin.""" + + +def a_test_filter(a, b): + """Return a string containing both a and b.""" + return '{0}:{1}'.format(a, b) + + +class FilterModule(object): + """Filter plugin.""" + + def filters(self): + """Return filters.""" + return { + 'test_filter': a_test_filter + } diff --git a/test/local-content/collections/ansible_collections/testns/testcoll/plugins/modules/test_module_2.py b/test/local-content/collections/ansible_collections/testns/testcoll/plugins/modules/test_module_2.py new file mode 100644 index 0000000..cae1a26 --- /dev/null +++ b/test/local-content/collections/ansible_collections/testns/testcoll/plugins/modules/test_module_2.py @@ -0,0 +1,14 @@ +#!/usr/bin/python +"""A module.""" + +from ansible.module_utils.basic import AnsibleModule + + +def main() -> None: + """Execute module.""" + module = AnsibleModule(dict()) + module.exit_json(msg="Hello 2!") + + +if __name__ == '__main__': + main() diff --git a/test/local-content/test-collection.yml b/test/local-content/test-collection.yml new file mode 100644 index 0000000..bc3ed1b --- /dev/null +++ b/test/local-content/test-collection.yml @@ -0,0 +1,10 @@ +--- +- name: Use module and filter plugin from local collection + hosts: localhost + tasks: + - name: Use module from local collection + testns.testcoll.test_module_2: + - name: Use filter from local collection + assert: + that: + - 1 | testns.testcoll.test_filter(2) == '1:2' diff --git a/test/local-content/test-roles-failed-complete/roles/role1/library/test_module_1_failed_complete.py b/test/local-content/test-roles-failed-complete/roles/role1/library/test_module_1_failed_complete.py new file mode 100644 index 0000000..1c63fdd --- /dev/null +++ b/test/local-content/test-roles-failed-complete/roles/role1/library/test_module_1_failed_complete.py @@ -0,0 +1,14 @@ +#!/usr/bin/python +"""A module.""" + +from ansible.module_utils.basic import AnsibleModule + + +def main() -> None: + """Execute module.""" + module = AnsibleModule(dict()) + module.exit_json(msg="Hello 1!") + + +if __name__ == '__main__': + main() diff --git a/test/local-content/test-roles-failed-complete/roles/role1/tasks/main.yml b/test/local-content/test-roles-failed-complete/roles/role1/tasks/main.yml new file mode 100644 index 0000000..680dcab --- /dev/null +++ b/test/local-content/test-roles-failed-complete/roles/role1/tasks/main.yml @@ -0,0 +1,3 @@ +--- +- name: Use local module 1 + test_module_1_failed_complete: diff --git a/test/local-content/test-roles-failed-complete/roles/role2/tasks/main.yml b/test/local-content/test-roles-failed-complete/roles/role2/tasks/main.yml new file mode 100644 index 0000000..8646f6b --- /dev/null +++ b/test/local-content/test-roles-failed-complete/roles/role2/tasks/main.yml @@ -0,0 +1,11 @@ +--- +- name: Use local module from other role that has been included before this one + # If it has not been included before, loading this role fails! + test_module_1_failed_complete: +- name: Use local module from other role that has been included before this one + # If it has not been included before, loading this role fails! + test_module_3_failed_complete: +- name: Use local test plugin + assert: + that: + - "'2' is b_test_failed_complete '12345'" diff --git a/test/local-content/test-roles-failed-complete/roles/role2/test_plugins/b_failed_complete.py b/test/local-content/test-roles-failed-complete/roles/role2/test_plugins/b_failed_complete.py new file mode 100644 index 0000000..abc1049 --- /dev/null +++ b/test/local-content/test-roles-failed-complete/roles/role2/test_plugins/b_failed_complete.py @@ -0,0 +1,16 @@ +"""A test plugin.""" + + +def compatibility_in_test(a, b): + """Return True when a is contained in b.""" + return a in b + + +class TestModule: + """Test plugin.""" + + def tests(self): + """Return tests.""" + return { + 'b_test_failed_complete': compatibility_in_test, + } diff --git a/test/local-content/test-roles-failed-complete/roles/role3/library/test_module_3_failed_complete.py b/test/local-content/test-roles-failed-complete/roles/role3/library/test_module_3_failed_complete.py new file mode 100644 index 0000000..c7296be --- /dev/null +++ b/test/local-content/test-roles-failed-complete/roles/role3/library/test_module_3_failed_complete.py @@ -0,0 +1,14 @@ +#!/usr/bin/python +"""A module.""" + +from ansible.module_utils.basic import AnsibleModule + + +def main() -> None: + """Execute module.""" + module = AnsibleModule(dict()) + module.exit_json(msg="Hello 3!") + + +if __name__ == '__main__': + main() diff --git a/test/local-content/test-roles-failed-complete/roles/role3/tasks/main.yml b/test/local-content/test-roles-failed-complete/roles/role3/tasks/main.yml new file mode 100644 index 0000000..7a36734 --- /dev/null +++ b/test/local-content/test-roles-failed-complete/roles/role3/tasks/main.yml @@ -0,0 +1,3 @@ +--- +- name: Use local module 3 + test_module_3_failed_complete: diff --git a/test/local-content/test-roles-failed-complete/test.yml b/test/local-content/test-roles-failed-complete/test.yml new file mode 100644 index 0000000..1160bb5 --- /dev/null +++ b/test/local-content/test-roles-failed-complete/test.yml @@ -0,0 +1,5 @@ +--- +- name: Include role which expects module that is local to other role which is not loaded + hosts: localhost + roles: + - role2 diff --git a/test/local-content/test-roles-failed/roles/role1/library/test_module_1_failed.py b/test/local-content/test-roles-failed/roles/role1/library/test_module_1_failed.py new file mode 100644 index 0000000..1c63fdd --- /dev/null +++ b/test/local-content/test-roles-failed/roles/role1/library/test_module_1_failed.py @@ -0,0 +1,14 @@ +#!/usr/bin/python +"""A module.""" + +from ansible.module_utils.basic import AnsibleModule + + +def main() -> None: + """Execute module.""" + module = AnsibleModule(dict()) + module.exit_json(msg="Hello 1!") + + +if __name__ == '__main__': + main() diff --git a/test/local-content/test-roles-failed/roles/role1/tasks/main.yml b/test/local-content/test-roles-failed/roles/role1/tasks/main.yml new file mode 100644 index 0000000..257493a --- /dev/null +++ b/test/local-content/test-roles-failed/roles/role1/tasks/main.yml @@ -0,0 +1,3 @@ +--- +- name: Use local module 1 + test_module_1_failed: diff --git a/test/local-content/test-roles-failed/roles/role2/tasks/main.yml b/test/local-content/test-roles-failed/roles/role2/tasks/main.yml new file mode 100644 index 0000000..48daca6 --- /dev/null +++ b/test/local-content/test-roles-failed/roles/role2/tasks/main.yml @@ -0,0 +1,11 @@ +--- +- name: Use local module from other role that has been included before this one + # If it has not been included before, loading this role fails! + test_module_1_failed: +- name: Use local module from other role that has been included before this one + # If it has not been included before, loading this role fails! + test_module_3_failed: +- name: Use local test plugin + assert: + that: + - "'2' is b_test_failed '12345'" diff --git a/test/local-content/test-roles-failed/roles/role2/test_plugins/b_failed.py b/test/local-content/test-roles-failed/roles/role2/test_plugins/b_failed.py new file mode 100644 index 0000000..09a02a3 --- /dev/null +++ b/test/local-content/test-roles-failed/roles/role2/test_plugins/b_failed.py @@ -0,0 +1,16 @@ +"""A test plugin.""" + + +def compatibility_in_test(a, b): + """Return True when a is contained in b.""" + return a in b + + +class TestModule: + """Test plugin.""" + + def tests(self): + """Return tests.""" + return { + 'b_test_failed': compatibility_in_test, + } diff --git a/test/local-content/test-roles-failed/roles/role3/library/test_module_3_failed.py b/test/local-content/test-roles-failed/roles/role3/library/test_module_3_failed.py new file mode 100644 index 0000000..c7296be --- /dev/null +++ b/test/local-content/test-roles-failed/roles/role3/library/test_module_3_failed.py @@ -0,0 +1,14 @@ +#!/usr/bin/python +"""A module.""" + +from ansible.module_utils.basic import AnsibleModule + + +def main() -> None: + """Execute module.""" + module = AnsibleModule(dict()) + module.exit_json(msg="Hello 3!") + + +if __name__ == '__main__': + main() diff --git a/test/local-content/test-roles-failed/roles/role3/tasks/main.yml b/test/local-content/test-roles-failed/roles/role3/tasks/main.yml new file mode 100644 index 0000000..ad17eb0 --- /dev/null +++ b/test/local-content/test-roles-failed/roles/role3/tasks/main.yml @@ -0,0 +1,3 @@ +--- +- name: Use local module 3 + test_module_3_failed: diff --git a/test/local-content/test-roles-failed/test.yml b/test/local-content/test-roles-failed/test.yml new file mode 100644 index 0000000..08ff0f6 --- /dev/null +++ b/test/local-content/test-roles-failed/test.yml @@ -0,0 +1,7 @@ +--- +- name: Use roles with local module in wrong order, so that Ansible fails + hosts: localhost + roles: + - role2 + - role3 + - role1 diff --git a/test/local-content/test-roles-success/roles/role1/library/test_module_1_success.py b/test/local-content/test-roles-success/roles/role1/library/test_module_1_success.py new file mode 100644 index 0000000..1c63fdd --- /dev/null +++ b/test/local-content/test-roles-success/roles/role1/library/test_module_1_success.py @@ -0,0 +1,14 @@ +#!/usr/bin/python +"""A module.""" + +from ansible.module_utils.basic import AnsibleModule + + +def main() -> None: + """Execute module.""" + module = AnsibleModule(dict()) + module.exit_json(msg="Hello 1!") + + +if __name__ == '__main__': + main() diff --git a/test/local-content/test-roles-success/roles/role1/tasks/main.yml b/test/local-content/test-roles-success/roles/role1/tasks/main.yml new file mode 100644 index 0000000..ba920af --- /dev/null +++ b/test/local-content/test-roles-success/roles/role1/tasks/main.yml @@ -0,0 +1,3 @@ +--- +- name: Use local module 1 + test_module_1_success: diff --git a/test/local-content/test-roles-success/roles/role2/tasks/main.yml b/test/local-content/test-roles-success/roles/role2/tasks/main.yml new file mode 100644 index 0000000..a540cf1 --- /dev/null +++ b/test/local-content/test-roles-success/roles/role2/tasks/main.yml @@ -0,0 +1,11 @@ +--- +- name: Use local module from other role that has been included before this one + # If it has not been included before, loading this role fails! + test_module_1_success: +- name: Use local module from other role that has been included before this one + # If it has not been included before, loading this role fails! + test_module_3_success: +- name: Use local test plugin + assert: + that: + - "'2' is b_test_success '12345'" diff --git a/test/local-content/test-roles-success/roles/role2/test_plugins/b_success.py b/test/local-content/test-roles-success/roles/role2/test_plugins/b_success.py new file mode 100644 index 0000000..bcef377 --- /dev/null +++ b/test/local-content/test-roles-success/roles/role2/test_plugins/b_success.py @@ -0,0 +1,16 @@ +"""A test plugin.""" + + +def compatibility_in_test(a, b): + """Return True when a is contained in b.""" + return a in b + + +class TestModule: + """Test plugin.""" + + def tests(self): + """Return tests.""" + return { + 'b_test_success': compatibility_in_test, + } diff --git a/test/local-content/test-roles-success/roles/role3/library/test_module_3_success.py b/test/local-content/test-roles-success/roles/role3/library/test_module_3_success.py new file mode 100644 index 0000000..c7296be --- /dev/null +++ b/test/local-content/test-roles-success/roles/role3/library/test_module_3_success.py @@ -0,0 +1,14 @@ +#!/usr/bin/python +"""A module.""" + +from ansible.module_utils.basic import AnsibleModule + + +def main() -> None: + """Execute module.""" + module = AnsibleModule(dict()) + module.exit_json(msg="Hello 3!") + + +if __name__ == '__main__': + main() diff --git a/test/local-content/test-roles-success/roles/role3/tasks/main.yml b/test/local-content/test-roles-success/roles/role3/tasks/main.yml new file mode 100644 index 0000000..c77a7c8 --- /dev/null +++ b/test/local-content/test-roles-success/roles/role3/tasks/main.yml @@ -0,0 +1,3 @@ +--- +- name: Use local module 3 + test_module_3_success: diff --git a/test/local-content/test-roles-success/test.yml b/test/local-content/test-roles-success/test.yml new file mode 100644 index 0000000..df17c7d --- /dev/null +++ b/test/local-content/test-roles-success/test.yml @@ -0,0 +1,7 @@ +--- +- name: Use roles with local modules and test plugins + hosts: localhost + roles: + - role1 + - role3 + - role2 diff --git a/test/multiline-brackets-do-not-match-test.yml b/test/multiline-brackets-do-not-match-test.yml new file mode 100644 index 0000000..dfa5ff8 --- /dev/null +++ b/test/multiline-brackets-do-not-match-test.yml @@ -0,0 +1,22 @@ +--- +- hosts: foo + roles: + - ../../../roles/base_os + - ../../../roles/repos + - { + role: ../../../roles/openshift_master, + oo_minion_ips: "{ hostvars['localhost'].oo_minion_ips | default(['']) }}", + oo_bind_ip: "{{ hostvars[inventory_hostname].ansible_eth0.ipv4.address | default(['']) }}" + } + - ../../../roles/pods + +- name: "Set Origin specific facts on localhost (for later use)" + hosts: localhost + gather_facts: no + tasks: + - name: Setting oo_minion_ips fact on localhost + set_fact: + oo_minion_ips: "{{ hostvars + | oo_select_keys(groups['tag_env-host-type-' + oo_env + '-openshift-minion']) + | oo_collect(attribute='ansible_eth0.ipv4.address') }" + when: groups['tag_env-host-type-' + oo_env + '-openshift-minion'] is defined diff --git a/test/multiline-bracketsmatchtest.yml b/test/multiline-bracketsmatchtest.yml new file mode 100644 index 0000000..703f225 --- /dev/null +++ b/test/multiline-bracketsmatchtest.yml @@ -0,0 +1,22 @@ +--- +- hosts: foo + roles: + - ../../../roles/base_os + - ../../../roles/repos + - { + role: ../../../roles/openshift_master, + oo_minion_ips: "{{ hostvars['localhost'].oo_minion_ips | default(['']) }}", + oo_bind_ip: "{{ hostvars[inventory_hostname].ansible_eth0.ipv4.address | default(['']) }}" + } + - ../../../roles/pods + +- name: "Set Origin specific facts on localhost (for later use)" + hosts: localhost + gather_facts: no + tasks: + - name: Setting oo_minion_ips fact on localhost + set_fact: + oo_minion_ips: "{{ hostvars + | oo_select_keys(groups['tag_env-host-type-' + oo_env + '-openshift-minion']) + | oo_collect(attribute='ansible_eth0.ipv4.address') }}" + when: groups['tag_env-host-type-' + oo_env + '-openshift-minion'] is defined diff --git a/test/nestedincludes.yml b/test/nestedincludes.yml new file mode 100644 index 0000000..5985b54 --- /dev/null +++ b/test/nestedincludes.yml @@ -0,0 +1,2 @@ +--- +- include: simpletask.yml tags=nginx diff --git a/test/nomatchestest.yml b/test/nomatchestest.yml new file mode 100644 index 0000000..e48ef92 --- /dev/null +++ b/test/nomatchestest.yml @@ -0,0 +1,9 @@ +--- +- hosts: whatever + + tasks: + - name: hello world + action: debug msg="Hello!" + + - name: this should be fine too + action: file state=touch dest=./wherever mode=0600 diff --git a/test/norole.yml b/test/norole.yml new file mode 100644 index 0000000..3a18e94 --- /dev/null +++ b/test/norole.yml @@ -0,0 +1,5 @@ +--- +- hosts: + - localhost + roles: + - name: node diff --git a/test/norole2.yml b/test/norole2.yml new file mode 100644 index 0000000..2ee7a83 --- /dev/null +++ b/test/norole2.yml @@ -0,0 +1,5 @@ +--- +- hosts: + - localhost + roles: + - name: node diff --git a/test/package-check-failure.yml b/test/package-check-failure.yml new file mode 100644 index 0000000..8c25f3c --- /dev/null +++ b/test/package-check-failure.yml @@ -0,0 +1,14 @@ +- hosts: localhost + tasks: + - name: install ansible + yum: name=ansible state=latest + + - name: install ansible-lint + pip: name=ansible-lint + args: + state: latest + + - name: install some-package + package: + name: some-package + state: latest diff --git a/test/package-check-success.yml b/test/package-check-success.yml new file mode 100644 index 0000000..d649dc7 --- /dev/null +++ b/test/package-check-success.yml @@ -0,0 +1,15 @@ +- hosts: localhost + tasks: + - name: install ansible + yum: name=ansible-2.1.0.0 state=present + + - name: install ansible-lint + pip: name=ansible-lint + args: + state: present + version: 3.1.2 + + - name: install some-package + package: + name: some-package + state: present diff --git a/test/playbook-import/playbook_imported.yml b/test/playbook-import/playbook_imported.yml new file mode 100644 index 0000000..4dc646a --- /dev/null +++ b/test/playbook-import/playbook_imported.yml @@ -0,0 +1,9 @@ +--- +- hosts: localhost + connection: local + gather_facts: no + tasks: + - command: echo "no name" # should generate 502 + - name: Another task + debug: + msg: debug message diff --git a/test/playbook-import/playbook_parent.yml b/test/playbook-import/playbook_parent.yml new file mode 100644 index 0000000..7e8b524 --- /dev/null +++ b/test/playbook-import/playbook_parent.yml @@ -0,0 +1,3 @@ +--- +- name: Importing another playbook + import_playbook: playbook_imported.yml diff --git a/test/role-with-handler/a-role/handlers/main.yml b/test/role-with-handler/a-role/handlers/main.yml new file mode 100644 index 0000000..59ae800 --- /dev/null +++ b/test/role-with-handler/a-role/handlers/main.yml @@ -0,0 +1,5 @@ +--- +- name: do anything + shell: echo merp | cat + when: + - something.changed diff --git a/test/role-with-handler/main.yml b/test/role-with-handler/main.yml new file mode 100644 index 0000000..9b37597 --- /dev/null +++ b/test/role-with-handler/main.yml @@ -0,0 +1,4 @@ +- hosts: localhost + name: foo + roles: + - { role: a-role } diff --git a/test/role-with-included-imported-tasks/tasks/imported_tasks.yml b/test/role-with-included-imported-tasks/tasks/imported_tasks.yml new file mode 100644 index 0000000..32a2b23 --- /dev/null +++ b/test/role-with-included-imported-tasks/tasks/imported_tasks.yml @@ -0,0 +1,2 @@ +- name: This is a task that should be imported + ping: diff --git a/test/role-with-included-imported-tasks/tasks/included_tasks.yml b/test/role-with-included-imported-tasks/tasks/included_tasks.yml new file mode 100644 index 0000000..37b59d2 --- /dev/null +++ b/test/role-with-included-imported-tasks/tasks/included_tasks.yml @@ -0,0 +1,2 @@ +- name: This is a task that should be included + ping: diff --git a/test/role-with-included-imported-tasks/tasks/main.yml b/test/role-with-included-imported-tasks/tasks/main.yml new file mode 100644 index 0000000..81de7cb --- /dev/null +++ b/test/role-with-included-imported-tasks/tasks/main.yml @@ -0,0 +1,6 @@ +- include_tasks: included_tasks.yml +- import_tasks: imported_tasks.yml +- include_tasks: + file: included_tasks.yml + apply: + tags: sometag diff --git a/test/roles/ansible-role-foo/tasks/main.yaml b/test/roles/ansible-role-foo/tasks/main.yaml new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/test/roles/ansible-role-foo/tasks/main.yaml diff --git a/test/roles/invalid-name/tasks/main.yaml b/test/roles/invalid-name/tasks/main.yaml new file mode 100644 index 0000000..1270837 --- /dev/null +++ b/test/roles/invalid-name/tasks/main.yaml @@ -0,0 +1,4 @@ +--- +- name: foo + debug: + msg: foo diff --git a/test/roles/invalid_due_to_meta/meta/main.yml b/test/roles/invalid_due_to_meta/meta/main.yml new file mode 100644 index 0000000..0d4b0b2 --- /dev/null +++ b/test/roles/invalid_due_to_meta/meta/main.yml @@ -0,0 +1,8 @@ +galaxy_info: + role_name: invalid-due-to-meta + author: foo + description: foo + license: MIT + platforms: + - name: foo + min_ansible_version: 2.7 diff --git a/test/roles/invalid_due_to_meta/tasks/main.yaml b/test/roles/invalid_due_to_meta/tasks/main.yaml new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/test/roles/invalid_due_to_meta/tasks/main.yaml diff --git a/test/roles/test-role/molecule/default/include-import-role.yml b/test/roles/test-role/molecule/default/include-import-role.yml new file mode 100644 index 0000000..0e1d166 --- /dev/null +++ b/test/roles/test-role/molecule/default/include-import-role.yml @@ -0,0 +1,6 @@ +--- +- name: test + gather_facts: no + hosts: all + roles: + - role: test-role diff --git a/test/roles/test-role/tasks/main.yml b/test/roles/test-role/tasks/main.yml new file mode 100644 index 0000000..53b968b --- /dev/null +++ b/test/roles/test-role/tasks/main.yml @@ -0,0 +1,2 @@ +- name: shell instead of command + shell: echo hello world diff --git a/test/roles/valid-due-to-meta/meta/main.yml b/test/roles/valid-due-to-meta/meta/main.yml new file mode 100644 index 0000000..8b8566b --- /dev/null +++ b/test/roles/valid-due-to-meta/meta/main.yml @@ -0,0 +1,8 @@ +galaxy_info: + role_name: valid_due_to_meta + author: foo + description: foo + license: MIT + platforms: + - name: foo + min_ansible_version: 2.7 diff --git a/test/roles/valid-due-to-meta/tasks/debian/main.yml b/test/roles/valid-due-to-meta/tasks/debian/main.yml new file mode 100644 index 0000000..6fa48c2 --- /dev/null +++ b/test/roles/valid-due-to-meta/tasks/debian/main.yml @@ -0,0 +1,2 @@ +# This empty task file is here to test that roles with tasks organized in subdirectories +# are handled correctly by ansible-lint. diff --git a/test/roles/valid-due-to-meta/tasks/main.yaml b/test/roles/valid-due-to-meta/tasks/main.yaml new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/test/roles/valid-due-to-meta/tasks/main.yaml diff --git a/test/rules/EMatcherRule.py b/test/rules/EMatcherRule.py new file mode 100644 index 0000000..ed65883 --- /dev/null +++ b/test/rules/EMatcherRule.py @@ -0,0 +1,12 @@ +from ansiblelint.rules import AnsibleLintRule + + +class EMatcherRule(AnsibleLintRule): + id = 'TEST0001' + description = 'This is a test rule that looks for lines ' + \ + 'containing the letter e' + shortdesc = 'The letter "e" is present' + tags = ['fake', 'dummy', 'test1'] + + def match(self, filename, line): + return "e" in line diff --git a/test/rules/UnsetVariableMatcherRule.py b/test/rules/UnsetVariableMatcherRule.py new file mode 100644 index 0000000..b4c1756 --- /dev/null +++ b/test/rules/UnsetVariableMatcherRule.py @@ -0,0 +1,12 @@ +from ansiblelint.rules import AnsibleLintRule + + +class UnsetVariableMatcherRule(AnsibleLintRule): + id = 'TEST0002' + shortdesc = 'Line contains untemplated variable' + description = 'This is a test rule that looks for lines ' + \ + 'post templating that still contain {{' + tags = ['fake', 'dummy', 'test2'] + + def match(self, filename, line): + return "{{" in line diff --git a/test/rules/__init__.py b/test/rules/__init__.py new file mode 100644 index 0000000..4a6e23f --- /dev/null +++ b/test/rules/__init__.py @@ -0,0 +1,3 @@ +"""Test rules resources.""" + +__all__ = ['UnsetVariableMatcherRule', 'EMatcherRule'] diff --git a/test/simpletask.yml b/test/simpletask.yml new file mode 100644 index 0000000..0aba042 --- /dev/null +++ b/test/simpletask.yml @@ -0,0 +1,3 @@ +--- +- name: hello world + debug: msg="Hello!" diff --git a/test/skiptasks.yml b/test/skiptasks.yml new file mode 100644 index 0000000..c6a130b --- /dev/null +++ b/test/skiptasks.yml @@ -0,0 +1,70 @@ +--- +- hosts: all + + tasks: + + - name: test 401 + action: git + + - name: test 402 + action: hg + + - name: test 303 + command: git log + changed_when: False + + - name: test 302 + command: creates=B chmod 644 A + + - name: test invalid action (skip) + foo: bar + tags: + - skip_ansible_lint + + - name: test 401 (skip) + action: git + tags: + - skip_ansible_lint + + - name: test 402 (skip) + action: hg + tags: + - skip_ansible_lint + + - name: test 303 (skip) + command: git log + tags: + - skip_ansible_lint + + - name: test 302 (skip) + command: chmod 644 A + tags: + - skip_ansible_lint + + - name: test 401 (don't warn) + command: git log + args: + warn: False + changed_when: False + + - name: test 402 (don't warn) + command: chmod 644 A + args: + warn: False + creates: B + + - name: test 402 (warn) + command: chmod 644 A + args: + warn: yes + creates: B + + - name: test 401 (don't warn single line) + command: warn=False chdir=/tmp/blah git log + changed_when: False + + - name: test 402 (don't warn single line) + command: warn=no creates=B chmod 644 A + + - name: test 402 (warn single line) + command: warn=yes creates=B chmod 644 A diff --git a/test/task-has-name-failure.yml b/test/task-has-name-failure.yml new file mode 100644 index 0000000..ce947f3 --- /dev/null +++ b/test/task-has-name-failure.yml @@ -0,0 +1,7 @@ +--- + +- hosts: all + tasks: + - command: echo "no name" + - name: + command: echo "empty name" diff --git a/test/task-has-name-success.yml b/test/task-has-name-success.yml new file mode 100644 index 0000000..b708f5a --- /dev/null +++ b/test/task-has-name-success.yml @@ -0,0 +1,9 @@ +--- + +- hosts: all + tasks: + - name: This task has a name + command: echo "Hello World" + - debug: + msg: "Hello World" + - meta: flush_handlers diff --git a/test/taskimports.yml b/test/taskimports.yml new file mode 100644 index 0000000..f21b678 --- /dev/null +++ b/test/taskimports.yml @@ -0,0 +1,9 @@ +--- +- hosts: webservers + vars: + varset: varset + tasks: + - import_tasks: nestedincludes.yml tags=nested + - import_tasks: "{{ varnotset }}.yml" + - import_tasks: "{{ varset }}.yml" + - import_tasks: "directory with spaces/main.yml" diff --git a/test/taskincludes.yml b/test/taskincludes.yml new file mode 100644 index 0000000..cba7909 --- /dev/null +++ b/test/taskincludes.yml @@ -0,0 +1,9 @@ +--- +- hosts: webservers + vars: + varset: varset + tasks: + - include: nestedincludes.yml tags=nested + - include: "{{ varnotset }}.yml" + - include: "{{ varset }}.yml" + - include: "directory with spaces/main.yml" diff --git a/test/taskincludes_2_4_style.yml b/test/taskincludes_2_4_style.yml new file mode 100644 index 0000000..f1ae9f4 --- /dev/null +++ b/test/taskincludes_2_4_style.yml @@ -0,0 +1,9 @@ +--- +- hosts: webservers + vars: + varset: varset + tasks: + - include_tasks: nestedincludes.yml tags=nested + - include_tasks: "{{ varnotset }}.yml" + - include_tasks: "{{ varset }}.yml" + - include_tasks: "directory with spaces/main.yml" diff --git a/test/test-role/tasks/main.yml b/test/test-role/tasks/main.yml new file mode 100644 index 0000000..53b968b --- /dev/null +++ b/test/test-role/tasks/main.yml @@ -0,0 +1,2 @@ +- name: shell instead of command + shell: echo hello world diff --git a/test/test-role/tasks/world.yml b/test/test-role/tasks/world.yml new file mode 100644 index 0000000..69ae661 --- /dev/null +++ b/test/test-role/tasks/world.yml @@ -0,0 +1 @@ +- command: echo this is a task without a name diff --git a/test/test/always-run-success.yml b/test/test/always-run-success.yml new file mode 100644 index 0000000..468a17c --- /dev/null +++ b/test/test/always-run-success.yml @@ -0,0 +1 @@ +- hosts: localhost diff --git a/test/testproject/roles/test-role/tasks/main.yml b/test/testproject/roles/test-role/tasks/main.yml new file mode 100644 index 0000000..53b968b --- /dev/null +++ b/test/testproject/roles/test-role/tasks/main.yml @@ -0,0 +1,2 @@ +- name: shell instead of command + shell: echo hello world diff --git a/test/unicode.yml b/test/unicode.yml new file mode 100644 index 0000000..c9204e4 --- /dev/null +++ b/test/unicode.yml @@ -0,0 +1,9 @@ +--- +- hosts: localhost + connection: local + vars: + unicode_var: a_b_cö + + tasks: + - name: bonjour, ça va? + file: state=touch dest=/tmp/naïve.yml mode=0600 diff --git a/test/using-bare-variables-failure.yml b/test/using-bare-variables-failure.yml new file mode 100644 index 0000000..865381b --- /dev/null +++ b/test/using-bare-variables-failure.yml @@ -0,0 +1,108 @@ +--- +- hosts: localhost + become: no + vars: + my_list: + - foo + - bar + + my_list2: + - 1 + - 2 + + my_list_of_dicts: + - foo: 1 + bar: 2 + - foo: 3 + bar: 4 + + my_list_of_lists: + - "{{ my_list }}" + - "{{ my_list2 }}" + + my_filenames: + - foo.txt + - bar.txt + + my_dict: + foo: bar + + tasks: + - name: with_items loop using bare variable + debug: + msg: "{{ item }}" + with_items: my_list + + - name: with_dict loop using bare variable + debug: + msg: "{{ item }}" + with_dict: my_dict + + ### Testing with_dict with a default empty dictionary + - name: with_dict loop using variable and default + debug: + msg: "{{ item.key }} - {{ item.value }}" + with_dict: uwsgi_ini | default({}) + + - name: with_nested loop using bare variable + debug: + msg: "{{ item.0 }} {{ item.1 }}" + with_nested: + - my_list + - "{{ my_list2 }}" + + - name: with_file loop using bare variable + debug: + msg: "{{ item }}" + with_file: my_list + + - name: with_fileglob loop using bare variable + debug: + msg: "{{ item }}" + with_fileglob: my_list + + - name: with_filetree loop using bare variable + debug: + msg: "{{ item }}" + with_filetree: my_list + + - name: with_together loop using bare variable + debug: + msg: "{{ item.0 }} {{ item.1 }}" + with_together: + - my_list + - "{{ my_list2 }}" + + - name: with_subelements loop using bare variable + debug: + msg: "{{ item.0 }}" + with_subelements: + - my_list_of_dicts + - bar + + - name: with_random_choice loop using bare variable + debug: + msg: "{{ item }}" + with_random_choice: my_list + + - name: with_first_found loop using bare variable + debug: + msg: "{{ item }}" + with_first_found: my_filenames + + - name: with_indexed_items loop + debug: + msg: "{{ item.0 }} {{ item.1 }}" + with_indexed_items: my_list + + - name: with_flattened loop + debug: + msg: "{{ item }}" + with_flattened: + - my_list + - my_list2 + + - name: with_flattened loop with a variable + debug: + msg: "{{ item }}" + with_flattened: my_list_of_lists diff --git a/test/using-bare-variables-success.yml b/test/using-bare-variables-success.yml new file mode 100644 index 0000000..c8f0f3f --- /dev/null +++ b/test/using-bare-variables-success.yml @@ -0,0 +1,200 @@ +--- +- hosts: localhost + become: no + vars: + my_list: + - foo + - bar + + my_list2: + - 1 + - 2 + + my_list_of_dicts: + - foo: 1 + bar: 2 + - foo: 3 + bar: 4 + + my_list_of_lists: + - "{{ my_list }}" + - "{{ my_list2 }}" + + my_filenames: + - foo.txt + - bar.txt + + my_dict: + foo: bar + + tasks: + ### Testing with_items loops + - name: with_items loop using static list + debug: + msg: "{{ item }}" + with_items: + - foo + - bar + + - name: with_items using a static hash + debug: + msg: "{{ item.key }} - {{ item.value }}" + with_items: + - { key: foo, value: 1 } + - { key: bar, value: 2 } + + - name: with_items loop using variable + debug: + msg: "{{ item }}" + with_items: "{{ my_list }}" + + ### Testing with_nested loops + - name: with_nested loop using static lists + debug: + msg: "{{ item[0] }} - {{ item[1] }}" + with_nested: + - [ 'foo', 'bar' ] + - [ '1', '2', '3' ] + + - name: with_nested loop using variable list and static + debug: + msg: "{{ item[0] }} - {{ item[1] }}" + with_nested: + - "{{ my_list }}" + - [ '1', '2', '3' ] + + ### Testing with_dict + - name: with_dict loop using variable + debug: + msg: "{{ item.key }} - {{ item.value }}" + with_dict: "{{ my_dict }}" + + ### Testing with_dict with a default empty dictionary + - name: with_dict loop using variable and default + debug: + msg: "{{ item.key }} - {{ item.value }}" + with_dict: "{{ uwsgi_ini | default({}) }}" + + ### Testing with_file + - name: with_file loop using static files list + debug: + msg: "{{ item }}" + with_file: + - foo.txt + - bar.txt + + - name: with_file loop using list of filenames + debug: + msg: "{{ item }}" + with_file: "{{ my_filenames }}" + + ### Testing with_fileglob + - name: with_fileglob loop using list of *.txt + debug: + msg: "{{ item }}" + with_fileglob: + - '*.txt' + + ### Testing non-list form of with_fileglob + - name: with_fileglob loop using single value *.txt + debug: + msg: "{{ item }}" + with_fileglob: '*.txt' + + ### Testing non-list form of with_fileglob with trailing templated pattern + - name: with_fileglob loop using templated pattern + debug: + msg: "{{ item }}" + with_fileglob: 'foo{{glob}}' + + ### Testing with_filetree + - name: with_filetree loop using list of path + debug: + msg: "{{ item }}" + with_filetree: + - path/to/dir1/ + - path/to/dir2/ + + ### Testing non-list form of with_filetree + - name: with_filetree loop using single path + debug: + msg: "{{ item }}" + with_filetree: path/to/dir/ + + ### Testing non-list form of with_filetree with trailing templated pattern + - name: with_filetree loop using templated pattern + debug: + msg: "{{ item }}" + with_filetree: 'path/to/{{ directory }}' + + ### Testing with_together + - name: with_together loop using variable lists + debug: + msg: "{{ item.0 }} - {{ item.1 }}" + with_together: + - "{{ my_list }}" + - "{{ my_list2 }}" + + - name: with_subelements loop + debug: + msg: "{{ item }}" + with_subelements: + - "{{ my_list_of_dicts }}" + - bar + + - name: with_sequence loop + debug: + msg: "{{ item }}" + with_sequence: count=2 + + - name: with_random_choice loop + debug: + msg: "{{ item }}" + with_random_choice: "{{ my_list }}" + + - name: with_first_found loop with static files list + debug: + msg: "{{ item }}" + with_first_found: + - foo.txt + - bar.txt + + - name: with_first_found loop with list of filenames + debug: + msg: "{{ item }}" + with_first_found: "{{ my_filenames }}" + + - name: with_indexed_items loop + debug: + msg: "{{ item.0 }} {{ item.1 }}" + with_indexed_items: "{{ my_list }}" + + - name: with_ini loop + debug: + msg: "{{ item }}" + with_ini: value[1-2] section=section1 file=foo.ini re=true + + - name: with_flattened loop + debug: + msg: "{{ item }}" + with_flattened: + - "{{ my_list }}" + - "{{ my_list2 }}" + + - name: with_flattened loop with a variable + debug: + msg: "{{ item }}" + with_flattened: "{{ my_list_of_lists }}" + + - name: with_flattened loop with a multiline template + debug: + msg: "{{ item }}" + with_flattened: > + {{ my_list + | union(my_list2) + | list }} + + - name: with_inventory_hostnames loop + debug: + msg: "{{ item }}" + with_inventory_hostnames: all diff --git a/test/varset.yml b/test/varset.yml new file mode 100644 index 0000000..fa28db9 --- /dev/null +++ b/test/varset.yml @@ -0,0 +1,3 @@ +- debug: msg="var was set" + +- git: repo=hello.git diff --git a/test/varunset.yml b/test/varunset.yml new file mode 100644 index 0000000..9e8a891 --- /dev/null +++ b/test/varunset.yml @@ -0,0 +1 @@ +- debug: msg="var was not set" diff --git a/test/with-skip-tag-id.yml b/test/with-skip-tag-id.yml new file mode 100644 index 0000000..12d2fb7 --- /dev/null +++ b/test/with-skip-tag-id.yml @@ -0,0 +1,6 @@ +- hosts: all + tasks: + - name: trailing whitespace on this line + git: + repo: '{{ archive_services_repo_url }}' + dest: '/home/www' |