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

tests/unit/backends/test_dynamodb_storage.py

@@ -1,1554 +0,0 @@
-"""
-Unit tests for DynamoDB storage backend.
-
-These tests verify the DynamoDBStorageBackend implementation.
-For integration tests with a real DynamoDB database, see tests/integration/.
-"""
-
-from contextlib import asynccontextmanager
-from datetime import UTC, datetime
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from pyworkflow.engine.events import Event, EventType
-from pyworkflow.storage.schemas import (
-    Hook,
-    HookStatus,
-    RunStatus,
-    Schedule,
-    ScheduleSpec,
-    ScheduleStatus,
-    StepExecution,
-    StepStatus,
-    WorkflowRun,
-)
-
-# Skip all tests if aiobotocore is not installed
-pytest.importorskip("aiobotocore")
-
-from pyworkflow.storage.dynamodb import DynamoDBStorageBackend
-
-
-@pytest.fixture
-def mock_backend():
-    """Create a backend with mocked client for testing."""
-    backend = DynamoDBStorageBackend()
-    mock_client = AsyncMock()
-
-    @asynccontextmanager
-    async def mock_get_client():
-        yield mock_client
-
-    backend._get_client = mock_get_client
-    return backend, mock_client
-
-
-class TestDynamoDBStorageBackendInit:
-    """Test DynamoDB backend initialization."""
-
-    def test_init_with_defaults(self):
-        """Test initialization with default values."""
-        backend = DynamoDBStorageBackend()
-
-        assert backend.table_name == "pyworkflow"
-        assert backend.region == "us-east-1"
-        assert backend.endpoint_url is None
-        assert backend._initialized is False
-
-    def test_init_with_custom_params(self):
-        """Test initialization with custom parameters."""
-        backend = DynamoDBStorageBackend(
-            table_name="custom_table",
-            region="eu-west-1",
-            endpoint_url="http://localhost:8000",
-        )
-
-        assert backend.table_name == "custom_table"
-        assert backend.region == "eu-west-1"
-        assert backend.endpoint_url == "http://localhost:8000"
-
-    def test_init_with_local_endpoint(self):
-        """Test initialization with DynamoDB Local endpoint."""
-        backend = DynamoDBStorageBackend(
-            endpoint_url="http://localhost:8000",
-        )
-
-        assert backend.endpoint_url == "http://localhost:8000"
-
-
-class TestDynamoDBStorageBackendConfig:
-    """Test configuration and serialization methods."""
-
-    def test_storage_to_config(self):
-        """Test serializing backend to config dict."""
-        from pyworkflow.storage.config import storage_to_config
-
-        backend = DynamoDBStorageBackend(
-            table_name="my_table",
-            region="us-west-2",
-            endpoint_url="http://localhost:8000",
-        )
-
-        config = storage_to_config(backend)
-
-        assert config["type"] == "dynamodb"
-        assert config["table_name"] == "my_table"
-        assert config["region"] == "us-west-2"
-        assert config["endpoint_url"] == "http://localhost:8000"
-
-    def test_config_to_storage(self):
-        """Test deserializing config dict to backend."""
-        from pyworkflow.storage.config import config_to_storage
-
-        config = {
-            "type": "dynamodb",
-            "table_name": "test_table",
-            "region": "ap-northeast-1",
-            "endpoint_url": "http://localhost:8000",
-        }
-
-        backend = config_to_storage(config)
-
-        assert isinstance(backend, DynamoDBStorageBackend)
-        assert backend.table_name == "test_table"
-        assert backend.region == "ap-northeast-1"
-        assert backend.endpoint_url == "http://localhost:8000"
-
-
-class TestDynamoDBStorageBackendConnection:
-    """Test connection management."""
-
-    @pytest.mark.asyncio
-    async def test_connect_creates_table_if_not_exists(self):
-        """Test that connect creates table if it doesn't exist."""
-        backend = DynamoDBStorageBackend(table_name="test_table")
-
-        mock_client = AsyncMock()
-        from botocore.exceptions import ClientError
-
-        mock_client.describe_table = AsyncMock(
-            side_effect=ClientError(
-                {"Error": {"Code": "ResourceNotFoundException"}},
-                "DescribeTable",
-            )
-        )
-        mock_client.create_table = AsyncMock()
-
-        mock_waiter = AsyncMock()
-        mock_waiter.wait = AsyncMock()
-        mock_client.get_waiter = MagicMock(return_value=mock_waiter)
-
-        with patch.object(backend, "_get_client") as mock_get_client:
-            mock_context = AsyncMock()
-            mock_context.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_context.__aexit__ = AsyncMock()
-            mock_get_client.return_value = mock_context
-
-            await backend.connect()
-
-            mock_client.create_table.assert_called_once()
-            call_kwargs = mock_client.create_table.call_args.kwargs
-
-            assert call_kwargs["TableName"] == "test_table"
-            assert call_kwargs["BillingMode"] == "PAY_PER_REQUEST"
-
-            # Verify GSIs were created
-            gsi_names = [gsi["IndexName"] for gsi in call_kwargs["GlobalSecondaryIndexes"]]
-            assert "GSI1" in gsi_names
-            assert "GSI2" in gsi_names
-            assert "GSI3" in gsi_names
-            assert "GSI4" in gsi_names
-            assert "GSI5" in gsi_names
-
-    @pytest.mark.asyncio
-    async def test_connect_skips_create_if_table_exists(self):
-        """Test that connect doesn't create table if it exists."""
-        backend = DynamoDBStorageBackend()
-
-        mock_client = AsyncMock()
-        mock_client.describe_table = AsyncMock(return_value={"Table": {}})
-        mock_client.create_table = AsyncMock()
-
-        with patch.object(backend, "_get_client") as mock_get_client:
-            mock_context = AsyncMock()
-            mock_context.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_context.__aexit__ = AsyncMock()
-            mock_get_client.return_value = mock_context
-
-            await backend.connect()
-
-            mock_client.create_table.assert_not_called()
-            assert backend._initialized is True
-
-    @pytest.mark.asyncio
-    async def test_disconnect_sets_initialized_to_false(self):
-        """Test that disconnect sets _initialized to False."""
-        backend = DynamoDBStorageBackend()
-        backend._initialized = True
-
-        await backend.disconnect()
-
-        assert backend._initialized is False
-
-    @pytest.mark.asyncio
-    async def test_health_check_returns_true_when_healthy(self, mock_backend):
-        """Test health check returns True when list_runs succeeds."""
-        backend, mock_client = mock_backend
-
-        # Mock list_runs to return empty result
-        mock_client.query = AsyncMock(return_value={"Items": []})
-
-        with patch.object(backend, "list_runs", return_value=([], None)):
-            result = await backend.health_check()
-
-        assert result is True
-
-    @pytest.mark.asyncio
-    async def test_health_check_returns_false_on_error(self):
-        """Test health check returns False when list_runs fails."""
-        backend = DynamoDBStorageBackend()
-
-        with patch.object(backend, "list_runs", side_effect=Exception("Connection error")):
-            result = await backend.health_check()
-
-        assert result is False
-
-
-class TestDynamoDBSerialization:
-    """Test DynamoDB value serialization/deserialization."""
-
-    @pytest.fixture
-    def backend(self):
-        """Create a DynamoDB backend instance."""
-        return DynamoDBStorageBackend()
-
-    def test_serialize_string(self, backend):
-        """Test serializing string values."""
-        result = backend._serialize_value("test")
-        assert result == {"S": "test"}
-
-    def test_serialize_int(self, backend):
-        """Test serializing integer values."""
-        result = backend._serialize_value(42)
-        assert result == {"N": "42"}
-
-    def test_serialize_float(self, backend):
-        """Test serializing float values."""
-        result = backend._serialize_value(3.14)
-        assert result == {"N": "3.14"}
-
-    def test_serialize_bool(self, backend):
-        """Test serializing boolean values."""
-        assert backend._serialize_value(True) == {"BOOL": True}
-        assert backend._serialize_value(False) == {"BOOL": False}
-
-    def test_serialize_none(self, backend):
-        """Test serializing None values."""
-        result = backend._serialize_value(None)
-        assert result == {"NULL": True}
-
-    def test_serialize_list(self, backend):
-        """Test serializing list values."""
-        result = backend._serialize_value(["a", 1, True])
-        assert result == {"L": [{"S": "a"}, {"N": "1"}, {"BOOL": True}]}
-
-    def test_serialize_dict(self, backend):
-        """Test serializing dict values."""
-        result = backend._serialize_value({"key": "value", "num": 42})
-        assert result == {"M": {"key": {"S": "value"}, "num": {"N": "42"}}}
-
-    def test_deserialize_string(self, backend):
-        """Test deserializing string values."""
-        result = backend._deserialize_value({"S": "test"})
-        assert result == "test"
-
-    def test_deserialize_number_int(self, backend):
-        """Test deserializing integer number values."""
-        result = backend._deserialize_value({"N": "42"})
-        assert result == 42
-
-    def test_deserialize_number_float(self, backend):
-        """Test deserializing float number values."""
-        result = backend._deserialize_value({"N": "3.14"})
-        assert result == 3.14
-
-    def test_deserialize_bool(self, backend):
-        """Test deserializing boolean values."""
-        assert backend._deserialize_value({"BOOL": True}) is True
-        assert backend._deserialize_value({"BOOL": False}) is False
-
-    def test_deserialize_null(self, backend):
-        """Test deserializing null values."""
-        result = backend._deserialize_value({"NULL": True})
-        assert result is None
-
-    def test_deserialize_list(self, backend):
-        """Test deserializing list values."""
-        result = backend._deserialize_value({"L": [{"S": "a"}, {"N": "1"}, {"BOOL": True}]})
-        assert result == ["a", 1, True]
-
-    def test_deserialize_dict(self, backend):
-        """Test deserializing dict values."""
-        result = backend._deserialize_value({"M": {"key": {"S": "value"}, "num": {"N": "42"}}})
-        assert result == {"key": "value", "num": 42}
-
-
-class TestDynamoDBItemConversion:
-    """Test item-to-object conversion methods."""
-
-    @pytest.fixture
-    def backend(self):
-        """Create a DynamoDB backend instance."""
-        return DynamoDBStorageBackend()
-
-    def test_item_to_workflow_run(self, backend):
-        """Test converting DynamoDB item to WorkflowRun."""
-        now = datetime.now(UTC)
-        item = {
-            "run_id": "test_run",
-            "workflow_name": "test_workflow",
-            "status": "pending",
-            "created_at": now.isoformat(),
-            "updated_at": now.isoformat(),
-            "input_args": "[]",
-            "input_kwargs": "{}",
-            "metadata": "{}",
-            "recovery_attempts": 0,
-            "max_recovery_attempts": 3,
-            "recover_on_worker_loss": True,
-            "nesting_depth": 0,
-        }
-
-        run = backend._item_to_workflow_run(item)
-
-        assert run.run_id == "test_run"
-        assert run.workflow_name == "test_workflow"
-        assert run.status == RunStatus.PENDING
-        assert run.recovery_attempts == 0
-
-    def test_item_to_event(self, backend):
-        """Test converting DynamoDB item to Event."""
-        now = datetime.now(UTC)
-        item = {
-            "event_id": "evt_123",
-            "run_id": "test_run",
-            "sequence": 0,
-            "type": "workflow.started",
-            "timestamp": now.isoformat(),
-            "data": '{"key": "value"}',
-        }
-
-        event = backend._item_to_event(item)
-
-        assert event.event_id == "evt_123"
-        assert event.run_id == "test_run"
-        assert event.type == EventType.WORKFLOW_STARTED
-        assert event.data == {"key": "value"}
-
-    def test_item_to_step_execution(self, backend):
-        """Test converting DynamoDB item to StepExecution."""
-        now = datetime.now(UTC)
-        item = {
-            "step_id": "step_123",
-            "run_id": "test_run",
-            "step_name": "test_step",
-            "status": "completed",
-            "created_at": now.isoformat(),
-            "input_args": "[]",
-            "input_kwargs": "{}",
-            "retry_count": 0,
-        }
-
-        step = backend._item_to_step_execution(item)
-
-        assert step.step_id == "step_123"
-        assert step.run_id == "test_run"
-        assert step.step_name == "test_step"
-        assert step.status == StepStatus.COMPLETED
-        assert step.attempt == 1  # retry_count + 1
-
-    def test_item_to_hook(self, backend):
-        """Test converting DynamoDB item to Hook."""
-        now = datetime.now(UTC)
-        item = {
-            "hook_id": "hook_123",
-            "run_id": "test_run",
-            "token": "token_abc",
-            "created_at": now.isoformat(),
-            "status": "pending",
-            "metadata": "{}",
-        }
-
-        hook = backend._item_to_hook(item)
-
-        assert hook.hook_id == "hook_123"
-        assert hook.run_id == "test_run"
-        assert hook.token == "token_abc"
-        assert hook.status == HookStatus.PENDING
-
-    def test_item_to_schedule(self, backend):
-        """Test converting DynamoDB item to Schedule."""
-        now = datetime.now(UTC)
-        item = {
-            "schedule_id": "sched_123",
-            "workflow_name": "test_workflow",
-            "spec": "0 9 * * *",
-            "spec_type": "cron",
-            "timezone": "UTC",
-            "status": "active",
-            "input_args": "[]",
-            "input_kwargs": "{}",
-            "overlap_policy": "skip",
-            "created_at": now.isoformat(),
-            "running_run_ids": "[]",
-        }
-
-        schedule = backend._item_to_schedule(item)
-
-        assert schedule.schedule_id == "sched_123"
-        assert schedule.workflow_name == "test_workflow"
-        assert schedule.spec.cron == "0 9 * * *"
-        assert schedule.status == ScheduleStatus.ACTIVE
-
-
-class TestDynamoDBKeyPatterns:
-    """Test DynamoDB key pattern generation."""
-
-    @pytest.fixture
-    def backend(self):
-        """Create a DynamoDB backend instance."""
-        return DynamoDBStorageBackend()
-
-    @pytest.mark.asyncio
-    async def test_workflow_run_key_pattern(self, backend):
-        """Test that workflow run uses correct key pattern."""
-        now = datetime.now(UTC)
-        run = WorkflowRun(
-            run_id="test_run_123",
-            workflow_name="test_workflow",
-            status=RunStatus.PENDING,
-            created_at=now,
-            updated_at=now,
-            input_args="[]",
-            input_kwargs="{}",
-        )
-
-        mock_client = AsyncMock()
-        mock_client.put_item = AsyncMock()
-
-        with patch.object(backend, "_get_client") as mock_get_client:
-            mock_context = AsyncMock()
-            mock_context.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_context.__aexit__ = AsyncMock()
-            mock_get_client.return_value = mock_context
-
-            await backend.create_run(run)
-
-            call_args = mock_client.put_item.call_args
-            item = call_args.kwargs["Item"]
-
-            assert item["PK"]["S"] == "RUN#test_run_123"
-            assert item["SK"]["S"] == "#METADATA"
-            assert item["GSI1PK"]["S"] == "RUNS"
-
-    @pytest.mark.asyncio
-    async def test_event_key_pattern(self, backend):
-        """Test that events use correct key pattern with sequence."""
-        now = datetime.now(UTC)
-        event = Event(
-            event_id="evt_123",
-            run_id="test_run_123",
-            type=EventType.WORKFLOW_STARTED,
-            timestamp=now,
-            data={},
-        )
-
-        mock_client = AsyncMock()
-        mock_client.update_item = AsyncMock(return_value={"Attributes": {"seq": {"N": "1"}}})
-        mock_client.put_item = AsyncMock()
-
-        with patch.object(backend, "_get_client") as mock_get_client:
-            mock_context = AsyncMock()
-            mock_context.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_context.__aexit__ = AsyncMock()
-            mock_get_client.return_value = mock_context
-
-            await backend.record_event(event)
-
-            put_call = mock_client.put_item.call_args
-            item = put_call.kwargs["Item"]
-
-            assert item["PK"]["S"] == "RUN#test_run_123"
-            assert item["SK"]["S"].startswith("EVENT#")
-
-
-class TestWorkflowRunOperations:
-    """Test workflow run CRUD operations."""
-
-    @pytest.mark.asyncio
-    async def test_create_run(self, mock_backend):
-        """Test creating a workflow run."""
-        backend, mock_client = mock_backend
-        mock_client.put_item = AsyncMock()
-
-        now = datetime.now(UTC)
-        run = WorkflowRun(
-            run_id="test_run",
-            workflow_name="test_workflow",
-            status=RunStatus.PENDING,
-            created_at=now,
-            updated_at=now,
-            input_args="[]",
-            input_kwargs="{}",
-        )
-
-        await backend.create_run(run)
-
-        mock_client.put_item.assert_called_once()
-        call_kwargs = mock_client.put_item.call_args.kwargs
-        assert call_kwargs["TableName"] == "pyworkflow"
-        assert "PK" in call_kwargs["Item"]
-
-    @pytest.mark.asyncio
-    async def test_get_run_found(self, mock_backend):
-        """Test getting an existing workflow run."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.get_item = AsyncMock(
-            return_value={
-                "Item": {
-                    "run_id": {"S": "test_run"},
-                    "workflow_name": {"S": "test_workflow"},
-                    "status": {"S": "pending"},
-                    "created_at": {"S": now.isoformat()},
-                    "updated_at": {"S": now.isoformat()},
-                    "input_args": {"S": "[]"},
-                    "input_kwargs": {"S": "{}"},
-                    "metadata": {"S": "{}"},
-                    "recovery_attempts": {"N": "0"},
-                    "max_recovery_attempts": {"N": "3"},
-                    "recover_on_worker_loss": {"BOOL": True},
-                    "nesting_depth": {"N": "0"},
-                }
-            }
-        )
-
-        result = await backend.get_run("test_run")
-
-        assert result is not None
-        assert result.run_id == "test_run"
-        assert result.workflow_name == "test_workflow"
-
-    @pytest.mark.asyncio
-    async def test_get_run_not_found(self, mock_backend):
-        """Test getting a non-existent workflow run."""
-        backend, mock_client = mock_backend
-        mock_client.get_item = AsyncMock(return_value={})
-
-        result = await backend.get_run("nonexistent")
-
-        assert result is None
-
-    @pytest.mark.asyncio
-    async def test_get_run_by_idempotency_key(self, mock_backend):
-        """Test getting run by idempotency key uses GSI3."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "run_id": {"S": "test_run"},
-                        "workflow_name": {"S": "test_workflow"},
-                        "status": {"S": "pending"},
-                        "created_at": {"S": now.isoformat()},
-                        "updated_at": {"S": now.isoformat()},
-                        "input_args": {"S": "[]"},
-                        "input_kwargs": {"S": "{}"},
-                        "metadata": {"S": "{}"},
-                        "recovery_attempts": {"N": "0"},
-                        "max_recovery_attempts": {"N": "3"},
-                        "recover_on_worker_loss": {"BOOL": True},
-                        "nesting_depth": {"N": "0"},
-                    }
-                ]
-            }
-        )
-
-        result = await backend.get_run_by_idempotency_key("my_key")
-
-        call_args = mock_client.query.call_args
-        assert call_args.kwargs["IndexName"] == "GSI3"
-        assert result is not None
-        assert result.run_id == "test_run"
-
-    @pytest.mark.asyncio
-    async def test_update_run_status(self, mock_backend):
-        """Test updating run status."""
-        backend, mock_client = mock_backend
-        mock_client.update_item = AsyncMock()
-
-        await backend.update_run_status(
-            run_id="test_run",
-            status=RunStatus.RUNNING,
-        )
-
-        mock_client.update_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_list_runs(self, mock_backend):
-        """Test listing workflow runs."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "run_id": {"S": "run_1"},
-                        "workflow_name": {"S": "test"},
-                        "status": {"S": "pending"},
-                        "created_at": {"S": now.isoformat()},
-                        "updated_at": {"S": now.isoformat()},
-                        "input_args": {"S": "[]"},
-                        "input_kwargs": {"S": "{}"},
-                        "metadata": {"S": "{}"},
-                        "recovery_attempts": {"N": "0"},
-                        "max_recovery_attempts": {"N": "3"},
-                        "recover_on_worker_loss": {"BOOL": True},
-                        "nesting_depth": {"N": "0"},
-                    }
-                ]
-            }
-        )
-
-        runs, cursor = await backend.list_runs()
-
-        assert len(runs) == 1
-        assert runs[0].run_id == "run_1"
-
-
-class TestEventOperations:
-    """Test event log operations."""
-
-    @pytest.mark.asyncio
-    async def test_record_event(self, mock_backend):
-        """Test recording an event."""
-        backend, mock_client = mock_backend
-        mock_client.update_item = AsyncMock(return_value={"Attributes": {"seq": {"N": "1"}}})
-        mock_client.put_item = AsyncMock()
-
-        now = datetime.now(UTC)
-        event = Event(
-            event_id="evt_1",
-            run_id="test_run",
-            type=EventType.WORKFLOW_STARTED,
-            timestamp=now,
-            data={},
-        )
-
-        await backend.record_event(event)
-
-        mock_client.put_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_get_events(self, mock_backend):
-        """Test getting events for a run."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "event_id": {"S": "evt_1"},
-                        "run_id": {"S": "test_run"},
-                        "sequence": {"N": "0"},
-                        "type": {"S": "workflow.started"},
-                        "timestamp": {"S": now.isoformat()},
-                        "data": {"S": "{}"},
-                    }
-                ]
-            }
-        )
-
-        events = await backend.get_events("test_run")
-
-        assert len(events) == 1
-        assert events[0].event_id == "evt_1"
-
-    @pytest.mark.asyncio
-    async def test_get_latest_event(self, mock_backend):
-        """Test getting latest event for a run."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "event_id": {"S": "evt_5"},
-                        "run_id": {"S": "test_run"},
-                        "sequence": {"N": "5"},
-                        "type": {"S": "step.completed"},
-                        "timestamp": {"S": now.isoformat()},
-                        "data": {"S": "{}"},
-                    }
-                ]
-            }
-        )
-
-        event = await backend.get_latest_event("test_run")
-
-        assert event is not None
-        assert event.event_id == "evt_5"
-
-
-class TestStepOperations:
-    """Test step execution operations."""
-
-    @pytest.mark.asyncio
-    async def test_create_step(self, mock_backend):
-        """Test creating a step execution."""
-        backend, mock_client = mock_backend
-        mock_client.put_item = AsyncMock()
-
-        now = datetime.now(UTC)
-        step = StepExecution(
-            step_id="step_1",
-            run_id="test_run",
-            step_name="test_step",
-            status=StepStatus.RUNNING,
-            created_at=now,
-            input_args="[]",
-            input_kwargs="{}",
-            attempt=1,
-        )
-
-        await backend.create_step(step)
-
-        mock_client.put_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_get_step_found(self, mock_backend):
-        """Test getting an existing step."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.scan = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "step_id": {"S": "step_1"},
-                        "run_id": {"S": "test_run"},
-                        "step_name": {"S": "test_step"},
-                        "status": {"S": "completed"},
-                        "created_at": {"S": now.isoformat()},
-                        "input_args": {"S": "[]"},
-                        "input_kwargs": {"S": "{}"},
-                        "retry_count": {"N": "0"},
-                    }
-                ]
-            }
-        )
-
-        result = await backend.get_step("step_1")
-
-        assert result is not None
-        assert result.step_id == "step_1"
-
-    @pytest.mark.asyncio
-    async def test_get_step_not_found(self, mock_backend):
-        """Test getting a non-existent step."""
-        backend, mock_client = mock_backend
-        mock_client.scan = AsyncMock(return_value={"Items": []})
-
-        result = await backend.get_step("nonexistent")
-
-        assert result is None
-
-    @pytest.mark.asyncio
-    async def test_update_step_status(self, mock_backend):
-        """Test updating step status."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        # Mock get_step to return a step
-        mock_client.scan = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "step_id": {"S": "step_1"},
-                        "run_id": {"S": "test_run"},
-                        "step_name": {"S": "test_step"},
-                        "status": {"S": "running"},
-                        "created_at": {"S": now.isoformat()},
-                        "input_args": {"S": "[]"},
-                        "input_kwargs": {"S": "{}"},
-                        "retry_count": {"N": "0"},
-                    }
-                ]
-            }
-        )
-        mock_client.update_item = AsyncMock()
-
-        await backend.update_step_status(
-            step_id="step_1",
-            status="completed",
-            result='{"output": "success"}',
-        )
-
-        mock_client.update_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_list_steps(self, mock_backend):
-        """Test listing steps for a run."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "step_id": {"S": "step_1"},
-                        "run_id": {"S": "test_run"},
-                        "step_name": {"S": "step_1"},
-                        "status": {"S": "completed"},
-                        "created_at": {"S": now.isoformat()},
-                        "input_args": {"S": "[]"},
-                        "input_kwargs": {"S": "{}"},
-                        "retry_count": {"N": "0"},
-                    }
-                ]
-            }
-        )
-
-        steps = await backend.list_steps("test_run")
-
-        assert len(steps) == 1
-
-
-class TestHookOperations:
-    """Test hook/webhook operations."""
-
-    @pytest.mark.asyncio
-    async def test_create_hook(self, mock_backend):
-        """Test creating a hook."""
-        backend, mock_client = mock_backend
-        mock_client.put_item = AsyncMock()
-
-        now = datetime.now(UTC)
-        hook = Hook(
-            hook_id="hook_1",
-            run_id="test_run",
-            token="token_abc",
-            status=HookStatus.PENDING,
-            created_at=now,
-        )
-
-        await backend.create_hook(hook)
-
-        # Should be called twice (hook record + token lookup)
-        assert mock_client.put_item.call_count == 2
-
-    @pytest.mark.asyncio
-    async def test_get_hook_found(self, mock_backend):
-        """Test getting an existing hook."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.get_item = AsyncMock(
-            return_value={
-                "Item": {
-                    "hook_id": {"S": "hook_1"},
-                    "run_id": {"S": "test_run"},
-                    "token": {"S": "token_abc"},
-                    "status": {"S": "pending"},
-                    "created_at": {"S": now.isoformat()},
-                    "metadata": {"S": "{}"},
-                }
-            }
-        )
-
-        result = await backend.get_hook("hook_1")
-
-        assert result is not None
-        assert result.hook_id == "hook_1"
-
-    @pytest.mark.asyncio
-    async def test_get_hook_not_found(self, mock_backend):
-        """Test getting a non-existent hook."""
-        backend, mock_client = mock_backend
-        mock_client.get_item = AsyncMock(return_value={})
-
-        result = await backend.get_hook("nonexistent")
-
-        assert result is None
-
-    @pytest.mark.asyncio
-    async def test_get_hook_by_token(self, mock_backend):
-        """Test getting hook by token."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        # First query returns the token lookup item with hook_id
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "PK": {"S": "TOKEN#token_abc"},
-                        "SK": {"S": "TOKEN#token_abc"},
-                        "hook_id": {"S": "hook_1"},
-                    }
-                ]
-            }
-        )
-
-        # Then get_item fetches the actual hook
-        mock_client.get_item = AsyncMock(
-            return_value={
-                "Item": {
-                    "hook_id": {"S": "hook_1"},
-                    "run_id": {"S": "test_run"},
-                    "token": {"S": "token_abc"},
-                    "status": {"S": "pending"},
-                    "created_at": {"S": now.isoformat()},
-                    "metadata": {"S": "{}"},
-                }
-            }
-        )
-
-        result = await backend.get_hook_by_token("token_abc")
-
-        assert result is not None
-        assert result.token == "token_abc"
-        mock_client.query.assert_called_once()
-        mock_client.get_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_update_hook_status(self, mock_backend):
-        """Test updating hook status."""
-        backend, mock_client = mock_backend
-        mock_client.update_item = AsyncMock()
-
-        await backend.update_hook_status(
-            hook_id="hook_1",
-            status=HookStatus.RECEIVED,
-            payload='{"data": "payload"}',
-        )
-
-        mock_client.update_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_list_hooks(self, mock_backend):
-        """Test listing hooks for a run."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "hook_id": {"S": "hook_1"},
-                        "run_id": {"S": "test_run"},
-                        "token": {"S": "token_abc"},
-                        "status": {"S": "pending"},
-                        "created_at": {"S": now.isoformat()},
-                        "metadata": {"S": "{}"},
-                    }
-                ]
-            }
-        )
-
-        hooks = await backend.list_hooks(run_id="test_run")
-
-        assert len(hooks) == 1
-
-
-class TestCancellationOperations:
-    """Test cancellation flag operations."""
-
-    @pytest.mark.asyncio
-    async def test_set_cancellation_flag(self, mock_backend):
-        """Test setting a cancellation flag."""
-        backend, mock_client = mock_backend
-        mock_client.put_item = AsyncMock()
-
-        await backend.set_cancellation_flag("run_123")
-
-        call_args = mock_client.put_item.call_args
-        item = call_args.kwargs["Item"]
-        assert item["PK"]["S"] == "CANCEL#run_123"
-        assert item["SK"]["S"] == "#FLAG"
-
-    @pytest.mark.asyncio
-    async def test_check_cancellation_flag_set(self, mock_backend):
-        """Test checking cancellation flag when it exists."""
-        backend, mock_client = mock_backend
-        mock_client.get_item = AsyncMock(return_value={"Item": {"PK": {"S": "CANCEL#run_123"}}})
-
-        result = await backend.check_cancellation_flag("run_123")
-
-        assert result is True
-
-    @pytest.mark.asyncio
-    async def test_check_cancellation_flag_not_set(self, mock_backend):
-        """Test checking cancellation flag when it doesn't exist."""
-        backend, mock_client = mock_backend
-        mock_client.get_item = AsyncMock(return_value={})
-
-        result = await backend.check_cancellation_flag("run_123")
-
-        assert result is False
-
-    @pytest.mark.asyncio
-    async def test_clear_cancellation_flag(self, mock_backend):
-        """Test clearing a cancellation flag."""
-        backend, mock_client = mock_backend
-        mock_client.delete_item = AsyncMock()
-
-        await backend.clear_cancellation_flag("run_123")
-
-        call_args = mock_client.delete_item.call_args
-        key = call_args.kwargs["Key"]
-        assert key["PK"]["S"] == "CANCEL#run_123"
-        assert key["SK"]["S"] == "#FLAG"
-
-
-class TestContinueAsNewOperations:
-    """Test continue-as-new chain operations."""
-
-    @pytest.mark.asyncio
-    async def test_update_run_continuation(self, mock_backend):
-        """Test updating run continuation link."""
-        backend, mock_client = mock_backend
-        mock_client.update_item = AsyncMock()
-
-        await backend.update_run_continuation("run_1", "run_2")
-
-        mock_client.update_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_get_workflow_chain(self, mock_backend):
-        """Test getting workflow chain."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        # Chain: run_1 -> run_2
-        # run_1: first in chain (no continued_from_run_id), has continued_to_run_id
-        # run_2: second in chain, has continued_from_run_id, no continued_to_run_id
-        run_1_item = {
-            "Item": {
-                "run_id": {"S": "run_1"},
-                "workflow_name": {"S": "test"},
-                "status": {"S": "completed"},
-                "created_at": {"S": now.isoformat()},
-                "updated_at": {"S": now.isoformat()},
-                "input_args": {"S": "[]"},
-                "input_kwargs": {"S": "{}"},
-                "metadata": {"S": "{}"},
-                "recovery_attempts": {"N": "0"},
-                "max_recovery_attempts": {"N": "3"},
-                "recover_on_worker_loss": {"BOOL": True},
-                "nesting_depth": {"N": "0"},
-                "continued_to_run_id": {"S": "run_2"},
-            }
-        }
-        run_2_item = {
-            "Item": {
-                "run_id": {"S": "run_2"},
-                "workflow_name": {"S": "test"},
-                "status": {"S": "completed"},
-                "created_at": {"S": now.isoformat()},
-                "updated_at": {"S": now.isoformat()},
-                "input_args": {"S": "[]"},
-                "input_kwargs": {"S": "{}"},
-                "metadata": {"S": "{}"},
-                "recovery_attempts": {"N": "0"},
-                "max_recovery_attempts": {"N": "3"},
-                "recover_on_worker_loss": {"BOOL": True},
-                "nesting_depth": {"N": "0"},
-                "continued_from_run_id": {"S": "run_1"},
-            }
-        }
-
-        # Mock get_item to return different items based on which run is requested
-        async def mock_get_item(**kwargs):
-            key = kwargs.get("Key", {})
-            pk = key.get("PK", {}).get("S", "")
-            if "run_1" in pk:
-                return run_1_item
-            elif "run_2" in pk:
-                return run_2_item
-            return {}
-
-        mock_client.get_item = AsyncMock(side_effect=mock_get_item)
-
-        result = await backend.get_workflow_chain("run_2")
-
-        assert len(result) == 2
-        assert result[0].run_id == "run_1"
-        assert result[1].run_id == "run_2"
-
-
-class TestChildWorkflowOperations:
-    """Test child workflow operations."""
-
-    @pytest.mark.asyncio
-    async def test_get_children(self, mock_backend):
-        """Test getting child workflows uses GSI4."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "run_id": {"S": "child_1"},
-                        "workflow_name": {"S": "child_workflow"},
-                        "status": {"S": "completed"},
-                        "created_at": {"S": now.isoformat()},
-                        "updated_at": {"S": now.isoformat()},
-                        "input_args": {"S": "[]"},
-                        "input_kwargs": {"S": "{}"},
-                        "metadata": {"S": "{}"},
-                        "recovery_attempts": {"N": "0"},
-                        "max_recovery_attempts": {"N": "3"},
-                        "recover_on_worker_loss": {"BOOL": True},
-                        "nesting_depth": {"N": "1"},
-                        "parent_run_id": {"S": "parent_123"},
-                    }
-                ]
-            }
-        )
-
-        result = await backend.get_children("parent_123")
-
-        call_args = mock_client.query.call_args
-        assert call_args.kwargs["IndexName"] == "GSI4"
-        assert len(result) == 1
-        assert result[0].run_id == "child_1"
-
-    @pytest.mark.asyncio
-    async def test_get_parent_found(self, mock_backend):
-        """Test getting parent workflow."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        # First call returns child run
-        child_response = {
-            "Item": {
-                "run_id": {"S": "child_1"},
-                "workflow_name": {"S": "child"},
-                "status": {"S": "running"},
-                "created_at": {"S": now.isoformat()},
-                "updated_at": {"S": now.isoformat()},
-                "input_args": {"S": "[]"},
-                "input_kwargs": {"S": "{}"},
-                "metadata": {"S": "{}"},
-                "recovery_attempts": {"N": "0"},
-                "max_recovery_attempts": {"N": "3"},
-                "recover_on_worker_loss": {"BOOL": True},
-                "nesting_depth": {"N": "1"},
-                "parent_run_id": {"S": "parent_1"},
-            }
-        }
-
-        # Second call returns parent run
-        parent_response = {
-            "Item": {
-                "run_id": {"S": "parent_1"},
-                "workflow_name": {"S": "parent"},
-                "status": {"S": "running"},
-                "created_at": {"S": now.isoformat()},
-                "updated_at": {"S": now.isoformat()},
-                "input_args": {"S": "[]"},
-                "input_kwargs": {"S": "{}"},
-                "metadata": {"S": "{}"},
-                "recovery_attempts": {"N": "0"},
-                "max_recovery_attempts": {"N": "3"},
-                "recover_on_worker_loss": {"BOOL": True},
-                "nesting_depth": {"N": "0"},
-            }
-        }
-
-        mock_client.get_item = AsyncMock(side_effect=[child_response, parent_response])
-
-        result = await backend.get_parent("child_1")
-
-        assert result is not None
-        assert result.run_id == "parent_1"
-
-    @pytest.mark.asyncio
-    async def test_get_parent_not_found(self, mock_backend):
-        """Test getting parent when no parent exists."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.get_item = AsyncMock(
-            return_value={
-                "Item": {
-                    "run_id": {"S": "root_run"},
-                    "workflow_name": {"S": "test"},
-                    "status": {"S": "running"},
-                    "created_at": {"S": now.isoformat()},
-                    "updated_at": {"S": now.isoformat()},
-                    "input_args": {"S": "[]"},
-                    "input_kwargs": {"S": "{}"},
-                    "metadata": {"S": "{}"},
-                    "recovery_attempts": {"N": "0"},
-                    "max_recovery_attempts": {"N": "3"},
-                    "recover_on_worker_loss": {"BOOL": True},
-                    "nesting_depth": {"N": "0"},
-                }
-            }
-        )
-
-        result = await backend.get_parent("root_run")
-
-        assert result is None
-
-    @pytest.mark.asyncio
-    async def test_get_nesting_depth(self, mock_backend):
-        """Test getting nesting depth."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.get_item = AsyncMock(
-            return_value={
-                "Item": {
-                    "run_id": {"S": "child_run"},
-                    "workflow_name": {"S": "test"},
-                    "status": {"S": "running"},
-                    "created_at": {"S": now.isoformat()},
-                    "updated_at": {"S": now.isoformat()},
-                    "input_args": {"S": "[]"},
-                    "input_kwargs": {"S": "{}"},
-                    "metadata": {"S": "{}"},
-                    "recovery_attempts": {"N": "0"},
-                    "max_recovery_attempts": {"N": "3"},
-                    "recover_on_worker_loss": {"BOOL": True},
-                    "nesting_depth": {"N": "2"},
-                }
-            }
-        )
-
-        result = await backend.get_nesting_depth("child_run")
-
-        assert result == 2
-
-
-class TestScheduleOperations:
-    """Test schedule CRUD operations."""
-
-    @pytest.mark.asyncio
-    async def test_create_schedule(self, mock_backend):
-        """Test creating a schedule."""
-        backend, mock_client = mock_backend
-        mock_client.put_item = AsyncMock()
-
-        now = datetime.now(UTC)
-        schedule = Schedule(
-            schedule_id="sched_1",
-            workflow_name="test_workflow",
-            spec=ScheduleSpec(cron="0 9 * * *"),
-            status=ScheduleStatus.ACTIVE,
-            created_at=now,
-        )
-
-        await backend.create_schedule(schedule)
-
-        mock_client.put_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_get_schedule_found(self, mock_backend):
-        """Test getting an existing schedule."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.get_item = AsyncMock(
-            return_value={
-                "Item": {
-                    "schedule_id": {"S": "sched_1"},
-                    "workflow_name": {"S": "test_workflow"},
-                    "spec": {"S": "0 9 * * *"},
-                    "spec_type": {"S": "cron"},
-                    "timezone": {"S": "UTC"},
-                    "status": {"S": "active"},
-                    "input_args": {"S": "[]"},
-                    "input_kwargs": {"S": "{}"},
-                    "overlap_policy": {"S": "skip"},
-                    "created_at": {"S": now.isoformat()},
-                    "running_run_ids": {"S": "[]"},
-                }
-            }
-        )
-
-        result = await backend.get_schedule("sched_1")
-
-        assert result is not None
-        assert result.schedule_id == "sched_1"
-
-    @pytest.mark.asyncio
-    async def test_get_schedule_not_found(self, mock_backend):
-        """Test getting a non-existent schedule."""
-        backend, mock_client = mock_backend
-        mock_client.get_item = AsyncMock(return_value={})
-
-        result = await backend.get_schedule("nonexistent")
-
-        assert result is None
-
-    @pytest.mark.asyncio
-    async def test_update_schedule(self, mock_backend):
-        """Test updating a schedule."""
-        backend, mock_client = mock_backend
-        mock_client.put_item = AsyncMock()
-
-        now = datetime.now(UTC)
-        schedule = Schedule(
-            schedule_id="sched_1",
-            workflow_name="test_workflow",
-            spec=ScheduleSpec(cron="0 10 * * *"),
-            status=ScheduleStatus.PAUSED,
-            created_at=now,
-        )
-
-        await backend.update_schedule(schedule)
-
-        mock_client.put_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_delete_schedule(self, mock_backend):
-        """Test deleting a schedule."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.get_item = AsyncMock(
-            return_value={
-                "Item": {
-                    "schedule_id": {"S": "sched_1"},
-                    "workflow_name": {"S": "test"},
-                    "spec": {"S": "0 9 * * *"},
-                    "spec_type": {"S": "cron"},
-                    "timezone": {"S": "UTC"},
-                    "status": {"S": "active"},
-                    "input_args": {"S": "[]"},
-                    "input_kwargs": {"S": "{}"},
-                    "overlap_policy": {"S": "skip"},
-                    "created_at": {"S": now.isoformat()},
-                    "running_run_ids": {"S": "[]"},
-                }
-            }
-        )
-        mock_client.put_item = AsyncMock()
-
-        await backend.delete_schedule("sched_1")
-
-        mock_client.put_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_list_schedules(self, mock_backend):
-        """Test listing schedules."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "schedule_id": {"S": "sched_1"},
-                        "workflow_name": {"S": "test"},
-                        "spec": {"S": "0 9 * * *"},
-                        "spec_type": {"S": "cron"},
-                        "timezone": {"S": "UTC"},
-                        "status": {"S": "active"},
-                        "input_args": {"S": "[]"},
-                        "input_kwargs": {"S": "{}"},
-                        "overlap_policy": {"S": "skip"},
-                        "created_at": {"S": now.isoformat()},
-                        "running_run_ids": {"S": "[]"},
-                    }
-                ]
-            }
-        )
-
-        schedules = await backend.list_schedules()
-
-        assert len(schedules) == 1
-
-    @pytest.mark.asyncio
-    async def test_get_due_schedules(self, mock_backend):
-        """Test getting due schedules uses GSI5."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.query = AsyncMock(
-            return_value={
-                "Items": [
-                    {
-                        "schedule_id": {"S": "sched_1"},
-                        "workflow_name": {"S": "test"},
-                        "spec": {"S": "0 9 * * *"},
-                        "spec_type": {"S": "cron"},
-                        "timezone": {"S": "UTC"},
-                        "status": {"S": "active"},
-                        "input_args": {"S": "[]"},
-                        "input_kwargs": {"S": "{}"},
-                        "overlap_policy": {"S": "skip"},
-                        "created_at": {"S": now.isoformat()},
-                        "next_run_time": {"S": now.isoformat()},
-                        "running_run_ids": {"S": "[]"},
-                    }
-                ]
-            }
-        )
-
-        result = await backend.get_due_schedules(now)
-
-        call_args = mock_client.query.call_args
-        assert call_args.kwargs["IndexName"] == "GSI5"
-        assert call_args.kwargs["ExpressionAttributeValues"][":pk"]["S"] == "ACTIVE_SCHEDULES"
-        assert len(result) == 1
-
-    @pytest.mark.asyncio
-    async def test_add_running_run(self, mock_backend):
-        """Test adding a running run to schedule."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.get_item = AsyncMock(
-            return_value={
-                "Item": {
-                    "schedule_id": {"S": "sched_1"},
-                    "workflow_name": {"S": "test"},
-                    "spec": {"S": "0 9 * * *"},
-                    "spec_type": {"S": "cron"},
-                    "timezone": {"S": "UTC"},
-                    "status": {"S": "active"},
-                    "input_args": {"S": "[]"},
-                    "input_kwargs": {"S": "{}"},
-                    "overlap_policy": {"S": "skip"},
-                    "created_at": {"S": now.isoformat()},
-                    "running_run_ids": {"S": "[]"},
-                }
-            }
-        )
-        mock_client.put_item = AsyncMock()
-
-        await backend.add_running_run("sched_1", "run_1")
-
-        mock_client.put_item.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_remove_running_run(self, mock_backend):
-        """Test removing a running run from schedule."""
-        backend, mock_client = mock_backend
-        now = datetime.now(UTC)
-
-        mock_client.get_item = AsyncMock(
-            return_value={
-                "Item": {
-                    "schedule_id": {"S": "sched_1"},
-                    "workflow_name": {"S": "test"},
-                    "spec": {"S": "0 9 * * *"},
-                    "spec_type": {"S": "cron"},
-                    "timezone": {"S": "UTC"},
-                    "status": {"S": "active"},
-                    "input_args": {"S": "[]"},
-                    "input_kwargs": {"S": "{}"},
-                    "overlap_policy": {"S": "skip"},
-                    "created_at": {"S": now.isoformat()},
-                    "running_run_ids": {"S": '["run_1", "run_2"]'},
-                }
-            }
-        )
-        mock_client.put_item = AsyncMock()
-
-        await backend.remove_running_run("sched_1", "run_1")
-
-        mock_client.put_item.assert_called_once()
-
-
-class TestDynamoDBGSIQueries:
-    """Test GSI-based queries."""
-
-    @pytest.fixture
-    def backend(self):
-        """Create a DynamoDB backend instance."""
-        return DynamoDBStorageBackend()
-
-    @pytest.mark.asyncio
-    async def test_gsi1_runs_by_status(self, backend):
-        """Test that list_runs uses GSI1 for status queries."""
-        mock_client = AsyncMock()
-        mock_client.query = AsyncMock(return_value={"Items": []})
-
-        with patch.object(backend, "_get_client") as mock_get_client:
-            mock_context = AsyncMock()
-            mock_context.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_context.__aexit__ = AsyncMock()
-            mock_get_client.return_value = mock_context
-
-            await backend.list_runs(status=RunStatus.RUNNING)
-
-            call_args = mock_client.query.call_args
-            assert call_args.kwargs["IndexName"] == "GSI1"
-
-    @pytest.mark.asyncio
-    async def test_gsi3_idempotency_key(self, backend):
-        """Test that get_run_by_idempotency_key uses GSI3."""
-        mock_client = AsyncMock()
-        mock_client.query = AsyncMock(return_value={"Items": []})
-
-        with patch.object(backend, "_get_client") as mock_get_client:
-            mock_context = AsyncMock()
-            mock_context.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_context.__aexit__ = AsyncMock()
-            mock_get_client.return_value = mock_context
-
-            await backend.get_run_by_idempotency_key("test_key")
-
-            call_args = mock_client.query.call_args
-            assert call_args.kwargs["IndexName"] == "GSI3"
-            assert "IDEMPOTENCY#test_key" in str(call_args.kwargs["ExpressionAttributeValues"])
-
-    @pytest.mark.asyncio
-    async def test_gsi4_children(self, backend):
-        """Test that get_children uses GSI4."""
-        mock_client = AsyncMock()
-        mock_client.query = AsyncMock(return_value={"Items": []})
-
-        with patch.object(backend, "_get_client") as mock_get_client:
-            mock_context = AsyncMock()
-            mock_context.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_context.__aexit__ = AsyncMock()
-            mock_get_client.return_value = mock_context
-
-            await backend.get_children("parent_123")
-
-            call_args = mock_client.query.call_args
-            assert call_args.kwargs["IndexName"] == "GSI4"
-            assert "PARENT#parent_123" in str(call_args.kwargs["ExpressionAttributeValues"])
-
-    @pytest.mark.asyncio
-    async def test_gsi5_due_schedules(self, backend):
-        """Test that get_due_schedules uses GSI5."""
-        now = datetime.now(UTC)
-        mock_client = AsyncMock()
-        mock_client.query = AsyncMock(return_value={"Items": []})
-
-        with patch.object(backend, "_get_client") as mock_get_client:
-            mock_context = AsyncMock()
-            mock_context.__aenter__ = AsyncMock(return_value=mock_client)
-            mock_context.__aexit__ = AsyncMock()
-            mock_get_client.return_value = mock_context
-
-            await backend.get_due_schedules(now)
-
-            call_args = mock_client.query.call_args
-            assert call_args.kwargs["IndexName"] == "GSI5"
-            assert "ACTIVE_SCHEDULES" in str(call_args.kwargs["ExpressionAttributeValues"])