Make it pass and add more tests.

Author: tobiasraabe

src/_pytask/execute.py

@@ -25,6 +25,7 @@
 from _pytask.outcomes import count_outcomes
 from _pytask.outcomes import Exit
 from _pytask.outcomes import TaskOutcome
+from _pytask.outcomes import WouldBeExecuted
 from _pytask.report import ExecutionReport
 from _pytask.session import Session
 from _pytask.shared import get_first_non_none_value
@@ -153,17 +154,20 @@ def pytask_execute_task_setup(session: Session, task: Task) -> None:
 
 
 @hookimpl(trylast=True)
-def pytask_execute_task(task: Task) -> bool:
+def pytask_execute_task(session: Session, task: Task) -> bool:
     """Execute task."""
-    kwargs = {**task.kwargs}
+    if session.config["dry_run"]:
+        raise WouldBeExecuted()
+    else:
+        kwargs = {**task.kwargs}
 
-    func_arg_names = set(inspect.signature(task.function).parameters)
-    for arg_name in ("depends_on", "produces"):
-        if arg_name in func_arg_names:
-            attribute = getattr(task, arg_name)
-            kwargs[arg_name] = tree_map(lambda x: x.value, attribute)
+        func_arg_names = set(inspect.signature(task.function).parameters)
+        for arg_name in ("depends_on", "produces"):
+            if arg_name in func_arg_names:
+                attribute = getattr(task, arg_name)
+                kwargs[arg_name] = tree_map(lambda x: x.value, attribute)
 
-    task.execute(**kwargs)
+        task.execute(**kwargs)
     return True
 
 
@@ -201,6 +205,8 @@ def pytask_execute_task_process_report(
     task = report.task
     if report.outcome == TaskOutcome.SUCCESS:
         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
     else:
         for descending_task_name in descending_tasks(task.name, session.dag):
             descending_task = session.dag.nodes[descending_task_name]["task"]

src/_pytask/outcomes.py

@@ -115,6 +115,7 @@ def symbol(self) -> str:
             TaskOutcome.SKIP: "s",
             TaskOutcome.SKIP_PREVIOUS_FAILED: "F",
             TaskOutcome.FAIL: "F",
+            TaskOutcome.WOULD_BE_EXECUTED: "w",
         }
         assert len(symbols) == len(TaskOutcome)
         return symbols[self]
@@ -129,6 +130,7 @@ def description(self) -> str:
             TaskOutcome.SKIP: "Skipped",
             TaskOutcome.SKIP_PREVIOUS_FAILED: "Skipped because previous failed",
             TaskOutcome.FAIL: "Failed",
+            TaskOutcome.WOULD_BE_EXECUTED: "Would be executed",
         }
         assert len(descriptions) == len(TaskOutcome)
         return descriptions[self]
@@ -143,6 +145,7 @@ def style(self) -> str:
             TaskOutcome.SKIP: "skipped",
             TaskOutcome.SKIP_PREVIOUS_FAILED: "failed",
             TaskOutcome.FAIL: "failed",
+            TaskOutcome.WOULD_BE_EXECUTED: "success",
         }
         assert len(styles) == len(TaskOutcome)
         return styles[self]
@@ -157,6 +160,7 @@ def style_textonly(self) -> str:
             TaskOutcome.SKIP: "skipped.textonly",
             TaskOutcome.SKIP_PREVIOUS_FAILED: "failed.textonly",
             TaskOutcome.FAIL: "failed.textonly",
+            TaskOutcome.WOULD_BE_EXECUTED: "success.textonly",
         }
         assert len(styles_textonly) == len(TaskOutcome)
         return styles_textonly[self]

tests/test_execute.py

@@ -353,10 +353,86 @@ def task_second(): pass
 
 @pytest.mark.end_to_end
 def test_dry_run(runner, tmp_path):
-    tmp_path.joinpath("task_example.py").write_text("def task_example(): ...")
+    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()])
 
-    print(result.output)
     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