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

tests/unit/test_event_limits.py

@@ -1,316 +0,0 @@
-"""Unit tests for event limit validation."""
-
-import warnings
-
-import pytest
-from loguru import logger
-
-from pyworkflow.config import configure, get_config, reset_config
-from pyworkflow.context import LocalContext, set_context
-from pyworkflow.core.exceptions import EventLimitExceededError
-from pyworkflow.engine.events import create_step_completed_event
-from pyworkflow.storage.memory import InMemoryStorageBackend
-
-
-@pytest.fixture
-def capture_logs():
-    """Fixture to capture loguru logs for testing."""
-    captured = []
-
-    def sink(message):
-        captured.append(str(message))
-
-    handler_id = logger.add(sink, format="{message}", level="WARNING")
-    yield captured
-    logger.remove(handler_id)
-
-
-class TestEventLimitValidation:
-    """Test event limit validation."""
-
-    @pytest.fixture(autouse=True)
-    def reset_config_fixture(self):
-        """Reset config before and after each test."""
-        reset_config()
-        yield
-        reset_config()
-
-    @pytest.mark.asyncio
-    async def test_hard_limit_raises_error(self):
-        """Test that exceeding hard limit raises EventLimitExceededError."""
-        # Configure with low limits for testing
-        configure(event_hard_limit=10)
-
-        storage = InMemoryStorageBackend()
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-            durable=True,
-        )
-
-        # Add events to reach hard limit
-        for i in range(10):
-            event = create_step_completed_event(
-                run_id="test_run", step_id=f"step_{i}", result="test", step_name="test_step"
-            )
-            await storage.record_event(event)
-
-        # Validation should raise
-        with pytest.raises(EventLimitExceededError) as exc_info:
-            await ctx.validate_event_limits()
-
-        assert exc_info.value.event_count == 10
-        assert exc_info.value.limit == 10
-        assert exc_info.value.run_id == "test_run"
-
-    @pytest.mark.asyncio
-    async def test_hard_limit_message(self):
-        """Test that EventLimitExceededError has correct message."""
-        configure(event_hard_limit=5)
-
-        storage = InMemoryStorageBackend()
-        ctx = LocalContext(
-            run_id="my_run",
-            workflow_name="test_workflow",
-            storage=storage,
-            durable=True,
-        )
-
-        # Add events to reach hard limit
-        for i in range(5):
-            event = create_step_completed_event(
-                run_id="my_run", step_id=f"step_{i}", result="test", step_name="test_step"
-            )
-            await storage.record_event(event)
-
-        with pytest.raises(EventLimitExceededError) as exc_info:
-            await ctx.validate_event_limits()
-
-        assert "my_run" in str(exc_info.value)
-        assert "5 >= 5" in str(exc_info.value)
-
-    @pytest.mark.asyncio
-    async def test_soft_limit_logs_warning(self, capture_logs):
-        """Test that reaching soft limit logs warning."""
-        configure(event_soft_limit=5, event_hard_limit=100)
-
-        storage = InMemoryStorageBackend()
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-            durable=True,
-        )
-
-        # Add events to reach soft limit
-        for i in range(5):
-            event = create_step_completed_event(
-                run_id="test_run", step_id=f"step_{i}", result="test", step_name="test_step"
-            )
-            await storage.record_event(event)
-
-        # Validation should log warning
-        await ctx.validate_event_limits()
-
-        # Check captured logs
-        log_text = "\n".join(capture_logs)
-        assert "approaching event limit" in log_text
-        assert "5/100" in log_text
-
-    @pytest.mark.asyncio
-    async def test_below_soft_limit_no_warning(self, capture_logs):
-        """Test that below soft limit does not log warning."""
-        configure(event_soft_limit=10, event_hard_limit=100)
-
-        storage = InMemoryStorageBackend()
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-            durable=True,
-        )
-
-        # Add events below soft limit
-        for i in range(5):
-            event = create_step_completed_event(
-                run_id="test_run", step_id=f"step_{i}", result="test", step_name="test_step"
-            )
-            await storage.record_event(event)
-
-        # Validation should not log warning
-        await ctx.validate_event_limits()
-
-        # Check captured logs
-        log_text = "\n".join(capture_logs)
-        assert "approaching event limit" not in log_text
-
-    @pytest.mark.asyncio
-    async def test_warning_interval(self, capture_logs):
-        """Test warnings are logged every N events after soft limit."""
-        configure(event_soft_limit=5, event_hard_limit=100, event_warning_interval=3)
-
-        storage = InMemoryStorageBackend()
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=storage,
-            durable=True,
-        )
-        set_context(ctx)
-
-        try:
-            # Add 5 events (soft limit)
-            for i in range(5):
-                event = create_step_completed_event(
-                    run_id="test_run", step_id=f"step_{i}", result="test", step_name="test_step"
-                )
-                await storage.record_event(event)
-
-            # First validation - should warn (at 5)
-            await ctx.validate_event_limits()
-            log_text = "\n".join(capture_logs)
-            assert "approaching event limit" in log_text
-            assert "5/100" in log_text
-
-            # Clear captured logs
-            capture_logs.clear()
-
-            # Add 2 more events (not at interval yet - 7 events total)
-            for i in range(5, 7):
-                event = create_step_completed_event(
-                    run_id="test_run", step_id=f"step_{i}", result="test", step_name="test_step"
-                )
-                await storage.record_event(event)
-
-            # Validation should NOT warn (7 < 5 + 3 = 8)
-            await ctx.validate_event_limits()
-            log_text = "\n".join(capture_logs)
-            assert "approaching event limit" not in log_text
-
-            # Add 1 more (now at 8 events, should warn because 8 >= 5 + 3)
-            event = create_step_completed_event(
-                run_id="test_run", step_id="step_7", result="test", step_name="test_step"
-            )
-            await storage.record_event(event)
-
-            await ctx.validate_event_limits()
-            log_text = "\n".join(capture_logs)
-            assert "approaching event limit" in log_text
-            assert "8/100" in log_text
-        finally:
-            set_context(None)
-
-    @pytest.mark.asyncio
-    async def test_transient_mode_skips_validation(self):
-        """Test that transient mode skips validation."""
-        configure(event_hard_limit=1)  # Very low limit
-
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            durable=False,  # Transient mode
-        )
-
-        # Should not raise even though we would be over the limit
-        await ctx.validate_event_limits()  # No error
-
-    @pytest.mark.asyncio
-    async def test_no_storage_skips_validation(self):
-        """Test that missing storage skips validation."""
-        configure(event_hard_limit=1)  # Very low limit
-
-        ctx = LocalContext(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            storage=None,  # No storage
-            durable=True,
-        )
-
-        # Should not raise - no storage means validation is skipped
-        await ctx.validate_event_limits()  # No error
-
-    def test_configure_warns_on_limit_change(self):
-        """Test that configure() warns when modifying event limits."""
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            configure(event_hard_limit=100000)
-
-            assert len(w) == 1
-            assert "not recommended" in str(w[0].message)
-            assert "event_hard_limit" in str(w[0].message)
-
-    def test_configure_warns_on_multiple_limit_changes(self):
-        """Test that configure() warns when modifying multiple event limits."""
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            configure(event_soft_limit=5000, event_hard_limit=100000)
-
-            assert len(w) == 1
-            assert "not recommended" in str(w[0].message)
-            # Both should be mentioned
-            assert "event_hard_limit" in str(w[0].message)
-            assert "event_soft_limit" in str(w[0].message)
-
-    def test_configure_no_warning_for_other_options(self):
-        """Test that configure() doesn't warn for non-limit options."""
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always")
-            configure(default_retries=5)
-
-            # No warnings for non-limit options
-            assert len(w) == 0
-
-
-class TestEventLimitDefaults:
-    """Test default event limit values."""
-
-    @pytest.fixture(autouse=True)
-    def reset_config_fixture(self):
-        """Reset config before and after each test."""
-        reset_config()
-        yield
-        reset_config()
-
-    def test_default_soft_limit(self):
-        """Test default soft limit is 10,000."""
-        config = get_config()
-        assert config.event_soft_limit == 10_000
-
-    def test_default_hard_limit(self):
-        """Test default hard limit is 50,000."""
-        config = get_config()
-        assert config.event_hard_limit == 50_000
-
-    def test_default_warning_interval(self):
-        """Test default warning interval is 100."""
-        config = get_config()
-        assert config.event_warning_interval == 100
-
-
-class TestEventLimitExceededError:
-    """Test EventLimitExceededError exception."""
-
-    def test_exception_attributes(self):
-        """Test that exception has correct attributes."""
-        error = EventLimitExceededError(
-            run_id="run_123",
-            event_count=50000,
-            limit=50000,
-        )
-
-        assert error.run_id == "run_123"
-        assert error.event_count == 50000
-        assert error.limit == 50000
-
-    def test_exception_inherits_from_fatal_error(self):
-        """Test that EventLimitExceededError inherits from FatalError."""
-        from pyworkflow.core.exceptions import FatalError
-
-        error = EventLimitExceededError(
-            run_id="run_123",
-            event_count=50000,
-            limit=50000,
-        )
-
-        assert isinstance(error, FatalError)

