pyworkflow-engine 0.1.7__py3-none-any.whl → 0.1.10__py3-none-any.whl

tests/unit/test_registry.py

@@ -1,261 +0,0 @@
-"""
-Unit tests for workflow and step registry.
-"""
-
-import pytest
-
-from pyworkflow.core.registry import (
-    WorkflowRegistry,
-    get_workflow,
-    get_workflow_by_func,
-    register_step,
-    register_workflow,
-)
-
-
-class TestWorkflowRegistry:
-    """Test the workflow registry functionality."""
-
-    def test_register_and_get_workflow(self):
-        """Test registering and retrieving a workflow."""
-        registry = WorkflowRegistry()
-
-        # Define a simple workflow function
-        async def my_workflow():
-            pass
-
-        # Register workflow
-        registry.register_workflow(
-            name="test_workflow",
-            func=my_workflow,
-            original_func=my_workflow,
-            max_duration="1h",
-            tags=["backend", "critical"],
-        )
-
-        # Retrieve workflow
-        workflow_meta = registry.get_workflow("test_workflow")
-
-        assert workflow_meta is not None
-        assert workflow_meta.name == "test_workflow"
-        assert workflow_meta.func == my_workflow
-        assert workflow_meta.max_duration == "1h"
-        assert workflow_meta.tags == ["backend", "critical"]
-
-    def test_get_workflow_by_func(self):
-        """Test retrieving a workflow by its function reference."""
-        registry = WorkflowRegistry()
-
-        async def my_workflow():
-            pass
-
-        # Register workflow
-        registry.register_workflow(
-            name="test_workflow",
-            func=my_workflow,
-            original_func=my_workflow,
-        )
-
-        # Retrieve by function
-        workflow_meta = registry.get_workflow_by_func(my_workflow)
-
-        assert workflow_meta is not None
-        assert workflow_meta.name == "test_workflow"
-
-    def test_get_nonexistent_workflow(self):
-        """Test retrieving a workflow that doesn't exist."""
-        registry = WorkflowRegistry()
-        workflow_meta = registry.get_workflow("nonexistent")
-        assert workflow_meta is None
-
-    def test_register_duplicate_workflow(self):
-        """Test that registering the same workflow name raises an error."""
-        registry = WorkflowRegistry()
-
-        async def workflow1():
-            pass
-
-        async def workflow2():
-            pass
-
-        # Register first workflow
-        registry.register_workflow(
-            name="duplicate",
-            func=workflow1,
-            original_func=workflow1,
-        )
-
-        # Registering again should raise ValueError
-        with pytest.raises(ValueError, match="already registered"):
-            registry.register_workflow(
-                name="duplicate",
-                func=workflow2,
-                original_func=workflow2,
-            )
-
-    def test_list_workflows(self):
-        """Test listing all registered workflows."""
-        registry = WorkflowRegistry()
-
-        async def workflow1():
-            pass
-
-        async def workflow2():
-            pass
-
-        # Register multiple workflows
-        registry.register_workflow(
-            name="workflow_a",
-            func=workflow1,
-            original_func=workflow1,
-        )
-        registry.register_workflow(
-            name="workflow_b",
-            func=workflow2,
-            original_func=workflow2,
-        )
-
-        workflows = registry.list_workflows()
-        assert len(workflows) == 2
-        assert "workflow_a" in workflows
-        assert "workflow_b" in workflows
-
-
-class TestStepRegistry:
-    """Test the step registry functionality."""
-
-    def test_register_and_get_step(self):
-        """Test registering and retrieving a step."""
-        registry = WorkflowRegistry()
-
-        async def my_step():
-            pass
-
-        # Register step
-        registry.register_step(
-            name="test_step",
-            func=my_step,
-            original_func=my_step,
-            max_retries=5,
-            retry_delay="10",
-            timeout=30,
-            metadata={"type": "api_call"},
-        )
-
-        # Retrieve step
-        step_meta = registry.get_step("test_step")
-
-        assert step_meta is not None
-        assert step_meta.name == "test_step"
-        assert step_meta.func == my_step
-        assert step_meta.max_retries == 5
-        assert step_meta.retry_delay == "10"
-        assert step_meta.timeout == 30
-        assert step_meta.metadata == {"type": "api_call"}
-
-    def test_get_nonexistent_step(self):
-        """Test retrieving a step that doesn't exist."""
-        registry = WorkflowRegistry()
-        step_meta = registry.get_step("nonexistent")
-        assert step_meta is None
-
-    def test_register_duplicate_step(self):
-        """Test that registering the same step name raises an error."""
-        registry = WorkflowRegistry()
-
-        async def step1():
-            pass
-
-        async def step2():
-            pass
-
-        # Register first step
-        registry.register_step(
-            name="duplicate",
-            func=step1,
-            original_func=step1,
-        )
-
-        # Registering again should raise ValueError
-        with pytest.raises(ValueError, match="already registered"):
-            registry.register_step(
-                name="duplicate",
-                func=step2,
-                original_func=step2,
-            )
-
-    def test_list_steps(self):
-        """Test listing all registered steps."""
-        registry = WorkflowRegistry()
-
-        async def step1():
-            pass
-
-        async def step2():
-            pass
-
-        # Register multiple steps
-        registry.register_step(name="step_a", func=step1, original_func=step1)
-        registry.register_step(name="step_b", func=step2, original_func=step2)
-
-        steps = registry.list_steps()
-        assert len(steps) == 2
-        assert "step_a" in steps
-        assert "step_b" in steps
-
-
-class TestGlobalRegistry:
-    """Test the global registry functions."""
-
-    def test_register_workflow_globally(self):
-        """Test the global register_workflow function."""
-
-        async def global_workflow():
-            pass
-
-        register_workflow(
-            name="global_test_workflow",
-            func=global_workflow,
-            original_func=global_workflow,
-        )
-
-        # Should be able to retrieve it
-        workflow_meta = get_workflow("global_test_workflow")
-        assert workflow_meta is not None
-        assert workflow_meta.name == "global_test_workflow"
-
-    def test_register_step_globally(self):
-        """Test the global register_step function."""
-
-        async def global_step():
-            pass
-
-        register_step(
-            name="global_test_step",
-            func=global_step,
-            original_func=global_step,
-        )
-
-        # Should be able to retrieve it from global registry
-        from pyworkflow.core.registry import _registry
-
-        step_meta = _registry.get_step("global_test_step")
-        assert step_meta is not None
-        assert step_meta.name == "global_test_step"
-
-    def test_get_workflow_by_func_globally(self):
-        """Test retrieving workflow by function from global registry."""
-
-        async def another_workflow():
-            pass
-
-        register_workflow(
-            name="func_lookup_test",
-            func=another_workflow,
-            original_func=another_workflow,
-        )
-
-        # Should be able to retrieve by function
-        workflow_meta = get_workflow_by_func(another_workflow)
-        assert workflow_meta is not None
-        assert workflow_meta.name == "func_lookup_test"

