Ejemplo n.º 1
0
def test_normalize(reference_form: Dict[str, Any],
                   alternate_forms: Tuple[Dict[str, Any]]) -> None:
    """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')
Ejemplo n.º 2
0
 def test_normalize_task_is_idempotent(self):
     tasks = list()
     tasks.append(dict(name="hello", action={'module': 'ec2', 'region': 'us-east1', 'etc': 'whatever'}))
     tasks.append(dict(name="hello", ec2={'region': 'us-east1', 'etc': 'whatever'}))
     tasks.append(dict(name="hello", ec2="region=us-east1 etc=whatever"))
     tasks.append(dict(name="hello", action="ec2 region=us-east1 etc=whatever"))
     for task in tasks:
         normalized_task = utils.normalize_task(task)
         self.assertEquals(normalized_task, utils.normalize_task(normalized_task))
Ejemplo n.º 3
0
 def test_normalize_task_is_idempotent(self):
     tasks = list()
     tasks.append(dict(name="hello", action={"module": "ec2", "region": "us-east1", "etc": "whatever"}))
     tasks.append(dict(name="hello", ec2={"region": "us-east1", "etc": "whatever"}))
     tasks.append(dict(name="hello", ec2="region=us-east1 etc=whatever"))
     tasks.append(dict(name="hello", action="ec2 region=us-east1 etc=whatever"))
     for task in tasks:
         normalized_task = utils.normalize_task(task)
         self.assertEqual(normalized_task, utils.normalize_task(normalized_task))
Ejemplo n.º 4
0
 def test_normalize_task_is_idempotent(self):
     tasks = list()
     tasks.append(dict(name="hello", action={'module': 'ec2',
                                             'region': 'us-east1',
                                             'etc': 'whatever'}))
     tasks.append(dict(name="hello", ec2={'region': 'us-east1', 'etc': 'whatever'}))
     tasks.append(dict(name="hello", ec2="region=us-east1 etc=whatever"))
     tasks.append(dict(name="hello", action="ec2 region=us-east1 etc=whatever"))
     for task in tasks:
         normalized_task = utils.normalize_task(task)
         self.assertEqual(normalized_task, utils.normalize_task(normalized_task))
Ejemplo n.º 5
0
def yaml_form_rather_than_key_value(candidate, settings):
    with codecs.open(candidate.path, mode='rb', encoding='utf-8') as f:
        content = parse_yaml_linenumbers(f.read(), candidate.path)
    errors = []
    if content:
        fileinfo = dict(type=candidate.filetype, path=candidate.path)
        for task in get_action_tasks(content, fileinfo):
            normal_form = normalize_task(task, candidate.path)
            action = normal_form['action']['__ansible_module__']
            arguments = normal_form['action']['__ansible_arguments__']
            # Cope with `set_fact` where task['set_fact'] is None
            if not task.get(action):
                continue
            if isinstance(task[action], dict):
                continue
            # allow skipping based on tag e.g. if using splatting
            # https://docs.ansible.com/ansible/devel/reference_appendices\
            # /faq.html#argsplat-unsafe
            if 'skip_ansible_lint' in (task.get('tags') or []):
                continue
            # strip additional newlines off task[action]
            if task[action].strip().split() != arguments:
                errors.append(Error(task['__line__'], "Task arguments appear "
                                    "to be in key value rather "
                                    "than YAML format"))
    return Result(candidate.path, errors)
Ejemplo n.º 6
0
    def test_normalize_task_is_idempotent(self):
        tasks = list()
        tasks.append(dict(name="hello", action={'module': 'ec2',
                                                'region': 'us-east1',
                                                'etc': 'whatever'}))
        tasks.append(dict(name="hello", ec2={'region': 'us-east1', 'etc': 'whatever'}))
        tasks.append(dict(name="hello", ec2="region=us-east1 etc=whatever"))
        tasks.append(dict(name="hello", action="ec2 region=us-east1 etc=whatever"))
        for task in tasks:
            normalized_task = utils.normalize_task(task, 'tasks.yml')
            normalized_task['action']['module'] = normalized_task['action']['__ansible_module__']
            del normalized_task['action']['__ansible_module__']

            renormalized_task = utils.normalize_task(dict(normalized_task), 'tasks.yml')
            renormalized_task['action']['module'] = renormalized_task['action']['__ansible_module__']
            del renormalized_task['action']['__ansible_module__']

            self.assertEqual(normalized_task, renormalized_task)
Ejemplo n.º 7
0
    def test_normalize_args(self):
        task1 = {
            'git': {
                'version': 'abc'
            },
            'args': {
                'repo': 'blah',
                'dest': 'xyz'
            }
        }
        task2 = {'git': {'version': 'abc', 'repo': 'blah', 'dest': 'xyz'}}

        task3 = {"git": 'version=abc repo=blah dest=xyz'}
        task4 = {
            "git": None,
            "args": {
                'repo': 'blah',
                'dest': 'xyz',
                'version': 'abc'
            }
        }
        self.assertEqual(utils.normalize_task(task1, 'tasks.yml'),
                         utils.normalize_task(task2, 'tasks.yml'))
        self.assertEqual(utils.normalize_task(task1, 'tasks.yml'),
                         utils.normalize_task(task3, 'tasks.yml'))
        self.assertEqual(utils.normalize_task(task1, 'tasks.yml'),
                         utils.normalize_task(task4, 'tasks.yml'))
Ejemplo n.º 8
0
 def test_normalize_complex_command(self):
     task1 = dict(name="hello", action={"module": "ec2", "region": "us-east1", "etc": "whatever"})
     task2 = dict(name="hello", ec2={"region": "us-east1", "etc": "whatever"})
     task3 = dict(name="hello", ec2="region=us-east1 etc=whatever")
     task4 = dict(name="hello", action="ec2 region=us-east1 etc=whatever")
     self.assertEqual(utils.normalize_task(task1), utils.normalize_task(task2))
     self.assertEqual(utils.normalize_task(task2), utils.normalize_task(task3))
     self.assertEqual(utils.normalize_task(task3), utils.normalize_task(task4))
Ejemplo n.º 9
0
 def test_normalize_complex_command(self):
     task1 = dict(name="hello", action={'module': 'ec2', 'region': 'us-east1', 'etc': 'whatever'})
     task2 = dict(name="hello", ec2={'region': 'us-east1', 'etc': 'whatever'})
     task3 = dict(name="hello", ec2="region=us-east1 etc=whatever")
     task4 = dict(name="hello", action="ec2 region=us-east1 etc=whatever")
     self.assertEquals(utils.normalize_task(task1), utils.normalize_task(task2))
     self.assertEquals(utils.normalize_task(task2), utils.normalize_task(task3))
     self.assertEquals(utils.normalize_task(task3), utils.normalize_task(task4))
Ejemplo n.º 10
0
    def test_normalize_args(self):
        task1 = dict(git={'version': 'abc'}, args={'repo': 'blah', 'dest': 'xyz'})
        task2 = dict(git={'version': 'abc', 'repo': 'blah', 'dest': 'xyz'})

        task3 = dict(git='version=abc repo=blah dest=xyz')
        task4 = dict(git=None, args={'repo': 'blah', 'dest': 'xyz', 'version': 'abc'})
        self.assertEqual(utils.normalize_task(task1, 'tasks.yml'), utils.normalize_task(task2, 'tasks.yml'))
        self.assertEqual(utils.normalize_task(task1, 'tasks.yml'), utils.normalize_task(task3, 'tasks.yml'))
        self.assertEqual(utils.normalize_task(task1, 'tasks.yml'), utils.normalize_task(task4, 'tasks.yml'))
Ejemplo n.º 11
0
def test_normalize_complex_command():
    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')
Ejemplo n.º 12
0
 def test_normalize_complex_command(self):
     task1 = dict(name="hello", action={'module': 'ec2',
                                        'region': 'us-east1',
                                        'etc': 'whatever'})
     task2 = dict(name="hello", ec2={'region': 'us-east1',
                                     'etc': 'whatever'})
     task3 = dict(name="hello", ec2="region=us-east1 etc=whatever")
     task4 = dict(name="hello", action="ec2 region=us-east1 etc=whatever")
     self.assertEqual(utils.normalize_task(task1, 'tasks.yml'), utils.normalize_task(task2, 'tasks.yml'))
     self.assertEqual(utils.normalize_task(task2, 'tasks.yml'), utils.normalize_task(task3, 'tasks.yml'))
     self.assertEqual(utils.normalize_task(task3, 'tasks.yml'), utils.normalize_task(task4, 'tasks.yml'))
Ejemplo n.º 13
0
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')
Ejemplo n.º 14
0
def yaml_form_rather_than_key_value(candidate, settings):
    with codecs.open(candidate.path, mode='rb', encoding='utf-8') as f:
        content = parse_yaml_linenumbers(f.read(), candidate.path)
    errors = []
    if content:
        fileinfo = dict(type=candidate.filetype, path=candidate.path)
        for task in get_action_tasks(content, fileinfo):
            normal_form = normalize_task(task, candidate.path)
            action = normal_form['action']['__ansible_module__']
            arguments = normal_form['action']['__ansible_arguments__']
            # FIXME: This is a bug - perhaps when connection is local
            # or similar
            if action not in task:
                continue
            if isinstance(task[action], dict):
                continue
            if task[action] != ' '.join(arguments):
                errors.append(Error(task['__line__'], "Task arguments appear "
                                    "to be in key value rather "
                                    "than YAML format"))
    return Result(candidate.path, errors)
Ejemplo n.º 15
0
def yaml_form_rather_than_key_value(candidate, settings):
    with codecs.open(candidate.path, mode='rb', encoding='utf-8') as f:
        content = parse_yaml_linenumbers(f.read(), candidate.path)
    errors = []
    if content:
        fileinfo = dict(type=candidate.filetype, path=candidate.path)
        for task in get_action_tasks(content, fileinfo):
            normal_form = normalize_task(task, candidate.path)
            action = normal_form['action']['__ansible_module__']
            arguments = normal_form['action']['__ansible_arguments__']
            # Cope with `set_fact` where task['set_fact'] is None
            if not task.get(action):
                continue
            if isinstance(task[action], dict):
                continue
            # strip additional newlines off task[action]
            if task[action].strip().split() != arguments:
                errors.append(Error(task['__line__'], "Task arguments appear "
                                    "to be in key value rather "
                                    "than YAML format"))
    return Result(candidate.path, errors)
Ejemplo n.º 16
0
def yaml_form_rather_than_key_value(candidate, settings):
    with codecs.open(candidate.path, mode='rb', encoding='utf-8') as f:
        content = parse_yaml_linenumbers(f.read(), candidate.path)
    errors = []
    if content:
        fileinfo = dict(type=candidate.filetype, path=candidate.path)
        for task in get_action_tasks(content, fileinfo):
            normal_form = normalize_task(task, candidate.path)
            action = normal_form['action']['__ansible_module__']
            arguments = normal_form['action']['__ansible_arguments__']
            # Cope with `set_fact` where task['set_fact'] is None
            if not task.get(action):
                continue
            if isinstance(task[action], dict):
                continue
            # strip additional newlines off task[action]
            if task[action].strip().split() != arguments:
                errors.append(
                    Error(
                        task['__line__'], "Task arguments appear "
                        "to be in key value rather "
                        "than YAML format"))
    return Result(candidate.path, errors)
Ejemplo n.º 17
0
def yaml_form_rather_than_key_value(candidate, settings):
    with codecs.open(candidate.path, mode='rb', encoding='utf-8') as f:
        content = parse_yaml_linenumbers(f.read(), candidate.path)
    errors = []
    if content:
        fileinfo = dict(type=candidate.filetype, path=candidate.path)
        for task in get_action_tasks(content, fileinfo):
            normal_form = normalize_task(task, candidate.path)
            action = normal_form['action']['__ansible_module__']
            arguments = normal_form['action']['__ansible_arguments__']
            # FIXME: This is a bug - perhaps when connection is local
            # or similar
            if action not in task:
                continue
            if isinstance(task[action], dict):
                continue
            if task[action] != ' '.join(arguments):
                errors.append(
                    Error(
                        task['__line__'], "Task arguments appear "
                        "to be in key value rather "
                        "than YAML format"))
    return Result(candidate.path, errors)
Ejemplo n.º 18
0
def test_task_to_str_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 é ô à"
Ejemplo n.º 19
0
 def test_normalize_simple_command(self):
     task1 = dict(name="hello", action="command chdir=abc echo hello world")
     task2 = dict(name="hello", command="chdir=abc echo hello world")
     self.assertEqual(utils.normalize_task(task1, 'tasks.yml'), utils.normalize_task(task2, 'tasks.yml'))
Ejemplo n.º 20
0
 def test_task_to_str_unicode(self):
     task = dict(fail=dict(msg=u"unicode é ô à"))
     result = utils.task_to_str(utils.normalize_task(task, 'filename.yml'))
     self.assertEqual(result, u"fail msg=unicode é ô à")
Ejemplo n.º 21
0
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')
Ejemplo n.º 22
0
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 é ô à"
Ejemplo n.º 23
0
 def test_task_to_str_unicode(self):
     task = dict(fail=dict(msg=u"unicode é ô à"))
     result = utils.task_to_str(utils.normalize_task(task, 'filename.yml'))
     self.assertEqual(result, u"fail msg=unicode é ô à")
Ejemplo n.º 24
0
def test_normalize(reference_form, alternate_forms):
    normal_form = utils.normalize_task(reference_form, 'tasks.yml')

    for form in alternate_forms:
        assert normal_form == utils.normalize_task(form, 'tasks.yml')