Add some more tests and make it working.

Author: tobiasraabe

src/_pytask/execute.py

@@ -20,6 +20,7 @@
 from _pytask.exceptions import ExecutionError
 from _pytask.exceptions import NodeNotFoundError
 from _pytask.mark import Mark
+from _pytask.mark_utils import has_mark
 from _pytask.nodes import FilePathNode
 from _pytask.nodes import Task
 from _pytask.outcomes import count_outcomes
@@ -152,6 +153,10 @@ def pytask_execute_task_setup(session: Session, task: Task) -> None:
         if isinstance(node, FilePathNode):
             node.path.parent.mkdir(parents=True, exist_ok=True)
 
+    would_be_executed = has_mark(task, "would_be_executed")
+    if would_be_executed:
+        raise WouldBeExecuted
+
 
 @hookimpl(trylast=True)
 def pytask_execute_task(session: Session, task: Task) -> bool:
@@ -207,6 +212,16 @@ def pytask_execute_task_process_report(
         update_states_in_database(session.dag, task.name)
     elif report.exc_info and isinstance(report.exc_info[1], WouldBeExecuted):
         report.outcome = TaskOutcome.WOULD_BE_EXECUTED
+
+        for descending_task_name in descending_tasks(task.name, session.dag):
+            descending_task = session.dag.nodes[descending_task_name]["task"]
+            descending_task.markers.append(
+                Mark(
+                    "would_be_executed",
+                    (),
+                    {"reason": f"Previous task {task.name!r} would be executed."},
+                )
+            )
     else:
         for descending_task_name in descending_tasks(task.name, session.dag):
             descending_task = session.dag.nodes[descending_task_name]["task"]

src/_pytask/skipping.py

@@ -49,7 +49,9 @@ def pytask_parse_config(config: dict[str, Any]) -> None:
 @hookimpl
 def pytask_execute_task_setup(task: Task) -> None:
     """Take a short-cut for skipped tasks during setup with an exception."""
-    is_unchanged = has_mark(task, "skip_unchanged")
+    is_unchanged = has_mark(task, "skip_unchanged") and not has_mark(
+        task, "would_be_executed"
+    )
     if is_unchanged:
         raise SkippedUnchanged
 

tests/test_dry_run.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import textwrap
+
+import pytest
+from pytask import cli
+from pytask import ExitCode
+
+
+@pytest.mark.end_to_end
+def test_dry_run(runner, tmp_path):
+    source = """
+    import pytask
+
+    @pytask.mark.produces("out.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "1  Would be executed" in result.output
+    assert not tmp_path.joinpath("out.txt").exists()
+
+
+@pytest.mark.end_to_end
+def test_dry_run_w_subsequent_task(runner, tmp_path):
+    source = """
+    import pytask
+
+    @pytask.mark.depends_on("out.txt")
+    @pytask.mark.produces("out_2.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example_second.py").write_text(textwrap.dedent(source))
+
+    source = """
+    import pytask
+
+    @pytask.mark.produces("out.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example_first.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, [tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "2  Succeeded" in result.output
+
+    tmp_path.joinpath("task_example_first.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "2  Would be executed" in result.output
+
+
+@pytest.mark.end_to_end
+def test_dry_run_w_subsequent_skipped_task(runner, tmp_path):
+    source = """
+    import pytask
+
+    @pytask.mark.produces("out.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example_first.py").write_text(textwrap.dedent(source))
+
+    source = """
+    import pytask
+
+    @pytask.mark.depends_on("out.txt")
+    @pytask.mark.produces("out_2.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example_second.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, [tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "2  Succeeded" in result.output
+
+    source = """
+    import pytask
+
+    @pytask.mark.produces("out.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example_first.py").write_text(textwrap.dedent(source))
+
+    source = """
+    import pytask
+
+    @pytask.mark.skip
+    @pytask.mark.depends_on("out.txt")
+    @pytask.mark.produces("out_2.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example_second.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "1  Would be executed" in result.output
+    assert "1  Skipped" in result.output
+
+
+@pytest.mark.end_to_end
+def test_dry_run_skip(runner, tmp_path):
+    source = """
+    import pytask
+
+    @pytask.mark.skip
+    def task_example_skip(): ...
+
+    @pytask.mark.produces("out.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "1  Would be executed" in result.output
+    assert "1  Skipped" in result.output
+    assert not tmp_path.joinpath("out.txt").exists()
+
+
+@pytest.mark.end_to_end
+def test_dry_run_skipped_successul(runner, tmp_path):
+    source = """
+    import pytask
+
+    @pytask.mark.produces("out.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, [tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "1  Succeeded" in result.output
+
+    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "1  Skipped because unchanged" in result.output
+
+
+@pytest.mark.end_to_end
+def test_dry_run_persisted(runner, tmp_path):
+    source = """
+    import pytask
+
+    @pytask.mark.persist
+    @pytask.mark.produces("out.txt")
+    def task_example(produces):
+        produces.touch()
+    """
+    tmp_path.joinpath("task_example.py").write_text(textwrap.dedent(source))
+
+    result = runner.invoke(cli, [tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "1  Succeeded" in result.output
+
+    tmp_path.joinpath("out.txt").write_text("Changed text file.")
+
+    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
+
+    assert result.exit_code == ExitCode.OK
+    assert "1  Persisted" in result.output

tests/test_execute.py

@@ -349,90 +349,3 @@ def task_second(): pass
     assert ("Task task_example.py::task_second failed" in result.output) is (
         verbose == 2
     )
-
-
-@pytest.mark.end_to_end
-def test_dry_run(runner, tmp_path):
-    source = """
-    import pytask
-
-    @pytask.mark.produces("out.txt")
-    def task_example(produces):
-        produces.touch()
-    """
-    tmp_path.joinpath("task_example.py").write_text(textwrap.dedent(source))
-
-    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
-
-    assert result.exit_code == ExitCode.OK
-    assert "1  Would be executed" in result.output
-    assert not tmp_path.joinpath("out.txt").exists()
-
-
-@pytest.mark.end_to_end
-def test_dry_run_skip(runner, tmp_path):
-    source = """
-    import pytask
-
-    @pytask.mark.skip
-    def task_example_skip(): ...
-
-    @pytask.mark.produces("out.txt")
-    def task_example(produces):
-        produces.touch()
-    """
-    tmp_path.joinpath("task_example.py").write_text(textwrap.dedent(source))
-
-    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
-
-    assert result.exit_code == ExitCode.OK
-    assert "1  Would be executed" in result.output
-    assert "1  Skipped" in result.output
-    assert not tmp_path.joinpath("out.txt").exists()
-
-
-@pytest.mark.end_to_end
-def test_dry_run_skipped_successul(runner, tmp_path):
-    source = """
-    import pytask
-
-    @pytask.mark.produces("out.txt")
-    def task_example(produces):
-        produces.touch()
-    """
-    tmp_path.joinpath("task_example.py").write_text(textwrap.dedent(source))
-
-    result = runner.invoke(cli, [tmp_path.as_posix()])
-
-    assert result.exit_code == ExitCode.OK
-    assert "1  Succeeded" in result.output
-
-    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
-
-    assert result.exit_code == ExitCode.OK
-    assert "1  Skipped because unchanged" in result.output
-
-
-@pytest.mark.end_to_end
-def test_dry_run_persisted(runner, tmp_path):
-    source = """
-    import pytask
-
-    @pytask.mark.persist
-    @pytask.mark.produces("out.txt")
-    def task_example(produces):
-        produces.touch()
-    """
-    tmp_path.joinpath("task_example.py").write_text(textwrap.dedent(source))
-
-    result = runner.invoke(cli, [tmp_path.as_posix()])
-
-    assert result.exit_code == ExitCode.OK
-    assert "1  Succeeded" in result.output
-
-    tmp_path.joinpath("out.txt").write_text("Changed text file.")
-
-    result = runner.invoke(cli, ["--dry-run", tmp_path.as_posix()])
-
-    assert result.exit_code == ExitCode.OK
-    assert "1  Persisted" in result.output