tests/unit/test_replay.py

@@ -1,420 +0,0 @@
-"""
-Unit tests for event replay engine.
-"""
-
-from datetime import UTC, datetime
-
-import pytest
-
-from pyworkflow.context import LocalContext
-from pyworkflow.engine.events import (
-    Event,
-    EventType,
-    create_hook_created_event,
-    create_hook_expired_event,
-    create_hook_received_event,
-    create_sleep_completed_event,
-    create_sleep_started_event,
-    create_step_completed_event,
-    create_step_started_event,
-)
-from pyworkflow.engine.replay import EventReplayer, replay_events
-from pyworkflow.serialization.encoder import serialize
-from pyworkflow.storage.file import FileStorageBackend
-
-
-class TestEventReplayer:
-    """Test the EventReplayer class."""
-
-    @pytest.mark.asyncio
-    async def test_replay_empty_events(self, tmp_path):
-        """Test replaying with no events."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        replayer = EventReplayer()
-        await replayer.replay(ctx, [])
-
-        # Context should remain empty
-        assert len(ctx.step_results) == 0
-        assert len(ctx.completed_sleeps) == 0
-        assert len(ctx.hook_results) == 0
-
-    @pytest.mark.asyncio
-    async def test_replay_step_completed(self, tmp_path):
-        """Test replaying step.completed events."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        # Create step completed events
-        events = [
-            create_step_started_event(
-                run_id="test_run",
-                step_id="step_1",
-                step_name="test_step",
-                args="[]",
-                kwargs="{}",
-                attempt=1,
-            ),
-            create_step_completed_event(
-                run_id="test_run",
-                step_id="step_1",
-                result=serialize("result_1"),
-                step_name="test_step",
-            ),
-        ]
-
-        # Assign sequence numbers
-        for i, event in enumerate(events, 1):
-            event.sequence = i
-
-        replayer = EventReplayer()
-        await replayer.replay(ctx, events)
-
-        # Step result should be cached
-        assert "step_1" in ctx.step_results
-        assert ctx.step_results["step_1"] == "result_1"
-
-    @pytest.mark.asyncio
-    async def test_replay_multiple_steps(self, tmp_path):
-        """Test replaying multiple step events."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        events = [
-            create_step_completed_event(
-                run_id="test_run",
-                step_id="step_1",
-                result=serialize("result_1"),
-                step_name="test_step",
-            ),
-            create_step_completed_event(
-                run_id="test_run",
-                step_id="step_2",
-                result=serialize("result_2"),
-                step_name="test_step",
-            ),
-            create_step_completed_event(
-                run_id="test_run",
-                step_id="step_3",
-                result=serialize("result_3"),
-                step_name="test_step",
-            ),
-        ]
-
-        for i, event in enumerate(events, 1):
-            event.sequence = i
-
-        replayer = EventReplayer()
-        await replayer.replay(ctx, events)
-
-        # All results should be cached
-        assert len(ctx.step_results) == 3
-        assert ctx.step_results["step_1"] == "result_1"
-        assert ctx.step_results["step_2"] == "result_2"
-        assert ctx.step_results["step_3"] == "result_3"
-
-    @pytest.mark.asyncio
-    async def test_replay_sleep_events(self, tmp_path):
-        """Test replaying sleep events."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        resume_at = datetime.now(UTC)
-        events = [
-            create_sleep_started_event(
-                run_id="test_run",
-                sleep_id="sleep_1",
-                duration_seconds=60,
-                resume_at=resume_at,
-                name="test_sleep",
-            ),
-            create_sleep_completed_event(run_id="test_run", sleep_id="sleep_1"),
-        ]
-
-        for i, event in enumerate(events, 1):
-            event.sequence = i
-
-        replayer = EventReplayer()
-        await replayer.replay(ctx, events)
-
-        # Sleep should be marked as completed
-        assert ctx.is_sleep_completed("sleep_1")
-        assert "sleep_1" in ctx.completed_sleeps
-
-    @pytest.mark.asyncio
-    async def test_replay_pending_sleep(self, tmp_path):
-        """Test replaying sleep that hasn't completed."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        resume_at = datetime.now(UTC)
-        events = [
-            create_sleep_started_event(
-                run_id="test_run",
-                sleep_id="sleep_pending",
-                duration_seconds=60,
-                resume_at=resume_at,
-                name="pending_sleep",
-            ),
-        ]
-
-        for i, event in enumerate(events, 1):
-            event.sequence = i
-
-        replayer = EventReplayer()
-        await replayer.replay(ctx, events)
-
-        # Sleep should be pending (not completed)
-        assert not ctx.is_sleep_completed("sleep_pending")
-        assert "sleep_pending" in ctx.pending_sleeps
-
-    @pytest.mark.asyncio
-    async def test_replay_hook_events(self, tmp_path):
-        """Test replaying hook events."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        events = [
-            create_hook_created_event(
-                run_id="test_run",
-                hook_id="hook_1",
-                url="https://example.com/hook",
-                token="secret_token",
-                name="test_hook",
-            ),
-            create_hook_received_event(
-                run_id="test_run",
-                hook_id="hook_1",
-                payload={"data": "test_payload"},
-            ),
-        ]
-
-        for i, event in enumerate(events, 1):
-            event.sequence = i
-
-        replayer = EventReplayer()
-        await replayer.replay(ctx, events)
-
-        # Hook result should be cached
-        assert ctx.has_hook_result("hook_1")
-        assert ctx.get_hook_result("hook_1") == {"data": "test_payload"}
-
-    @pytest.mark.asyncio
-    async def test_replay_expired_hook(self, tmp_path):
-        """Test replaying an expired hook."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        events = [
-            create_hook_created_event(
-                run_id="test_run",
-                hook_id="hook_expired",
-                url="https://example.com/hook",
-                token="token",
-            ),
-            create_hook_expired_event(
-                run_id="test_run",
-                hook_id="hook_expired",
-            ),
-        ]
-
-        for i, event in enumerate(events, 1):
-            event.sequence = i
-
-        replayer = EventReplayer()
-        await replayer.replay(ctx, events)
-
-        # Hook should not be in pending hooks
-        assert "hook_expired" not in ctx.pending_hooks
-        # Hook should not have a result
-        assert not ctx.has_hook_result("hook_expired")
-
-    @pytest.mark.asyncio
-    async def test_replay_events_in_order(self, tmp_path):
-        """Test that events are replayed in sequence order."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        # Create events out of order
-        event1 = create_step_completed_event(
-            run_id="test_run", step_id="step_1", result=serialize("result_1"), step_name="test_step"
-        )
-        event1.sequence = 2
-
-        event2 = create_step_completed_event(
-            run_id="test_run", step_id="step_2", result=serialize("result_2"), step_name="test_step"
-        )
-        event2.sequence = 1
-
-        # Provide in wrong order
-        events = [event1, event2]
-
-        replayer = EventReplayer()
-        await replayer.replay(ctx, events)
-
-        # Both should be replayed correctly regardless of input order
-        assert len(ctx.step_results) == 2
-
-    @pytest.mark.asyncio
-    async def test_replay_sets_replaying_flag(self, tmp_path):
-        """Test that replay sets and clears is_replaying flag."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        events = [
-            create_step_completed_event(
-                run_id="test_run",
-                step_id="step_1",
-                result=serialize("result"),
-                step_name="test_step",
-            ),
-        ]
-        events[0].sequence = 1
-
-        assert ctx.is_replaying is False
-
-        replayer = EventReplayer()
-        await replayer.replay(ctx, events)
-
-        # After replay, flag should be cleared
-        assert ctx.is_replaying is False
-
-
-class TestReplayPublicAPI:
-    """Test the public replay API."""
-
-    @pytest.mark.asyncio
-    async def test_replay_events_function(self, tmp_path):
-        """Test the replay_events public function."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        events = [
-            create_step_completed_event(
-                run_id="test_run",
-                step_id="step_1",
-                result=serialize("test_result"),
-                step_name="test_step",
-            ),
-        ]
-        events[0].sequence = 1
-
-        # Use public API
-        await replay_events(ctx, events)
-
-        # Verify replay worked
-        assert "step_1" in ctx.step_results
-        assert ctx.step_results["step_1"] == "test_result"
-
-
-class TestReplayIntegration:
-    """Integration tests for replay with full workflows."""
-
-    @pytest.mark.asyncio
-    async def test_replay_full_workflow(self, tmp_path):
-        """Test replaying a complete workflow event log."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-        )
-
-        # Simulate a workflow with steps and sleep
-        resume_at = datetime.now(UTC)
-        events = [
-            Event(
-                run_id="test_run",
-                type=EventType.WORKFLOW_STARTED,
-                sequence=1,
-                data={"workflow_name": "test_workflow"},
-            ),
-            create_step_started_event(
-                run_id="test_run",
-                step_id="step_1",
-                step_name="first_step",
-                args="[]",
-                kwargs="{}",
-                attempt=1,
-            ),
-            create_step_completed_event(
-                run_id="test_run",
-                step_id="step_1",
-                result=serialize("step_1_result"),
-                step_name="first_step",
-            ),
-            create_sleep_started_event(
-                run_id="test_run",
-                sleep_id="sleep_1",
-                duration_seconds=10,
-                resume_at=resume_at,
-            ),
-            create_sleep_completed_event(run_id="test_run", sleep_id="sleep_1"),
-            create_step_started_event(
-                run_id="test_run",
-                step_id="step_2",
-                step_name="second_step",
-                args="[]",
-                kwargs="{}",
-                attempt=1,
-            ),
-            create_step_completed_event(
-                run_id="test_run",
-                step_id="step_2",
-                result=serialize("step_2_result"),
-                step_name="second_step",
-            ),
-        ]
-
-        # Assign sequences
-        for i, event in enumerate(events, 1):
-            event.sequence = i
-
-        await replay_events(ctx, events)
-
-        # Verify all state was restored
-        assert len(ctx.step_results) == 2
-        assert ctx.step_results["step_1"] == "step_1_result"
-        assert ctx.step_results["step_2"] == "step_2_result"
-        assert ctx.is_sleep_completed("sleep_1")