cook-build 0.2.0__tar.gz → 0.2.1__tar.gz

{cook-build-0.2.0/cook_build.egg-info → cook-build-0.2.1}/PKG-INFO

@@ -1,6 +1,7 @@
 Metadata-Version: 2.1
 Name: cook-build
-Version: 0.2.0
+Version: 0.2.1
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 
@@ -21,6 +22,7 @@ Tasks are declared in a :code:`recipe.py` file using the :code:`~cook.manager.cr
 
 .. code-block::
 
+
     >>> from cook import create_task
 
     >>> create_task("src", targets=["hello.c"],
@@ -31,40 +33,48 @@ Tasks are declared in a :code:`recipe.py` file using the :code:`~cook.manager.cr
 
 Running :code:`cook ls` from the command line lists all known tasks, e.g.,
 
-.. code-block:: bash
+.. code-block::
+
+    :cwd: examples/getting_started
 
     $ cook ls
     <task `src` @ /.../recipe.py:3>
-    <task `cc` @ /.../recipe.py:5>
-    <task `hello` @ /.../recipe.py:7>
+    <task `cc` @ /.../recipe.py:4>
+    <task `hello` @ /.../recipe.py:5>
 
 Running :code:`cook exec hello` creates the source file, compile it, and executes the binary. We use :code:`--log-level=debug` to provide additional information here.
 
-.. code-block:: bash
-
-    $ cook --log-level=debug exec hello
-    DEBUG: <task `src` @ ...> is stale because one of its targets is missing
-    DEBUG: started <task `src` @ ...>
-    DEBUG: completed <task `src` @ ...> in ... seconds
-    DEBUG: `<task `src` @ ...>` created `hello.c`
+.. code-block::
 
-    DEBUG: <task `cc` @ ...> is stale because its dependency `hello.c` does not have a hash entry
-    DEBUG: started <task `cc` @ ...>
-    DEBUG: completed <task `cc` @ ...> in ... seconds
-    DEBUG: `<task `cc` @ ...>` created `hello`
+    :cwd: examples/getting_started
+    :stderr:
 
-    DEBUG: <task `hello` @ ...> is "stale" because it has no targets
-    DEBUG: started <task `hello` @ ...>
-    DEBUG: completed <task `hello` @ ...> in ... seconds
+    $ cook --log-level=debug exec hello
+    DEBUG: <task `src` @ .../recipe.py:3> is stale because one of its targets is missing
+    DEBUG: started <task `src` @ .../recipe.py:3>
+    DEBUG: completed <task `src` @ .../recipe.py:3> in ... seconds
+    DEBUG: <task `src` @ .../recipe.py:3> created `hello.c`
+    DEBUG: <task `cc` @ .../recipe.py:4> is stale because one of its targets is missing
+    DEBUG: started <task `cc` @ .../recipe.py:4>
+    DEBUG: completed <task `cc` @ .../recipe.py:4> in ... seconds
+    DEBUG: <task `cc` @ .../recipe.py:4> created `hello`
+    DEBUG: <task `hello` @ .../recipe.py:5> is "stale" because it has no targets
+    DEBUG: started <task `hello` @ .../recipe.py:5>
+    DEBUG: completed <task `hello` @ .../recipe.py:5> in ... seconds
 
 To rerun a task, tell Cook to reset it.
 
-.. code-block:: bash
+.. code-block::
+
+    :cwd: examples/getting_started
+    :stderr:
 
     $ cook reset cc
     INFO: reset 1 task
 
-The full set of available commands can be explored using :code:`cook --help`.
+The full set of available commands can be explored using :code:`cook --help` as shown below.
+
+.. cook --help
 
 Tasks Are Dumb; Contexts Are Smart
 ----------------------------------

{cook-build-0.2.0 → cook-build-0.2.1}/README.rst

