示例#1
0
    def test_task_config(self):
        # Ensure that doit.cfg specified task parameters are applied.

        cmd = Command()
        members = {
            'task_foo': lambda: {
                'actions': [],
                'params': [{
                    'name': 'x',
                    'default': None,
                    'long': 'x'
                }]
            },
            'DOIT_CONFIG': {
                'task:foo': {
                    'x': 1
                }
            },
        }
        loader = ModuleTaskLoader(members)
        loader.setup({})
        loader.config = loader.load_doit_config()
        task_list = loader.load_tasks(cmd, [])
        task = task_list.pop()
        task.init_options()
        assert 1 == task.options['x']
示例#2
0
 def test_load_tasks_from_module(self):
     import tests.module_with_tasks as module
     loader = ModuleTaskLoader(module)
     loader.setup({})
     config = loader.load_doit_config()
     task_list = loader.load_tasks(Command(), [])
     assert ['xxx1'] == [t.name for t in task_list]
     assert {'verbose': 2} == config
示例#3
0
 def test_load_tasks(self):
     cmd = Command()
     members = {'task_xxx1': lambda : {'actions':[]},
                'task_no': 'strings are not tasks',
                'blabla': lambda :None,
                'DOIT_CONFIG': {'verbose': 2},
                }
     loader = ModuleTaskLoader(members)
     task_list, config = loader.load_tasks(cmd, {}, [])
     assert ['xxx1'] == [t.name for t in task_list]
     assert {'verbose': 2} == config
示例#4
0
 def test_load_tasks(self, restore_cwd):
     os.chdir(os.path.dirname(__file__))
     cmd = Command()
     params = {'dodoFile': 'loader_sample.py',
               'cwdPath': None,
               'seek_file': False,
               }
     loader = DodoTaskLoader()
     task_list, config = loader.load_tasks(cmd, params, [])
     assert ['xxx1', 'yyy2'] == [t.name for t in task_list]
     assert {'verbose': 2} == config
示例#5
0
    def test_cmd_arg_list(self):
        no_args = TabCompletion._zsh_arg_list(Command())
        assert "'*::task:(($tasks))'" not in no_args
        assert "'::cmd:(($commands))'" not in no_args

        class CmdTakeTasks(Command):
            doc_usage = '[TASK ...]'
        with_task_args = TabCompletion._zsh_arg_list(CmdTakeTasks())
        assert "'*::task:(($tasks))'" in with_task_args
        assert "'::cmd:(($commands))'" not in with_task_args

        class CmdTakeCommands(Command):
            doc_usage = '[COMMAND ...]'
        with_cmd_args = TabCompletion._zsh_arg_list(CmdTakeCommands())
        assert "'*::task:(($tasks))'" not in with_cmd_args
        assert "'::cmd:(($commands))'" in with_cmd_args
示例#6
0
 def __init__(self, *args, **kwargs):
     BasePlugin.__init__(self, *args, **kwargs)
     DoitCommand.__init__(self)
示例#7
0
 def __init__(self, *args, **kwargs):
     BasePlugin.__init__(self, *args, **kwargs)
     DoitCommand.__init__(self)
示例#8
0
 def __call__(self, config=None, **kwargs):
     """Reset doit arguments (workaround)."""
     self._doitargs = kwargs
     DoitCommand.__init__(self, config, **kwargs)
     return self
示例#9
0
 def __init__(self, *args, **kwargs):
     """Initialize a command."""
     BasePlugin.__init__(self, *args, **kwargs)
     DoitCommand.__init__(self)
示例#10
0
 def __call__(self, config=None, **kwargs):
     self._doitargs = kwargs
     DoitCommand.__init__(self, config, **kwargs)
     return self
示例#11
0
 def __call__(self, config=None, **kwargs):
     self._doitargs = kwargs
     DoitCommand.__init__(self, config, **kwargs)
     return self