tests/unit/test_executor.py

@@ -1,320 +0,0 @@
-"""
-Unit tests for workflow executor.
-
-Tests use the unified start/resume API with local runtime.
-"""
-
-import pytest
-
-from pyworkflow import configure, reset_config, resume, start
-from pyworkflow.core.exceptions import (
-    WorkflowNotFoundError,
-)
-from pyworkflow.core.step import step
-from pyworkflow.core.workflow import workflow
-from pyworkflow.engine.executor import get_workflow_events, get_workflow_run
-from pyworkflow.primitives.sleep import sleep
-from pyworkflow.storage.file import FileStorageBackend
-from pyworkflow.storage.schemas import RunStatus
-
-
-@pytest.fixture(autouse=True)
-def reset_config_fixture():
-    """Reset configuration before each test."""
-    reset_config()
-    yield
-    reset_config()
-
-
-class TestWorkflowStart:
-    """Test starting workflows."""
-
-    @pytest.mark.asyncio
-    async def test_start_basic_workflow(self, tmp_path):
-        """Test starting a basic workflow."""
-
-        @workflow(name="test_start_workflow")
-        async def my_workflow(x: int):
-            return x * 2
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        run_id = await start(my_workflow, 5, durable=True, storage=storage)
-
-        # Check run was created
-        assert run_id is not None
-        assert run_id.startswith("run_")
-
-        # Check run status
-        run = await storage.get_run(run_id)
-        assert run is not None
-        assert run.status == RunStatus.COMPLETED
-        assert run.workflow_name == "test_start_workflow"
-
-    @pytest.mark.asyncio
-    async def test_start_workflow_with_kwargs(self, tmp_path):
-        """Test starting workflow with keyword arguments."""
-
-        @workflow(name="kwargs_workflow")
-        async def kwargs_workflow(a: int, b: int):
-            return a + b
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        run_id = await start(kwargs_workflow, 10, b=20, durable=True, storage=storage)
-
-        # Check result was stored
-        run = await storage.get_run(run_id)
-        assert run.status == RunStatus.COMPLETED
-
-    @pytest.mark.asyncio
-    async def test_start_with_idempotency_key(self, tmp_path):
-        """Test workflow idempotency."""
-
-        @workflow(name="idempotent_workflow")
-        async def my_workflow():
-            return "done"
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-
-        # First execution
-        run_id1 = await start(
-            my_workflow, durable=True, storage=storage, idempotency_key="unique-key-123"
-        )
-
-        # Second execution with same key - should return same run_id
-        run_id2 = await start(
-            my_workflow, durable=True, storage=storage, idempotency_key="unique-key-123"
-        )
-
-        assert run_id1 == run_id2
-
-    @pytest.mark.asyncio
-    async def test_start_workflow_with_failure(self, tmp_path):
-        """Test starting a workflow that fails."""
-
-        @workflow(name="failing_workflow")
-        async def failing_workflow():
-            raise ValueError("Test failure")
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-
-        with pytest.raises(ValueError, match="Test failure"):
-            await start(failing_workflow, durable=True, storage=storage)
-
-        # Check that run was marked as failed
-        # (We need to get the run_id from storage somehow)
-        # For now, just verify the exception was raised
-
-    @pytest.mark.asyncio
-    async def test_start_workflow_with_suspension(self, tmp_path):
-        """Test starting a workflow that suspends."""
-
-        @workflow(name="suspending_workflow")
-        async def suspending_workflow():
-            await sleep("5s")
-            return "completed"
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        run_id = await start(suspending_workflow, durable=True, storage=storage)
-
-        # Workflow should have suspended
-        run = await storage.get_run(run_id)
-        assert run.status == RunStatus.SUSPENDED
-
-    @pytest.mark.asyncio
-    async def test_start_workflow_with_steps(self, tmp_path):
-        """Test starting a workflow with steps."""
-
-        @step()
-        async def add_step(a: int, b: int):
-            return a + b
-
-        @workflow(name="step_workflow")
-        async def step_workflow(x: int):
-            result = await add_step(x, 10)
-            return result
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        run_id = await start(step_workflow, 5, durable=True, storage=storage)
-
-        # Verify completion
-        run = await storage.get_run(run_id)
-        assert run.status == RunStatus.COMPLETED
-
-        # Verify events include step events
-        events = await storage.get_events(run_id)
-        event_types = [e.type.value for e in events]
-        assert "step.started" in event_types
-        assert "step.completed" in event_types
-
-
-class TestWorkflowResume:
-    """Test resuming workflows."""
-
-    @pytest.mark.asyncio
-    async def test_resume_suspended_workflow(self, tmp_path):
-        """Test resuming a suspended workflow."""
-
-        @workflow(name="resumable_workflow")
-        async def resumable_workflow():
-            await sleep("1s")
-            return "resumed"
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-
-        # Start and suspend
-        run_id = await start(resumable_workflow, durable=True, storage=storage)
-        run = await storage.get_run(run_id)
-        assert run.status == RunStatus.SUSPENDED
-
-        # Resume workflow
-        await resume(run_id, storage=storage)
-
-        # Should complete now
-        # Note: This will still suspend because sleep hasn't actually elapsed
-        # In a real scenario, we'd need time to pass or mock the time check
-
-    @pytest.mark.asyncio
-    async def test_resume_nonexistent_workflow(self, tmp_path):
-        """Test resuming a workflow that doesn't exist."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-
-        with pytest.raises(WorkflowNotFoundError):
-            await resume("nonexistent_run_id", storage=storage)
-
-    @pytest.mark.asyncio
-    async def test_resume_with_replay(self, tmp_path):
-        """Test that resume replays previous events."""
-        execution_count = 0
-
-        @step()
-        async def counting_step():
-            nonlocal execution_count
-            execution_count += 1
-            return "done"
-
-        @workflow(name="replay_workflow")
-        async def replay_workflow():
-            await counting_step()
-            await sleep("1s")
-            await counting_step()  # This should use cached result on resume
-            return "completed"
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-
-        # Start workflow - will execute first step and suspend
-        run_id = await start(replay_workflow, durable=True, storage=storage)
-        assert execution_count == 1
-
-        # Resume - should replay first step (not execute) and suspend again
-        await resume(run_id, storage=storage)
-
-        # First step should have been replayed, not re-executed
-        # So execution_count should still be 1
-        # (Second step hasn't executed yet because sleep hasn't elapsed)
-
-
-class TestWorkflowQueries:
-    """Test workflow query functions."""
-
-    @pytest.mark.asyncio
-    async def test_get_workflow_run(self, tmp_path):
-        """Test getting workflow run information."""
-
-        @workflow(name="query_workflow")
-        async def query_workflow():
-            return "done"
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        run_id = await start(query_workflow, durable=True, storage=storage)
-
-        # Query the run
-        run = await get_workflow_run(run_id, storage=storage)
-
-        assert run is not None
-        assert run.run_id == run_id
-        assert run.workflow_name == "query_workflow"
-        assert run.status == RunStatus.COMPLETED
-
-    @pytest.mark.asyncio
-    async def test_get_workflow_run_nonexistent(self, tmp_path):
-        """Test getting a nonexistent workflow run."""
-        storage = FileStorageBackend(base_path=str(tmp_path))
-
-        run = await get_workflow_run("nonexistent", storage=storage)
-        assert run is None
-
-    @pytest.mark.asyncio
-    async def test_get_workflow_events(self, tmp_path):
-        """Test getting workflow events."""
-
-        @step()
-        async def event_step():
-            return "done"
-
-        @workflow(name="events_workflow")
-        async def events_workflow():
-            await event_step()
-            return "completed"
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        run_id = await start(events_workflow, durable=True, storage=storage)
-
-        # Get events
-        events = await get_workflow_events(run_id, storage=storage)
-
-        assert len(events) > 0
-
-        # Check event types
-        event_types = [e.type.value for e in events]
-        assert "workflow.started" in event_types
-        assert "step.started" in event_types
-        assert "step.completed" in event_types
-        assert "workflow.completed" in event_types
-
-    @pytest.mark.asyncio
-    async def test_workflow_max_duration_stored(self, tmp_path):
-        """Test that workflow max_duration is stored correctly."""
-
-        @workflow(name="timed_workflow", max_duration="1h", tags=["test", "backend"])
-        async def timed_workflow():
-            return "done"
-
-        storage = FileStorageBackend(base_path=str(tmp_path))
-        run_id = await start(timed_workflow, durable=True, storage=storage)
-
-        # Check max_duration was stored on run
-        run = await storage.get_run(run_id)
-        assert run.max_duration == "1h"
-
-        # Check tags were stored on workflow metadata (not run)
-        from pyworkflow.core.registry import get_workflow
-
-        workflow_meta = get_workflow("timed_workflow")
-        assert workflow_meta.tags == ["test", "backend"]
-
-
-class TestWorkflowDefaultStorage:
-    """Test workflows with default storage backend."""
-
-    @pytest.mark.asyncio
-    async def test_start_without_storage_param(self, tmp_path):
-        """Test that configured storage is used by default."""
-        from pyworkflow.storage.memory import InMemoryStorageBackend
-
-        storage = InMemoryStorageBackend()
-        configure(storage=storage, default_durable=True)
-
-        @workflow(name="default_storage_workflow")
-        async def default_workflow():
-            return "done"
-
-        # Start without providing storage (uses configured default)
-        run_id = await start(default_workflow)
-
-        assert run_id is not None
-        assert run_id.startswith("run_")
-
-        # Verify run was stored
-        run = await storage.get_run(run_id)
-        assert run is not None
-        assert run.status == RunStatus.COMPLETED