@@ -25,40 +25,45 @@ Tasks are declared in a :code:`recipe.py` file using the :func:`~cook.manager.cr
 
 Running :code:`cook ls` from the command line lists all known tasks, e.g.,
 
-.. code-block:: bash
+.. shtest::
+    :cwd: examples/getting_started
 
     $ cook ls
     <task `src` @ /.../recipe.py:3>
-    <task `cc` @ /.../recipe.py:5>
-    <task `hello` @ /.../recipe.py:7>
+    <task `cc` @ /.../recipe.py:4>
+    <task `hello` @ /.../recipe.py:5>
 
 Running :code:`cook exec hello` creates the source file, compile it, and executes the binary. We use :code:`--log-level=debug` to provide additional information here.
 
-.. code-block:: bash
+.. shtest::
+    :cwd: examples/getting_started
+    :stderr:
 
     $ cook --log-level=debug exec hello
-    DEBUG: <task `src` @ ...> is stale because one of its targets is missing
-    DEBUG: started <task `src` @ ...>
-    DEBUG: completed <task `src` @ ...> in ... seconds
-    DEBUG: `<task `src` @ ...>` created `hello.c`
-
-    DEBUG: <task `cc` @ ...> is stale because its dependency `hello.c` does not have a hash entry
-    DEBUG: started <task `cc` @ ...>
-    DEBUG: completed <task `cc` @ ...> in ... seconds
-    DEBUG: `<task `cc` @ ...>` created `hello`
-
-    DEBUG: <task `hello` @ ...> is "stale" because it has no targets
-    DEBUG: started <task `hello` @ ...>
-    DEBUG: completed <task `hello` @ ...> in ... seconds
+    DEBUG: <task `src` @ .../recipe.py:3> is stale because one of its targets is missing
+    DEBUG: started <task `src` @ .../recipe.py:3>
+    DEBUG: completed <task `src` @ .../recipe.py:3> in ... seconds
+    DEBUG: <task `src` @ .../recipe.py:3> created `hello.c`
+    DEBUG: <task `cc` @ .../recipe.py:4> is stale because one of its targets is missing
+    DEBUG: started <task `cc` @ .../recipe.py:4>
+    DEBUG: completed <task `cc` @ .../recipe.py:4> in ... seconds
+    DEBUG: <task `cc` @ .../recipe.py:4> created `hello`
+    DEBUG: <task `hello` @ .../recipe.py:5> is "stale" because it has no targets
+    DEBUG: started <task `hello` @ .../recipe.py:5>
+    DEBUG: completed <task `hello` @ .../recipe.py:5> in ... seconds
 
 To rerun a task, tell Cook to reset it.
 
-.. code-block:: bash
+.. shtest::
+    :cwd: examples/getting_started
+    :stderr:
 
     $ cook reset cc
     INFO: reset 1 task
 
-The full set of available commands can be explored using :code:`cook --help`.
+The full set of available commands can be explored using :code:`cook --help` as shown below.
+
+.. sh:: cook --help
 
 Tasks Are Dumb; Contexts Are Smart
 ----------------------------------

{cook-build-0.2.0 → cook-build-0.2.1}/cook/__main__.py

@@ -63,6 +63,7 @@ class Command:
 class ExecArgs(argparse.Namespace):
     tasks: Iterable[re.Pattern]
     re: bool
+    jobs: int
 
 
 class ExecCommand(Command):
@@ -74,10 +75,13 @@ class ExecCommand(Command):
     def configure_parser(self, parser: argparse.ArgumentParser) -> None:
         parser.add_argument("--re", "-r", action="store_true",
                             help="use regular expressions for pattern matching instead of glob")
+        parser.add_argument("--jobs", "-j", help="number of concurrent jobs", type=int, default=1)
         parser.add_argument("tasks", nargs="+",
                             help="task or tasks to execute as regular expressions")
 
     def execute(self, controller: Controller, args: ExecArgs) -> None:
+        # Monkeypatch the controller semaphore.
+        controller.num_concurrent = args.jobs
         tasks = discover_tasks(controller.manager, args.tasks, args.re)
         controller.execute_sync(*tasks)
 

{cook-build-0.2.0 → cook-build-0.2.1}/cook/controller.py

@@ -3,6 +3,7 @@ import logging
 import os
 from pathlib import Path
 from sqlite3 import Connection
+import sys
 from typing import Dict, Iterable, Optional, Set, Tuple, TYPE_CHECKING, Union
 from . import util
 
@@ -41,7 +42,17 @@ class Controller:
         self.status: Dict[Task, bool] = {}
         self.futures: Dict[Task, asyncio.Future] = {}
         self.size_digest: Dict[str, Tuple[int, str]] = {}
-        self.semaphore = asyncio.Semaphore(num_concurrent)
+        self.num_concurrent = num_concurrent
+        self._semaphore = None
+        self.cancelled = False
+
+    @property
+    def semaphore(self) -> asyncio.Semaphore:
+        # Create the semaphore upon first use for python 3.9 and below (see
+        # https://stackoverflow.com/a/55918049/1150961 for details).
+        if self._semaphore is None:
+            self._semaphore = asyncio.Semaphore(self.num_concurrent)
+        return self._semaphore
 
     def resolve_stale_tasks(self, tasks: Optional[Iterable["Task"]] = None) -> Set["Task"]:
         tasks = tasks or self.manager.tasks.values()
@@ -115,6 +126,9 @@ class Controller:
         return self.status.setdefault(task, self._is_self_stale(task))
 
     async def execute(self, task: "Task") -> None:
+        if self.cancelled:  # pragma: no cover
+            return
+
         # If there already is a future, just wait for it and return.
         if future := self.futures.get(task):
             await future
@@ -140,7 +154,7 @@ class Controller:
                 for target in task.targets:
                     if not target.is_file():
                         raise FileNotFoundError(f"`{task}` did not create `{target}`")
-                    LOGGER.debug("`%s` created `%s`", task, target)
+                    LOGGER.debug("%s created `%s`", task, target)
 
                 # Update the state and write to the database.
                 self.status[task] = False
@@ -159,10 +173,17 @@ class Controller:
             error = util.FailedTaskError(message, task=task)
             error.__cause__ = ex
             future.set_exception(error)
+            # Cancel all other futures.
+            self.cancelled = True
+            for future in self.futures.values():
+                future.cancel(message) if sys.version_info[:2] > (3, 8) else future.cancel()
         else:
             future.set_result(None)
 
-        await future
+        try:
+            await future
+        except asyncio.CancelledError:  # pragma: no cover
+            pass
 
     def execute_sync(self, *tasks: "Task") -> None:
         util.run_until_complete(*(self.execute(task) for task in tasks))

{cook-build-0.2.0 → cook-build-0.2.1/cook_build.egg-info}/PKG-INFO

@@ -1,6 +1,7 @@
 Metadata-Version: 2.1
 Name: cook-build
-Version: 0.2.0
+Version: 0.2.1
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 
@@ -21,6 +22,7 @@ Tasks are declared in a :code:`recipe.py` file using the :code:`~cook.manager.cr
 
 .. code-block::
 
