def test_context(file_name):
    ctx = context(file=file_name, line=68)
    assert ctx.file == file_name
    assert ctx.line == 68
    ctx = context(file_name, 68)
    assert ctx.file == file_name
    assert ctx.line == 68
def test_line_in_context(file_name):
    line = line_in_context(
        line='a simple line of text',
        context=context(file=file_name, line=45),
    )
    assert line.context.file == file_name
    assert line.context.line == 45
    assert line.line == 'a simple line of text'
    line = line_in_context('a simple line of text', context(file_name, 45))
    assert line.context.file == file_name
    assert line.context.line == 45
    assert line.line == 'a simple line of text'
def test_statement_to_object(file_name):
    statements = add_context(file_name, (
        '# some comment',
        'a_command with:args',
    ))
    expected_objects = (
        comment(' some comment', context(file_name, 1)),
        command('a_command', 'with:args', context(file_name, 2)),
    )
    for sttmt, expected in _it.izip(statements, expected_objects):
        result = statement_to_object(sttmt)
        assert expected == result
def test_add_context(file_name):
    lines = (
        'line1',
        'line2',
        'line3',
    )
    expected = (
        line_in_context(context=context(file=file_name, line=1), line='line1'),
        line_in_context(context=context(file=file_name, line=2), line='line2'),
        line_in_context(context=context(file=file_name, line=3), line='line3'),
    )
    result = tuple(add_context(file=file_name, lines=lines))
    assert expected == result
def test_ast_to_used_files(file_name):
    ast = lines_to_ast((
        '# some comment',
        'run /some/script',
        'copy-in /copyed/dir:/dst/dir',
        'install sopme-pkg',
        '',
        'root-password file:/root/pwd/file',
    ), context_file=file_name)
    expected = (
        used_file('/some/script', context(file_name, 2)),
        used_file('/copyed/dir', context(file_name, 3)),
        used_file('/root/pwd/file', context(file_name, 6)),
    )
    result = tuple(ast_to_used_files(ast))
    assert expected == result
def test_lines_to_ast(file_name):
    lines = (
        '# some comment\n',
        'a_command with:multi\\\n',
        'line args\n',
        'a_command with:args\n',
    )
    expected = (
        comment(' some comment', context(file_name, 7)),
        command('a_command', 'with:multi\nline args', context(file_name, 8)),
        command('a_command', 'with:args', context(file_name, 10)),
    )
    result = tuple(
        lines_to_ast(lines, context_file=file_name, context_start_at=7)
    )
    assert expected == result
def test_lines_to_statements(file_name):
    lines = add_context(file=file_name, lines=(
        'line1\n',
        '  line2  \n',
        'line3 part1\\\n',
        'line3 part2\n',
        'line \\ number 4\n',
        'line5 part1\\\n',
        '  line5\\ part2\\\n',
        'line5 part3\n',
        'line6',
    ))
    expected = (
        line_in_context('line1', context(file_name, 1)),
        line_in_context('  line2  ', context(file_name, 2)),
        line_in_context('line3 part1\nline3 part2', context(file_name, 3)),
        line_in_context('line \\ number 4', context(file_name, 5)),
        line_in_context(
            'line5 part1\n  line5\\ part2\nline5 part3',
            context(file_name, 6)
        ),
        line_in_context('line6', context(file_name, 9)),
    )
    result = tuple(lines_to_statements(lines))
    assert expected == result
def test_perform_ast_include_errors(file_name, fake_open):
    files = {
        'missing.inc': dedent(
            """
            run just_a_command
            commands-from-file really_missing.inc
            """
        ).lstrip(),
        'simple_loop': dedent(
            """
            # a simple include loop
            commands-from-file simple_loop
            """
        ).lstrip(),
        'nested_loop1': dedent(
            """
            # a nested include loop file 1
            commands-from-file nested_loop2
            """
        ).lstrip(),
        'nested_loop2': dedent(
            """
            # a nested include loop file 2
            commands-from-file nested_loop1
            """
        ).lstrip(),
        'script_nested_loop1': dedent(
            """
            # a nested loop via script file 1
            commands-from-shell \
              echo commands-from-file script_nested_loop2
            """
        ).lstrip(),
        'script_nested_loop2': dedent(
            """
            # a nested lopp via script file 2
            commands-from-file script_nested_loop1
            """
        ).lstrip(),
    }
    asts_contexts = (
        (
            lines_to_ast(
                StringIO('commands-from-file simple_missing.inc'),
                file_name
            ),
            context(file_name, 1),
        ),
        (
            lines_to_ast(StringIO('commands-from-file missing.inc')),
            context('missing.inc', 2),
        ),
        (
            lines_to_ast(StringIO('commands-from-file simple_loop')),
            context('simple_loop', 2),
        ),
        (
            lines_to_ast(StringIO('commands-from-file nested_loop1')),
            context('nested_loop2', 2),
        ),
        (
            lines_to_ast(StringIO('commands-from-file script_nested_loop1')),
            context('script_nested_loop2', 2),
        ),
    )
    for ast, ctx in asts_contexts:
        with pytest.raises(VirtSyntaxError) as err:
            with fake_open(files):
                t = tuple(perform_ast_includes(ast))
                print(t)
        assert ctx == err.value.context