示例#12
0
def test_task(monkeypatch, depfile_name, capsys):
    """Tests that our various task generation mechanisms work"""
    @pytask(title="custom title")
    def a():
        """ hey """
        print("hello !")

    @pytask(task_dep=[a])
    def b():
        """ hey! """
        print("hello !!")

    @cmdtask(task_dep=[b])
    def d():
        """ hey!d """
        return """
        echo ola
        # skipped comment
        echo hey
        """

    @taskgen
    def c():
        """ hey!!! """

        # shell commands
        yield task(name="echo",
                   actions=["echo hi"],
                   doc="my echo doc",
                   targets=["hoho.txt"])

        # python task - non-decorator style
        def c_():
            """here is a doc"""
            print("hello")

        yield pytask(c_)

        for i in range(2):
            # python task - decorator style
            @pytask(name="subtask %i" % i,
                    doc="a subtask %s" % i,
                    title="this is %s running" % i)
            def c_():
                print("hello sub")

            yield c_

            # python task - non-decorator style
            def d_():
                print("hello variant")

            yield pytask(name="subtask %i variant" % i,
                         doc="a subtask %s variant" % i,
                         title="this is %s running variant" % i)(d_)

    if sys.version_info < (3, 0):
        # doit version is 0.29 on python 2. Internal api is different.
        pass
    else:
        # manually check that loading the tasks works
        loader = ModuleTaskLoader(locals())
        loader.setup({})
        config = loader.load_doit_config()
        task_list = loader.load_tasks(Command(), [])
        assert len(task_list) == 10

        # Note: unfortunately on python 3.5 and 3.6 the order does not seem guaranteed with this api
        # task a
        task_a = [t for t in task_list if t.name == 'a']
        assert len(task_a) == 1
        task_a = task_a[0]
        assert task_a.name == 'a'
        assert task_a.doc == a.__doc__.strip()
        assert task_a.actions[0].py_callable == why_am_i_running
        assert task_a.actions[1].py_callable == a
        assert task_a.title() == 'a => custom title'

        # task b dependency
        task_b = [t for t in task_list if t.name == 'b']
        assert len(task_b) == 1
        task_b = task_b[0]
        assert task_b.task_dep == ['a']

        # task c with 2 subtasks
        # todo

        # task d
        task_d = [t for t in task_list if t.name == 'd']
        assert len(task_d) == 1
        task_d = task_d[0]
        assert len(task_d.actions) == 2
        _sep = '& ' if platform.system() == 'Windows' else '; '
        assert task_d.actions[1]._action.split(_sep) == [
            "echo ola", "echo hey"
        ]

    # ---- checks : list
    monkeypatch.setattr(sys, 'argv',
                        ['did', 'list', '--all', '--db-file', depfile_name])
    try:
        # run
        run(locals())
    except SystemExit as err:
        assert err.code == 0, "doit execution error"
    else:  # pragma: no cover
        assert False, "Did not receive SystemExit - should not happen"

    captured = capsys.readouterr()
    with capsys.disabled():
        assert captured.out == """a                     hey
b                     hey!
c                     hey!!!
c:c_                  here is a doc
c:echo                my echo doc
c:subtask 0           a subtask 0
c:subtask 0 variant   a subtask 0 variant
c:subtask 1           a subtask 1
c:subtask 1 variant   a subtask 1 variant
d                     hey!d
"""

    # -- checks : execution
    monkeypatch.setattr(sys, 'argv',
                        ['did', '--verbosity', '2', '--db-file', depfile_name])
    try:
        # run
        run(locals())
    except SystemExit as err:
        assert err.code == 0, "doit execution error"
    else:  # pragma: no cover
        assert False, "Did not receive SystemExit - should not happen"

    captured = capsys.readouterr()
    with capsys.disabled():
        assert captured.out.replace("\r", "") == """hello !
hello !!
ola
hey
Running <Task: c:echo> because one of its targets does not exist: 'hoho.txt'
hi
hello
hello sub
hello variant
hello sub
hello variant
"""

    if sys.version_info < (3, 0):
        # doit version is 0.29 on python 2. Internal api is different.
        pass
    else:
        # formal checks:    equivalent of doit list --all
        output = StringIO()
        cmd_list = CmdFactory(List, outstream=output, task_list=task_list)
        cmd_list._execute(subtasks=True, quiet=False)
        assert output.getvalue() == """a                     hey
b                     hey!
c                     hey!!!
c:c_                  here is a doc
c:echo                my echo doc
c:subtask 0           a subtask 0
c:subtask 0 variant   a subtask 0 variant
c:subtask 1           a subtask 1
c:subtask 1 variant   a subtask 1 variant
d                     hey!d
"""

        # formal checks: equivalent of   doit  (execution)
        output = StringIO()
        cmd_run = CmdFactory(Run,
                             backend='dbm',
                             dep_file=depfile_name,
                             task_list=task_list)
        result = cmd_run._execute(output, verbosity=2)
        assert 0 == result
        assert output.getvalue() == """.  a => custom title
.  b => Python: function test_task.<locals>.b
.  d => Cmd: echo ola%secho hey
.  c:echo => Cmd: echo hi
.  c:c_ => Python: function test_task.<locals>.c.<locals>.c_
.  c:subtask 0 => this is 0 running
.  c:subtask 0 variant => this is 0 running variant
.  c:subtask 1 => this is 1 running
.  c:subtask 1 variant => this is 1 running variant
""" % _sep
        captured = capsys.readouterr()
        with capsys.disabled():
            assert captured.out.replace("\r", "") == """hello !
示例#13
0
 def __init__(self) -> None:
     BasePlugin.__init__(self)
     DoitCommand.__init__(self)