+
     >>> from cook import create_task
 
     >>> create_task("src", targets=["hello.c"],
@@ -31,40 +33,48 @@ Tasks are declared in a :code:`recipe.py` file using the :code:`~cook.manager.cr
 
 Running :code:`cook ls` from the command line lists all known tasks, e.g.,
 
-.. code-block:: bash
+.. code-block::
+
+    :cwd: examples/getting_started
 
     $ cook ls
     <task `src` @ /.../recipe.py:3>
-    <task `cc` @ /.../recipe.py:5>
-    <task `hello` @ /.../recipe.py:7>
+    <task `cc` @ /.../recipe.py:4>
+    <task `hello` @ /.../recipe.py:5>
 
 Running :code:`cook exec hello` creates the source file, compile it, and executes the binary. We use :code:`--log-level=debug` to provide additional information here.
 
-.. code-block:: bash
-
-    $ cook --log-level=debug exec hello
-    DEBUG: <task `src` @ ...> is stale because one of its targets is missing
-    DEBUG: started <task `src` @ ...>
-    DEBUG: completed <task `src` @ ...> in ... seconds
-    DEBUG: `<task `src` @ ...>` created `hello.c`
+.. code-block::
 
-    DEBUG: <task `cc` @ ...> is stale because its dependency `hello.c` does not have a hash entry
-    DEBUG: started <task `cc` @ ...>
-    DEBUG: completed <task `cc` @ ...> in ... seconds
-    DEBUG: `<task `cc` @ ...>` created `hello`
+    :cwd: examples/getting_started
+    :stderr:
 
-    DEBUG: <task `hello` @ ...> is "stale" because it has no targets
-    DEBUG: started <task `hello` @ ...>
-    DEBUG: completed <task `hello` @ ...> in ... seconds
+    $ cook --log-level=debug exec hello
+    DEBUG: <task `src` @ .../recipe.py:3> is stale because one of its targets is missing
+    DEBUG: started <task `src` @ .../recipe.py:3>
+    DEBUG: completed <task `src` @ .../recipe.py:3> in ... seconds
+    DEBUG: <task `src` @ .../recipe.py:3> created `hello.c`
+    DEBUG: <task `cc` @ .../recipe.py:4> is stale because one of its targets is missing
+    DEBUG: started <task `cc` @ .../recipe.py:4>
+    DEBUG: completed <task `cc` @ .../recipe.py:4> in ... seconds
+    DEBUG: <task `cc` @ .../recipe.py:4> created `hello`
+    DEBUG: <task `hello` @ .../recipe.py:5> is "stale" because it has no targets
+    DEBUG: started <task `hello` @ .../recipe.py:5>
+    DEBUG: completed <task `hello` @ .../recipe.py:5> in ... seconds
 
 To rerun a task, tell Cook to reset it.
 
-.. code-block:: bash
+.. code-block::
+
+    :cwd: examples/getting_started
+    :stderr:
 
     $ cook reset cc
     INFO: reset 1 task
 
-The full set of available commands can be explored using :code:`cook --help`.
+The full set of available commands can be explored using :code:`cook --help` as shown below.
+
+.. cook --help
 
 Tasks Are Dumb; Contexts Are Smart
 ----------------------------------

{cook-build-0.2.0 → cook-build-0.2.1}/cook_build.egg-info/SOURCES.txt

@@ -15,4 +15,11 @@ cook_build.egg-info/SOURCES.txt
 cook_build.egg-info/dependency_links.txt
 cook_build.egg-info/entry_points.txt
 cook_build.egg-info/requires.txt
-cook_build.egg-info/top_level.txt
+cook_build.egg-info/top_level.txt
+tests/test_actions.py
+tests/test_contexts.py
+tests/test_controller.py
+tests/test_examples.py
+tests/test_main.py
+tests/test_manager.py
+tests/test_util.py

{cook-build-0.2.0 → cook-build-0.2.1}/setup.py

@@ -5,16 +5,19 @@ with open("README.rst") as fp:
     long_description = fp.read()
 long_description = long_description \
     .replace(":func:", ":code:") \
-    .replace(".. doctest::", ".. code-block::") \
+    .replace(".. doctest::", ".. code-block::\n") \
+    .replace(".. shtest::", ".. code-block::\n") \
     .replace(":class:", ":code:") \
-    .replace(".. toctree::", "..")
+    .replace(".. toctree::", "..") \
+    .replace(".. sh::", "..")
 
 
 setup(
     name="cook-build",
-    version="0.2.0",
+    version="0.2.1",
     long_description=long_description,
     long_description_content_type="text/x-rst",
+    python_requires=">=3.8",
     install_requires=[
         "colorama",
     ],

cook-build-0.2.1/tests/test_actions.py

@@ -0,0 +1,51 @@
+from cook.actions import CompositeAction, FunctionAction, ShellAction, SubprocessAction
+from pathlib import Path
+import pytest
+from subprocess import SubprocessError
+
+
+def test_shell_action(tmp_wd: Path) -> None:
+    action = ShellAction("echo hello > world.txt")
+    action.execute_sync(None)
+    assert (tmp_wd / "world.txt").read_text().strip() == "hello"
+
+
+def test_subprocess_action(tmp_wd: Path) -> None:
+    action = SubprocessAction("touch", "foo")
+    action.execute_sync(None)
+    assert (tmp_wd / "foo").is_file()
+
+
+def test_bad_subprocess_action() -> None:
+    action = SubprocessAction("false")
+    with pytest.raises(SubprocessError):
+        action.execute_sync(None)
+
+
+def test_function_action() -> None:
+    args = []
+
+    action = FunctionAction(args.append)
+    action.execute_sync(42)
+
+    assert args == [42]
+
+
+def test_async_function_action() -> None:
+    args = []
+
+    async def func(*x) -> None:
+        args.append(*x)
+
+    action = FunctionAction(func)
+    action.execute_sync(17)
+
+    assert args == [17]
+
+
+def test_composite_action() -> None:
+    args = []
+
+    action = CompositeAction(FunctionAction(args.append), FunctionAction(args.append))
+    action.execute_sync("hello")
+    assert args == ["hello", "hello"]

cook-build-0.2.1/tests/test_contexts.py

@@ -0,0 +1,89 @@
+from cook import Manager, Task
+from cook.actions import CompositeAction, FunctionAction, ShellAction, SubprocessAction
+from cook.contexts import Context, create_target_directories, FunctionContext, create_group, \
+    normalize_action, normalize_dependencies
+from cook.controller import Controller
+from pathlib import Path
+import pytest
+import sqlite3
+from typing import List
+
+
+def test_function_context(m: Manager) -> None:
+    tasks: List[Task] = []
+
+    def func(t: Task) -> Task:
+        tasks.append(t)
+        return t
+
+    with FunctionContext(func):
+        m.create_task("my-task")
+    m.create_task("my-other-task")
+
+    task, = tasks
+    assert task.name == "my-task"
+
+
+def test_missing_task_context(m: Manager) -> None:
+    with pytest.raises(ValueError, match="did not return a task"), FunctionContext(lambda _: None):
+        m.create_task("my-task")
+
+
+def test_context_management(m: Manager) -> None:
+    with pytest.raises(RuntimeError, match="no active contexts"), Context():
+        m.contexts = []
+    with pytest.raises(RuntimeError, match="unexpected context"), Context():
+        m.contexts.append("something else")
+
+
+def test_create_target_directories(m: Manager, tmp_wd: Path, conn: sqlite3.Connection) -> None:
+    filename = tmp_wd / "this/is/a/hierarchy.txt"
+    with normalize_action(), create_target_directories():
+        task = m.create_task("foo", targets=[filename], action=["touch", filename])
+    assert not filename.parent.is_dir()
+
+    controller = Controller(m, conn)
+    controller.execute_sync(task)
+    assert filename.parent.is_dir()
+
+
+def test_normalize_action(m: Manager) -> None:
+    with normalize_action():
+        task = m.create_task("foo", action="bar")
+        assert isinstance(task.action, ShellAction) and task.action.cmd == "bar"
+
+        task = m.create_task("bar", action=["baz"])
+        assert isinstance(task.action, SubprocessAction) and task.action.program == "baz"
+
+        actions = [ShellAction("hello"), SubprocessAction("world")]
+        task = m.create_task("baz", action=actions)
+        assert isinstance(task.action, CompositeAction) and task.action.actions == tuple(actions)
+
+        task = m.create_task("xyz", action=lambda x: None)
+        assert isinstance(task.action, FunctionAction)
+
+
+def test_group_no_tasks(m: Manager) -> None:
+    with pytest.raises(RuntimeError, match="no tasks"), create_group("g"):
+        pass
+
+
+def test_group(m: Manager) -> None:
+    with create_group("g"):
+        t1 = m.create_task("t1")
+        t2 = m.create_task("t2")
+    assert m.tasks["g"].task_dependencies == [t1, t2]
+
+
+def test_normalize_dependencies(m: Manager) -> None:
+    with create_group("g") as g:
+        base = m.create_task("base")
+    with normalize_dependencies():
+        task = m.create_task("task1", dependencies=[g])
+        assert task.task_dependencies == [g.task]
+
+        task = m.create_task("task2", dependencies=[base])
+        assert task.task_dependencies == [base]
+
+        task = m.create_task("task3", task_dependencies=["g"])
+        assert task.task_dependencies == [g.task]

cook-build-0.2.1/tests/test_controller.py

@@ -0,0 +1,154 @@
+from cook import Controller, Manager, Task
+from cook.actions import FunctionAction, ShellAction
+from cook.contexts import normalize_dependencies
+from cook.controller import QUERIES
+from cook.util import FailedTaskError, Timer
+from pathlib import Path
+import pytest
+import shutil
+from sqlite3 import Connection
+from unittest.mock import patch
+
+
+def touch(task: Task) -> None:
+    for target in task.targets:
+        target.write_text(target.name)
+
+
+@pytest.fixture
+def patched_hexdigest() -> None:
+    with patch("cook.util.evaluate_hexdigest", lambda path: path.name):
+        yield
+
+
+def test_controller_empty_task(m: Manager, conn: Connection) -> None:
+    task = m.create_task("foo")
+    c = Controller(m, conn)
+    assert c.is_stale(task)
+    assert c.resolve_stale_tasks() == {task}
+
+
+def test_controller_missing_target(m: Manager, conn: Connection) -> None:
+    task = m.create_task("foo", targets=["bar"])
+    c = Controller(m, conn)
+    assert c.is_stale(task)
+    assert c.resolve_stale_tasks() == {task}
+
+
+def test_controller_simple_file_deps(m: Manager, conn: Connection, patched_hexdigest: None) -> None:
+    for path in ["input.txt", "output.txt"]:
+        Path(path).write_text(path)
+    with normalize_dependencies():
+        task = m.create_task("foo", dependencies=["input.txt"], targets=["output.txt"])
+    c = Controller(m, conn)
+
+    # No entry in the database.
+    assert c.is_stale(task)
+    assert c.resolve_stale_tasks() == {task}
+
+    # Up to date entry in the database.
+    conn.execute(QUERIES["upsert"], {"name": "input.txt", "digest": "input.txt", "size": 9})
+    c = Controller(m, conn)
+    assert not c.is_stale(task)
+
+    # Wrong file size in the database.
+    conn.execute(QUERIES["upsert"], {"name": "input.txt", "digest": "input.txt", "size": 7})
+    c = Controller(m, conn)
+    assert c.is_stale(task)
+
+    # Wrong digest in the database.
+    conn.execute(QUERIES["upsert"], {"name": "input.txt", "digest": "-", "size": 9})
+    c = Controller(m, conn)
+    assert c.is_stale(task)
+
+
+def test_controller(m: Manager, conn: Connection, patched_hexdigest: None) -> None:
+    for filename in ["input1.txt", "input2.txt", "intermediate.txt", "output1.txt"]:
+        Path(filename).write_text(filename)
+
+    with normalize_dependencies():
+        intermediate = m.create_task("intermediate", dependencies=["input1.txt", "input2.txt"],
+                                     targets=["intermediate.txt"], action=FunctionAction(touch))
+        output1 = m.create_task("output1", dependencies=["intermediate.txt"],
+                                targets=["output1.txt"], action=FunctionAction(touch))
+        output2 = m.create_task("output2", targets=["output2.txt"], action=FunctionAction(touch),
+                                dependencies=["intermediate.txt", "input2.txt", "output1.txt"])
+        special = m.create_task("special", dependencies=["intermediate.txt"])
+
+    # Make sure that the first output is not itself stale.
+    conn.executemany(QUERIES["upsert"], [
+        {"name": "intermediate.txt", "digest": "intermediate.txt", "size": 16},
+    ])
+    c = Controller(m, conn)
+    assert not c.is_stale(output1, recursive=False)
+
+    # We should get back all tasks anyway because the intermediate task is out of date (its inputs
+    # are not in the database).
+    c = Controller(m, conn)
+    assert c.resolve_stale_tasks() == {intermediate, output1, output2, special}
+
+    # Make sure we don't get any tasks that are upstream from what we request.
+    c = Controller(m, conn)
+    assert c.resolve_stale_tasks([output1]) == {intermediate, output1}
+
+    # Execute tasks and check that they are no longer stale.
+    c = Controller(m, conn)
+    c.execute_sync(output1)
+    assert not c.resolve_stale_tasks([output1])
+
+    # But the other ones are still stale.
+    c = Controller(m, conn)
+    assert c.resolve_stale_tasks() == {output2, special}
+
+    # Execute the second output. The special task without outputs never disappears.
+    c = Controller(m, conn)
+    c.execute_sync(output2)
+    assert c.resolve_stale_tasks() == {special}
+
+
+def test_target_not_created(m: Manager, conn: Connection) -> None:
+    task = m.create_task("nothing", targets=["missing"])
+    c = Controller(m, conn)
+    with pytest.raises(FailedTaskError, match="did not create"):
+        c.execute_sync(task)
+
+
+def test_failing_task(m: Manager, conn: Connection) -> None:
+    def raise_exception(_) -> None:
+        raise RuntimeError
+
+    task = m.create_task("nothing", action=FunctionAction(raise_exception))
+    c = Controller(m, conn)
+    with pytest.raises(FailedTaskError):
+        c.execute_sync(task)
+
+
+def test_concurrency(m: Manager, conn: Connection) -> None:
+    delay = 0.2
+    num_tasks = 4
+
+    tasks = [m.create_task(str(i), action=ShellAction(f"sleep {delay} && touch {i}.txt"),
+                           targets=[f"{i}.txt"]) for i in range(num_tasks)]
+    task = m.create_task("result", dependencies=[task.targets[0] for task in tasks])
+
+    c = Controller(m, conn)
+    with Timer() as timer:
+        c.execute_sync(task)
+    assert timer.duration > num_tasks * delay
+
+    c = Controller(m, conn, num_concurrent=num_tasks)
+    with Timer() as timer:
+        c.execute_sync(task)
+    assert timer.duration < 2 * delay
+
+
+def test_hexdigest_cache(m: Manager, conn: Connection, tmp_wd: Path) -> None:
+    c = Controller(m, conn)
+    shutil.copy(__file__, tmp_wd / "foo")
+    with patch("cook.util.evaluate_hexdigest") as evaluate_hexdigest:
+        c.evaluate_size_digest("foo")
+        c.evaluate_size_digest("foo")
+    evaluate_hexdigest.assert_called_once()
+
+
+# TODO: add tests to verify what happens when tasks are cancelled, e.g., by `KeyboardInterrupt`.

cook-build-0.2.1/tests/test_examples.py

@@ -0,0 +1,11 @@
+from cook.__main__ import __main__
+from cook.util import working_directory
+import pytest
+
+
+@pytest.mark.parametrize("name, task", [
+    ("hellomake", "say-hello"),
+])
+def test_example(name: str, task: str) -> None:
+    with working_directory(f"examples/{name}"):
+        __main__(["exec", task])

cook-build-0.2.1/tests/test_main.py

@@ -0,0 +1,68 @@
+from cook.__main__ import __main__, Formatter
+import logging
+from pathlib import Path
+import pytest
+import shutil
+from typing import List
+
+
+RECIPES = Path(__file__).parent / "recipes"
+
+
+def test_blah_recipe_run(tmp_wd: Path) -> None:
+    __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "run"])
+
+
+@pytest.mark.parametrize("patterns, expected", [
+    ([], ["create_source", "compile", "link", "run"]),
+    (["c*"], ["create_source", "compile"]),
+    (["--re", r"^\w{3}\w?$"], ["link", "run"]),
+    (["run"], ["run"]),
+])
+def test_blah_recipe_ls(patterns: str, expected: List[str], capsys: pytest.CaptureFixture) -> None:
+    __main__(["--recipe", str(RECIPES / "blah.py"), "ls", *patterns])
+    out, _ = capsys.readouterr()
+    for task in expected:
+        assert f"<task `{task}` @ " in out
+
+
+def test_blah_recipe_info() -> None:
+    __main__(["--recipe", str(RECIPES / "blah.py"), "info", "link"])
+
+
+def test_blah_recipe_reset() -> None:
+    __main__(["--recipe", str(RECIPES / "blah.py"), "reset", "link"])
+
+
+def test_simple_dag_run(tmp_wd: Path) -> None:
+    __main__(["--recipe", str(RECIPES / "simple_dag.py"), "exec", "3-1"])
+
+
+@pytest.mark.parametrize("patterns", [
+    ["foo"],
+    ["foo", "bar"],
+    ["foo", "bar", "baz"],
+])
+def test_simple_dag_no_matching_tasks(caplog: pytest.LogCaptureFixture, patterns: List[str]) \
+        -> None:
+    with pytest.raises(SystemExit), caplog.at_level("WARNING"):
+        __main__(["--recipe", str(RECIPES / "simple_dag.py"), "ls", *patterns])
+    assert "found no tasks matching" in caplog.text
+
+
+def test_module_import(tmp_wd: Path) -> None:
+    recipe = tmp_wd / "my_recipe.py"
+    shutil.copy(RECIPES / "simple_dag.py", recipe)
+    __main__(["-m", "my_recipe", "ls"])
+
+
+def test_bad_recipe(caplog: pytest.LogCaptureFixture) -> None:
+    with pytest.raises(SystemExit), caplog.at_level("ERROR"):
+        __main__(["--recipe", str(RECIPES / "bad.py"), "exec", "false"])
+    assert "failed to execute" in caplog.text
+
+
+def test_custom_formatter() -> None:
+    formatter = Formatter()
+    record = logging.LogRecord("a", logging.ERROR, "b", 2, "foo", None, None)
+    assert isinstance(formatter.format(record), str)

cook-build-0.2.1/tests/test_manager.py

@@ -0,0 +1,60 @@
+from cook import Manager
+from cook.contexts import create_group, normalize_dependencies
+from pathlib import Path
+import pytest
+
+
+def test_resolve_dependencies(m: Manager) -> None:
+    Path("input1.txt").write_text("input1.txt")
+    Path("input2.txt").write_text("input2.txt")
+
+    with normalize_dependencies():
+        intermediate = m.create_task("intermediate", dependencies=["input1.txt", "input2.txt"],
+                                     targets=["intermediate.txt"])
+        with create_group("outputs") as outputs:
+            output1 = m.create_task("output1", dependencies=["intermediate.txt"],
+                                    targets=["output1.txt"])
+            output2 = m.create_task("output2", targets=["output2.txt"],
+                                    dependencies=["intermediate.txt", "input2.txt", "output1.txt"])
+        special = m.create_task("special", dependencies=["intermediate.txt"])
+        dependent = m.create_task("dependent", task_dependencies=[output1])
+    dependencies = m.resolve_dependencies()
+
+    assert dependencies == {
+        output1: {intermediate},
+        output2: {intermediate, output1},
+        special: {intermediate},
+        dependent: {output1},
+        outputs.task: {output1, output2},
+    }
+
+
+def test_missing_file(m: Manager) -> None:
+    with normalize_dependencies():
+        m.create_task("has_missing_file_dependency", dependencies=["missing-file.txt"])
+    with pytest.raises(FileNotFoundError, match="does not exist nor is"):
+        m.resolve_dependencies()
+
+
+def test_conflicting_targets(m: Manager) -> None:
+    m.create_task("foo", targets=["bar"])
+    m.create_task("baz", targets=["bar"])
+    with pytest.raises(ValueError, match="both have target"):
+        m.resolve_dependencies()
+
+
+def test_same_name(m: Manager) -> None:
+    m.create_task("foo")
+    with pytest.raises(ValueError, match="task with name foo already exists"):
+        m.create_task("foo")
+
+
+def test_get_manager_instance() -> None:
+    with pytest.raises(ValueError, match="no manager"):
+        Manager.get_instance()
+    with Manager() as m:
+        assert Manager.get_instance() is m
+    with pytest.raises(RuntimeError, match="unexpected manager"), Manager():
+        Manager._INSTANCE = "asdf"
+    with pytest.raises(ValueError, match="already active"), Manager(), Manager():
+        pass

cook-build-0.2.1/tests/test_util.py

@@ -0,0 +1,9 @@
+from cook import util
+import hashlib
+from pathlib import Path
+
+
+def test_evaluate_digest(tmp_wd: Path) -> None:
+    fn = tmp_wd / "foo.txt"
+    fn.write_text("bar")
+    assert util.evaluate_hexdigest(fn) == hashlib.sha1(b"bar").hexdigest()