test: add integration and E2E tests (#14, #15)

Author: tracer-mohist

tests/test_audit_workflow_e2e.py

@@ -0,0 +1,56 @@
+# tests/test_audit_workflow_e2e.py
+"""E2E tests for audit workflow.
+
+REFERENCE: principles/automation/testing-strategy.md
+- Tests business-impacting workflows only
+- 5-15 E2E tests maximum
+"""
+
+import tempfile
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from workflow_as_list.cli import app
+from workflow_as_list.constants import ensure_directories
+
+runner = CliRunner()
+
+
+def test_complete_audit_workflow():
+    """Scenario: User completes full audit workflow (check → approve → reject).
+    Expected: Workflow can be approved and rejected.
+    If fails: Audit workflow broken, security model compromised.
+    """
+    ensure_directories()
+
+    # Create test workflow with unique name
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".workflow.list", delete=False, prefix="test_"
+    ) as f:
+        f.write("# Test workflow\n- (start) Test\n- End\n")
+        f.flush()
+        workflow_path = Path(f.name)
+
+    # Workflow name is derived from filename (remove .workflow.list suffix)
+    # e.g., test_abc.workflow.list -> test_abc.workflow
+    workflow_name = workflow_path.stem
+
+    try:
+        # Check
+        result = runner.invoke(app, ["check", str(workflow_path)])
+        assert result.exit_code == 0, f"Check failed: {result.output}"
+        assert "Workflow registered" in result.output
+
+        # Approve
+        result = runner.invoke(app, ["approve", workflow_name])
+        assert result.exit_code == 0, f"Approve failed: {result.output}"
+        assert "approved" in result.output.lower()
+
+        # Reject (to test reject flow)
+        result = runner.invoke(app, ["reject", workflow_name])
+        assert result.exit_code == 0, f"Reject failed: {result.output}"
+        assert "rejected" in result.output.lower()
+
+    finally:
+        workflow_path.unlink()

tests/test_execution_workflow_e2e.py

@@ -0,0 +1,78 @@
+# tests/test_execution_workflow_e2e.py
+"""E2E tests for execution workflow with progressive reading.
+
+REFERENCE: principles/automation/testing-strategy.md
+- Tests business-impacting workflows only
+- 5-15 E2E tests maximum
+"""
+
+import tempfile
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from workflow_as_list.cli import app
+from workflow_as_list.constants import ensure_directories
+
+runner = CliRunner()
+
+
+def test_complete_execution_workflow():
+    """Scenario: User completes full execution workflow with progressive reading.
+    Expected: Can read steps, advance only after reading, complete workflow.
+    If fails: Progressive reading model broken, core value proposition compromised.
+    """
+    ensure_directories()
+
+    # Create test workflow with unique name
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".workflow.list", delete=False, prefix="test_"
+    ) as f:
+        f.write("# Test workflow\n- (start) Step 1\n- Step 2\n- End\n")
+        f.flush()
+        workflow_path = Path(f.name)
+
+    # Workflow name is derived from filename (remove .workflow.list suffix)
+    # e.g., test_abc.workflow.list -> test_abc.workflow
+    workflow_name = workflow_path.stem
+
+    try:
+        # Check and approve
+        result = runner.invoke(app, ["check", str(workflow_path)])
+        assert result.exit_code == 0
+
+        result = runner.invoke(app, ["approve", workflow_name])
+        assert result.exit_code == 0
+
+        # Run to create execution
+        result = runner.invoke(app, ["run", workflow_name])
+        assert result.exit_code == 0
+
+        # Extract execution ID
+        import re
+
+        pattern = rf"Execution started: ({workflow_name}-\w+)"
+        match = re.search(pattern, result.output)
+        assert match, f"Could not find execution ID: {result.output}"
+        execution_id = match.group(1)
+
+        # Progressive reading: read → next → read → next
+        for step_num in range(1, 4):
+            # Read
+            result = runner.invoke(app, ["exec", "read", execution_id])
+            assert result.exit_code == 0, (
+                f"Read step {step_num} failed: {result.output}"
+            )
+
+            # Next
+            result = runner.invoke(app, ["exec", "next", execution_id])
+            if step_num < 3:
+                assert result.exit_code == 0, (
+                    f"Next step {step_num} failed: {result.output}"
+                )
+            else:
+                # Last step should complete
+                assert "completed" in result.output.lower()
+
+    finally:
+        workflow_path.unlink()

tests/test_pipeline_integration.py

