DAG-based integration test framework with durable state.

pip install dagtest

from dagtest import test

@test
async def test_root(ctx):
    return {"value": 1}

@test(depends_on=["test_root"])
async def test_child(ctx):
    parent_value = ctx.results["test_root"]["value"]
    assert parent_value == 1
    return {"computed": parent_value + 1}

dagtest run
dagtest list
dagtest graph

During execution, dagtest shows real-time branch status with hierarchical notation:

   Running root_step...
   PASS root_step (3ms)
[A•*]|A Running branch_a...
[A✓*]|A PASS branch_a (2ms)
[A•*]|B Running branch_b...
[A✓*]|B PASS branch_b (1ms)
[A•*]|C Running branch_c...
[A✓*]|C PASS branch_c (1ms)
[AC•]|A Running final_step...
[AC✓]|A PASS final_step (1ms)

First Bracket - Shows state at each depth level:

• Letter (A, B, C...) = completed at this depth
• • = currently running
• ✓ = successfully completed (shown on completion)
• ⚠ = failed but will retry (soft failure)
• ↻ = retrying after failure
• * = pending/not yet started
• ✗ = hard failed (after all retries) or blocked by upstream failure

Second Bracket - Last component of branch path, colored by depth for visual differentiation

Example breakdown:

• [A•*]|B → Root complete (A), this branch running (•), one pending level (*), branch identifier B
• [AC•]|A → Root complete (A), parent branch complete (C), this node running (•), branch identifier A

Failed nodes propagate to downstream branches, and retries are shown with the retry icon:

[A•**]|A Running branch_a...
[A✓**]|A PASS branch_a (1ms)
[A•**]|B Running branch_b...
[A✗✗✗]|B FAIL branch_b (2ms)
       ValueError: Simulated failure

The [A✗✗✗]|B shows:

• Root complete (A)
• This branch hard failed (✗)
• Two downstream levels blocked (✗✗)
• Branch identifier B

Retry example:

[A•*]|A Running flaky_step...
[A⚠*]|A FAIL flaky_step (3ms)
       ValueError: First attempt fails
[A•*]|A Running flaky_step... (attempt 2)
[A✓*]|A PASS flaky_step (2ms)

• [A⚠*]|A shows soft failure (will retry) - downstream nodes remain pending (*)
• After successful retry, shows ✓

Hard failure (retries exhausted):

[A•*]|A Running always_fails...
[A⚠*]|A FAIL always_fails (3ms)
       ValueError: Always fails
         With multiple lines
         Of error output
[A•*]|A Running always_fails... (attempt 2)
[A✗✗]|A FAIL always_fails (2ms)
       ValueError: Always fails

• First failure: [A⚠*]|A (soft, will retry)
• Final failure: [A✗✗]|A (hard, retries exhausted)
• Downstream nodes blocked: ✗✗ indicates two pending levels now blocked

Export DAG diagrams for documentation and review:

# Terminal tree view (default)
dagtest graph

# Mermaid diagram for documentation
dagtest graph --format mermaid --output dag.mmd

# Preview before execution
dagtest run --dry-run

Mermaid output can be rendered in GitHub, GitLab, or documentation tools that support Mermaid.js syntax.

Tools directly comparable to dagtest for various integration testing scenarios.

AI-powered testing platforms with autonomous agents, self-healing, and natural language test generation.

Platforms for tracing, monitoring, and evaluating LLM applications in production. For evaluation methodology guidance, see docs/llm-evaluation-guide.md.

DAG-based workflow engines and task runners that can be adapted for testing workflows.