def test_perform_ast_includes(file_name, fake_open):
    files = {
        'file1.inc': dedent(
            """
            run /file1/arg1
            write /file1/arg2:long\\
            input
            """
        ).lstrip(),
        'incdir/file2.inc': dedent(
            """
            # file2 comment
            run /file2/script
            commands-from-file file3.inc
            commands-from-shell \\
                echo "# shell ctx: $VIRT_COMMAND_FILE ($VIRT_COMMAND_LINE)" \\
                echo "root-password password:foo"
            write /last/file2:command
            """
        ).lstrip(),
        'incdir/file3.inc': dedent(
            """
            # file3 comment
            run file3_command
            """
        ).lstrip(),
        'file4': dedent(
            """
            # will be included from script
            """
        ).lstrip(),
    }
    ast = lines_to_ast(StringIO(dedent(
        """
        # The main AST
        commands-from-file file1.inc
        commands-from-file incdir/file2.inc
        commands-from-shell \\
            echo "# shell comment" \\
            echo commands-from-file file4
        selinux-relabel
        """
    ).lstrip()), context_file=file_name)
    expected = (
        comment(' The main AST', context(file_name, 1)),
        # commands-from-file file1.inc
        command('run', '/file1/arg1', context('file1.inc', 1)),
        command('write', '/file1/arg2:long\ninput', context('file1.inc', 2)),
        # commands-from-file file2.inc
        comment(' file2 comment', context('incdir/file2.inc', 1)),
        command('run', '/file2/script', context('incdir/file2.inc', 2)),
        # commands-from-file file3.inc (in file2)
        comment(' file3 comment', context('incdir/file3.inc', 1)),
        command('run', 'file3_command', context('incdir/file3.inc', 2)),
        # commands-from-shell (in file2)
        comment(
            " shell ctx: incdir/file2.inc (4)",
            nested_context(
                'script<incdir/file2.inc (4)>', 1,
                context('incdir/file2.inc', 4)
            )
        ),
        command(
            'root-password', 'password:foo',
            nested_context(
                'script<incdir/file2.inc (4)>', 2,
                context('incdir/file2.inc', 4)
            )
        ),
        # back to file2
        command(
            'write', '/last/file2:command',
            context('incdir/file2.inc', 7)
        ),
        # commands-from-shell (in main ast)
        comment(
            " shell comment",
            nested_context(
                'script<{0} (4)>'.format(file_name), 1,
                context(file_name, 4)
            ),
        ),
        # commands-from-file file4
        comment(' will be included from script', context('file4', 1)),
        # back to main
        command('selinux-relabel', None, context(file_name, 7)),
    )
    with fake_open(files):
        result = tuple(perform_ast_includes(ast))
    assert expected == result
 def gen_func(i):
     return context(file=file_name, line=i)

def test_shell_cmd_to_ast_errors(some_context):
    with pytest.raises(VirtSyntaxError) as err:
        tuple(shell_cmd_to_ast('false\n', some_context))
    assert some_context == err.value.context
    with pytest.raises(VirtSyntaxError) as err:
        tuple(shell_cmd_to_ast('false\ntrue\n', some_context))
    assert some_context == err.value.context


@pytest.mark.parametrize(
    ('given', 'inc_ctx', 'expected'),
    [
        ('/abs/inc', None, '/abs/inc'),
        ('/abs/inc', context('foo', 1), '/abs/inc'),
        ('/abs/inc', nested_context('bar', 1, context('foo', 1)), '/abs/inc'),
        ('inc', context('parent', 1), 'inc'),
        ('inc', context('dir/parent', 1), 'dir/inc'),
        ('inc', nested_context('bar', 1, context('f', 1)), 'inc'),
        ('inc', nested_context('bar', 1, context('hdir/f', 1)), 'hdir/inc'),
    ]
)
def test_find_included_file(given, inc_ctx, expected):
    result = find_included_file(given, inc_ctx)
    assert expected == result


def test_perform_ast_includes(file_name, fake_open):
    files = {
        'file1.inc': dedent(