@@ -0,0 +1,114 @@
+# tests/test_pipeline_integration.py
+"""Integration tests for critical data flows.
+
+REFERENCE: principles/automation/testing-strategy.md
+- Tests real integration points, not hypothetical combinations
+- Verifies necessary conditions, not sufficient conditions
+"""
+
+import tempfile
+import uuid
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from workflow_as_list.cli import app
+from workflow_as_list.constants import ensure_directories
+
+runner = CliRunner()
+
+
+def test_check_approve_run_pipeline():
+    """Scenario: User completes full workflow pipeline (check → approve → run).
+    Expected: Workflow registered, approved, execution created.
+    If fails: Core user workflow broken.
+    """
+    ensure_directories()
+
+    # Use unique workflow name
+    workflow_name = f"test_{uuid.uuid4().hex[:8]}"
+
+    # Create test workflow
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".workflow.list", delete=False
+    ) as f:
+        f.write(f"- (start) Test {workflow_name}\n- End\n")
+        f.flush()
+        workflow_path = Path(f.name)
+
+    try:
+        # Workflow name is derived from filename (remove .workflow.list suffix)
+        # e.g., test_abc.workflow.list -> test_abc.workflow
+        workflow_name = workflow_path.stem
+
+        # Check
+        result = runner.invoke(app, ["check", str(workflow_path)])
+        assert result.exit_code == 0, f"Check failed: {result.output}"
+
+        # Approve
+        result = runner.invoke(app, ["approve", workflow_name])
+        assert result.exit_code == 0, f"Approve failed: {result.output}"
+
+        # Run
+        result = runner.invoke(app, ["run", workflow_name])
+        assert result.exit_code == 0, f"Run failed: {result.output}"
+        assert "Execution started" in result.output
+
+    finally:
+        workflow_path.unlink()
+
+
+def test_exec_read_next_pipeline():
+    """Scenario: User uses progressive reading (read → next).
+    Expected: Can read step, advance only after reading.
+    If fails: Progressive reading enforcement broken.
+    """
+    ensure_directories()
+
+    # Create test workflow with unique name
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".workflow.list", delete=False, prefix="test_"
+    ) as f:
+        f.write("- (start) Step 1\n- Step 2\n- End\n")
+        f.flush()
+        workflow_path = Path(f.name)
+
+    # Workflow name is derived from filename (remove .workflow.list suffix)
+    # e.g., test_abc.workflow.list -> test_abc.workflow
+    workflow_name = workflow_path.stem
+
+    try:
+        # Check and approve
+        runner.invoke(app, ["check", str(workflow_path)])
+        runner.invoke(app, ["approve", workflow_name])
+
+        # Run to create execution
+        result = runner.invoke(app, ["run", workflow_name])
+        assert result.exit_code == 0
+
+        # Extract execution ID from output
+        # Format: "Execution started: test_abc.workflow-xyz"
+        import re
+
+        pattern = rf"Execution started: ({workflow_name}-\w+)"
+        match = re.search(pattern, result.output)
+        assert match, f"Could not find execution ID: {result.output}"
+        execution_id = match.group(1)
+
+        # Read current step
+        result = runner.invoke(app, ["exec", "read", execution_id])
+        assert result.exit_code == 0, f"Read failed: {result.output}"
+        assert "Step 1" in result.output
+
+        # Next should succeed (step was read)
+        result = runner.invoke(app, ["exec", "next", execution_id])
+        assert result.exit_code == 0, f"Next failed: {result.output}"
+        assert "Advanced to step" in result.output
+
+        # Try next again (should fail - step 2 not read)
+        result = runner.invoke(app, ["exec", "next", execution_id])
+        assert result.exit_code != 0, "Next should fail without reading first"
+        assert "not read" in result.output.lower()
+
+    finally:
+        workflow_path.unlink()

tests/test_state_persistence_e2e.py

@@ -0,0 +1,75 @@
+# tests/test_state_persistence_e2e.py
+"""E2E tests for state persistence.
+
+REFERENCE: principles/automation/testing-strategy.md
+- Tests business-impacting workflows only
+- 5-15 E2E tests maximum
+"""
+
+import tempfile
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from workflow_as_list.cli import app
+from workflow_as_list.constants import ensure_directories
+from workflow_as_list.executor import Executor
+
+runner = CliRunner()
+
+
+def test_state_persistence_after_restart():
+    """Scenario: Execution state persists after "restart" (new Executor instance).
+    Expected: Can resume execution from saved state.
+    If fails: State persistence broken, cannot resume interrupted executions.
+    """
+    ensure_directories()
+
+    # Create test workflow with unique name
+    with tempfile.NamedTemporaryFile(
+        mode="w", suffix=".workflow.list", delete=False, prefix="test_"
+    ) as f:
+        f.write("# Test workflow\n- (start) Step 1\n- Step 2\n- End\n")
+        f.flush()
+        workflow_path = Path(f.name)
+
+    # Workflow name is derived from filename (remove .workflow.list suffix)
+    # e.g., test_abc.workflow.list -> test_abc.workflow
+    workflow_name = workflow_path.stem
+
+    try:
+        # Check and approve
+        runner.invoke(app, ["check", str(workflow_path)])
+        runner.invoke(app, ["approve", workflow_name])
+
+        # Run to create execution
+        result = runner.invoke(app, ["run", workflow_name])
+        assert result.exit_code == 0
+
+        # Extract execution ID
+        import re
+
+        pattern = rf"Execution started: ({workflow_name}-\w+)"
+        match = re.search(pattern, result.output)
+        assert match, f"Could not find execution ID: {result.output}"
+        execution_id = match.group(1)
+
+        # Read step 1
+        result = runner.invoke(app, ["exec", "read", execution_id])
+        assert result.exit_code == 0
+
+        # "Restart" - create new Executor instance
+        executor = Executor()
+
+        # Verify state persisted
+        execution = executor.get_execution(execution_id)
+        assert execution is not None, "Execution state not persisted"
+        assert execution.workflow_name == workflow_name
+        assert execution.steps_total == 3
+
+        # Can continue from saved state
+        result = runner.invoke(app, ["exec", "next", execution_id])
+        assert result.exit_code == 0, f"Next after restart failed: {result.output}"
+
+    finally:
+        workflow_path.unlink()