taskqueue-toolkit 0.1.0__py3-none-any.whl

taskqueue_toolkit/testing/pubsub.py

@@ -0,0 +1,149 @@
+"""An in-memory double of the slice of google-cloud-pubsub that
+PubsubTaskQueue calls, for testing code that uses this package without a
+real Pub/Sub project or emulator.
+
+Usage:
+    broker = FakePubsubBroker()
+    queue = PubsubTaskQueue(
+        dsn=dsn,
+        encode=encode,
+        decode=decode,
+        publisher_factory=broker.publisher,
+        subscriber_factory=broker.subscriber,
+    )
+
+All methods on the fake clients are synchronous, matching the real (sync
+gRPC) SDK — PubsubTaskQueue always calls through asyncio.to_thread, never
+awaits these directly.
+
+Each FakePubsubBroker instance owns its own isolated state — create a new
+one per test rather than sharing one, and there is nothing to reset between
+tests.
+"""
+
+from __future__ import annotations
+
+import uuid
+from collections import deque
+from dataclasses import dataclass, field
+from typing import NamedTuple
+
+from google.api_core.exceptions import AlreadyExists
+
+__all__ = ["FakePubsubBroker"]
+
+
+class _Message(NamedTuple):
+    data: bytes
+
+
+class _ReceivedMessage(NamedTuple):
+    ack_id: str
+    message: _Message
+
+
+class _PullResponse(NamedTuple):
+    received_messages: list[_ReceivedMessage]
+
+
+class _PublishFuture:
+    def __init__(self, message_id: str) -> None:
+        self._message_id = message_id
+
+    def result(self, timeout: float | None = None) -> str:
+        return self._message_id
+
+
+@dataclass(slots=True)
+class _Subscription:
+    topic_path: str
+    pending: deque[bytes] = field(default_factory=deque)
+    in_flight: dict[str, bytes] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class _FakePublisherClient:
+    _broker: FakePubsubBroker
+
+    def topic_path(self, project: str, topic: str) -> str:
+        return f"projects/{project}/topics/{topic}"
+
+    def create_topic(self, *, name: str) -> None:
+        if name in self._broker._topics:
+            raise AlreadyExists(f"Topic already exists: {name}")  # type: ignore[no-untyped-call]
+        self._broker._topics.add(name)
+
+    def delete_topic(self, *, topic: str) -> None:
+        self._broker._topics.discard(topic)
+
+    def publish(self, topic_path: str, data: bytes) -> _PublishFuture:
+        for sub in self._broker._subscriptions.values():
+            if sub.topic_path == topic_path:
+                sub.pending.append(data)
+        return _PublishFuture(str(uuid.uuid4()))
+
+
+@dataclass(slots=True)
+class _FakeSubscriberClient:
+    _broker: FakePubsubBroker
+
+    def subscription_path(self, project: str, subscription: str) -> str:
+        return f"projects/{project}/subscriptions/{subscription}"
+
+    def create_subscription(self, *, name: str, topic: str) -> None:
+        if name in self._broker._subscriptions:
+            raise AlreadyExists(  # type: ignore[no-untyped-call]
+                f"Subscription already exists: {name}"
+            )
+        self._broker._subscriptions[name] = _Subscription(topic_path=topic)
+
+    def delete_subscription(self, *, subscription: str) -> None:
+        self._broker._subscriptions.pop(subscription, None)
+
+    def pull(
+        self, *, subscription: str, max_messages: int = 1, timeout: float | None = None
+    ) -> _PullResponse:
+        sub = self._broker._subscriptions.setdefault(
+            subscription, _Subscription(topic_path=subscription)
+        )
+        received = []
+        for _ in range(min(max_messages, len(sub.pending))):
+            data = sub.pending.popleft()
+            ack_id = str(uuid.uuid4())
+            sub.in_flight[ack_id] = data
+            received.append(_ReceivedMessage(ack_id=ack_id, message=_Message(data=data)))
+        return _PullResponse(received_messages=received)
+
+    def acknowledge(self, *, subscription: str, ack_ids: list[str]) -> None:
+        sub = self._broker._subscriptions.get(subscription)
+        if sub is None:
+            return
+        for ack_id in ack_ids:
+            sub.in_flight.pop(ack_id, None)
+
+    def modify_ack_deadline(
+        self, *, subscription: str, ack_ids: list[str], ack_deadline_seconds: int
+    ) -> None:
+        sub = self._broker._subscriptions.get(subscription)
+        if sub is None:
+            return
+        for ack_id in ack_ids:
+            data = sub.in_flight.pop(ack_id, None)
+            if data is not None and ack_deadline_seconds == 0:
+                sub.pending.appendleft(data)
+
+
+@dataclass(slots=True)
+class FakePubsubBroker:
+    """An isolated in-memory Pub/Sub double. Pass `broker.publisher` and
+    `broker.subscriber` as the `publisher_factory=`/`subscriber_factory=`
+    arguments to PubsubTaskQueue in place of the real SDK client classes."""
+
+    _topics: set[str] = field(default_factory=set, init=False)
+    _subscriptions: dict[str, _Subscription] = field(default_factory=dict, init=False)
+
+    def publisher(self) -> _FakePublisherClient:
+        return _FakePublisherClient(_broker=self)
+
+    def subscriber(self) -> _FakeSubscriberClient:
+        return _FakeSubscriberClient(_broker=self)

taskqueue_toolkit/testing/rabbitmq.py

@@ -0,0 +1,135 @@
+"""An in-memory double of the slice of aio_pika that RabbitMqTaskQueue
+calls, for testing code that uses this package without a real broker.
+
+Usage:
+    broker = FakeRabbitMqBroker()
+    queue = RabbitMqTaskQueue(dsn=dsn, encode=encode, decode=decode, connect=broker.connect)
+
+Each FakeRabbitMqBroker instance owns its own isolated state — create a new
+one per test (or per broker you want to simulate) rather than sharing one,
+and there is nothing to reset between tests.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections import deque
+from dataclasses import dataclass, field
+
+__all__ = ["FakeRabbitMqBroker"]
+
+
+@dataclass(slots=True)
+class _Queue:
+    """One named queue's backlog plus messages currently delivered but not
+    yet ack()'d/nack()'d — mirrors a real broker's per-queue state."""
+
+    pending: deque[bytes] = field(default_factory=deque)
+    unacked: dict[int, bytes] = field(default_factory=dict)
+    _next_id: int = 0
+
+    def push(self, body: bytes) -> None:
+        self.pending.append(body)
+
+    def requeue(self, delivery_id: int) -> None:
+        body = self.unacked.pop(delivery_id, None)
+        if body is not None:
+            self.pending.appendleft(body)
+
+    def drop(self, delivery_id: int) -> None:
+        self.unacked.pop(delivery_id, None)
+
+    def next_delivery_id(self) -> int:
+        self._next_id += 1
+        return self._next_id
+
+
+@dataclass(slots=True)
+class _FakeIncomingMessage:
+    body: bytes
+    _delivery_id: int
+    _queue: _Queue
+
+    async def ack(self) -> None:
+        self._queue.drop(self._delivery_id)
+
+    async def nack(self, *, requeue: bool = True) -> None:
+        if requeue:
+            self._queue.requeue(self._delivery_id)
+        else:
+            self._queue.drop(self._delivery_id)
+
+
+@dataclass(slots=True)
+class _FakeAioPikaQueue:
+    name: str
+    _queue: _Queue
+
+    def iterator(self) -> _FakeAioPikaQueue:
+        return self
+
+    def __aiter__(self) -> _FakeAioPikaQueue:
+        return self
+
+    async def __anext__(self) -> _FakeIncomingMessage:
+        while not self._queue.pending:
+            await asyncio.sleep(0)
+        body = self._queue.pending.popleft()
+        delivery_id = self._queue.next_delivery_id()
+        self._queue.unacked[delivery_id] = body
+        return _FakeIncomingMessage(body=body, _delivery_id=delivery_id, _queue=self._queue)
+
+
+@dataclass(slots=True)
+class _FakeExchange:
+    _queue: _Queue
+
+    async def publish(self, message: object, *, routing_key: str) -> None:
+        body = getattr(message, "body", b"")
+        self._queue.push(body)
+
+
+@dataclass(slots=True)
+class _FakeChannel:
+    _broker: FakeRabbitMqBroker
+    # Bound by declare_queue() — this fake routes directly to a named queue
+    # rather than modeling real exchange/routing-key bindings, so there's
+    # nothing meaningful to set until then.
+    default_exchange: _FakeExchange | None = field(default=None, init=False)
+
+    async def set_qos(self, *, prefetch_count: int) -> None:
+        return None
+
+    async def declare_queue(self, name: str, *, durable: bool = True) -> _FakeAioPikaQueue:
+        queue = self._broker._queue_for(name)
+        self.default_exchange = _FakeExchange(_queue=queue)
+        return _FakeAioPikaQueue(name=name, _queue=queue)
+
+    async def queue_delete(self, name: str) -> None:
+        self._broker._queues.pop(name, None)
+
+
+@dataclass(slots=True)
+class _FakeConnection:
+    _broker: FakeRabbitMqBroker
+    closed: bool = False
+
+    async def channel(self) -> _FakeChannel:
+        return _FakeChannel(_broker=self._broker)
+
+    async def close(self) -> None:
+        self.closed = True
+
+
+@dataclass(slots=True)
+class FakeRabbitMqBroker:
+    """An isolated in-memory RabbitMQ double. Pass `broker.connect` as the
+    `connect=` argument to RabbitMqTaskQueue in place of aio_pika.connect_robust."""
+
+    _queues: dict[str, _Queue] = field(default_factory=dict, init=False)
+
+    def _queue_for(self, name: str) -> _Queue:
+        return self._queues.setdefault(name, _Queue())
+
+    async def connect(self, url: str) -> _FakeConnection:
+        return _FakeConnection(_broker=self)

taskqueue_toolkit/testing/redis_streams.py

@@ -0,0 +1,141 @@
+"""An in-memory double of the slice of redis.asyncio that
+RedisStreamsTaskQueue calls, for testing code that uses this package
+without a real Redis — with real consumer-group semantics (a pending
+entries list per group, "0" re-reads a consumer's own unacked entries
+before ">" reads new ones), since that ordering is what nack(requeue=True)
+relies on.
+
+Usage:
+    broker = FakeRedisStreamsBroker()
+    queue = RedisStreamsTaskQueue(
+        dsn=dsn, encode=encode, decode=decode, client_factory=broker.client
+    )
+
+Each FakeRedisStreamsBroker instance owns its own isolated state — create a
+new one per test rather than sharing one, and there is nothing to reset
+between tests.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+
+from redis.exceptions import ResponseError
+
+__all__ = ["FakeRedisStreamsBroker"]
+
+
+@dataclass(slots=True)
+class _Group:
+    # Entries delivered to a consumer but not yet XACKed, in delivery order
+    # (a real broker's Pending Entries List) — nack(requeue=True) leaves an
+    # entry here; xreadgroup's "0" branch redelivers from here first.
+    pending_entries: list[tuple[bytes, dict[bytes, bytes]]] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class _Stream:
+    entries: list[tuple[bytes, dict[bytes, bytes]]] = field(default_factory=list)
+    next_id: int = 1
+    groups: dict[bytes, _Group] = field(default_factory=dict)
+    # Position in `entries` each group has already delivered up to, for the
+    # ">" (new entries) branch of xreadgroup.
+    cursor: dict[bytes, int] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class _FakeRedisClient:
+    _broker: FakeRedisStreamsBroker
+
+    async def ping(self) -> bool:
+        return True
+
+    async def xgroup_create(
+        self, name: str, group: str, *, id: str = "0", mkstream: bool = False
+    ) -> None:
+        stream = self._broker._stream_for(name.encode())
+        group_key = group.encode()
+        if group_key in stream.groups:
+            raise ResponseError("BUSYGROUP Consumer Group name already exists")
+        stream.groups[group_key] = _Group()
+        stream.cursor[group_key] = 0
+
+    async def xadd(self, name: str, fields: dict[str, bytes]) -> bytes:
+        stream = self._broker._stream_for(name.encode())
+        entry_id = f"{stream.next_id}-0".encode()
+        stream.next_id += 1
+        encoded_fields = {key.encode(): value for key, value in fields.items()}
+        stream.entries.append((entry_id, encoded_fields))
+        return entry_id
+
+    async def xreadgroup(
+        self,
+        group: str,
+        consumer: str,
+        streams: dict[str, str],
+        *,
+        count: int | None = None,
+        block: int | None = None,
+    ) -> list[tuple[bytes, list[tuple[bytes, dict[bytes, bytes]]]]]:
+        ((name, read_id),) = streams.items()
+        stream = self._broker._stream_for(name.encode())
+        group_key = group.encode()
+        grp = stream.groups[group_key]
+
+        if read_id == "0":
+            # Re-deliver this consumer's own still-pending entries — this
+            # fake doesn't track per-consumer PELs separately, only
+            # per-group, matching this package's single-consumer-per-group
+            # usage pattern.
+            delivered = grp.pending_entries[: count or len(grp.pending_entries)]
+            return [(name.encode(), delivered)]
+
+        # ">" branch: deliver new entries the group hasn't seen yet.
+        cursor = stream.cursor[group_key]
+        new_entries = stream.entries[cursor : cursor + (count or 1)]
+        if new_entries:
+            stream.cursor[group_key] = cursor + len(new_entries)
+            grp.pending_entries.extend(new_entries)
+            return [(name.encode(), new_entries)]
+
+        # Nothing new — a real broker blocks up to `block` ms; the fake
+        # yields control once so callers polling in a loop don't spin the
+        # event loop hot, then returns empty like a timed-out BLOCK would.
+        await asyncio.sleep(0)
+        return [(name.encode(), [])]
+
+    async def xack(self, name: str, group: str, *entry_ids: bytes) -> int:
+        stream = self._broker._stream_for(name.encode())
+        grp = stream.groups.get(group.encode())
+        if grp is None:
+            return 0
+        ids = set(entry_ids)
+        before = len(grp.pending_entries)
+        grp.pending_entries = [e for e in grp.pending_entries if e[0] not in ids]
+        return before - len(grp.pending_entries)
+
+    async def delete(self, *names: str) -> int:
+        count = 0
+        for name in names:
+            if self._broker._streams.pop(name.encode(), None) is not None:
+                count += 1
+        return count
+
+    async def aclose(self) -> None:
+        return None
+
+
+@dataclass(slots=True)
+class FakeRedisStreamsBroker:
+    """An isolated in-memory Redis Streams double. Pass `broker.client` as
+    the `client_factory=` argument to RedisStreamsTaskQueue in place of the
+    default redis.Redis.from_url-based factory."""
+
+    _streams: dict[bytes, _Stream] = field(default_factory=dict, init=False)
+
+    def _stream_for(self, name: bytes) -> _Stream:
+        return self._streams.setdefault(name, _Stream())
+
+    def client(self, dsn: object) -> _FakeRedisClient:
+        return _FakeRedisClient(_broker=self)

taskqueue_toolkit/testing/sns.py

@@ -0,0 +1,155 @@
+"""An in-memory double of the slice of aioboto3's SNS+SQS clients that
+SnsTaskQueue calls, for testing code that uses this package without a real
+topic/queue.
+
+Usage:
+    broker = FakeSnsBroker()
+    queue = SnsTaskQueue(dsn=dsn, encode=encode, decode=decode, client_factory=broker.client)
+
+publish() fans out directly into whichever SQS queues are subscribed to the
+topic, wrapping the body in the same {"Type": ..., "Message": ...} envelope
+real SNS-to-SQS delivery uses, since SnsTaskQueue.consume() unwraps that
+envelope.
+
+Each FakeSnsBroker instance owns its own isolated state — create a new one
+per test rather than sharing one, and there is nothing to reset between
+tests.
+"""
+
+from __future__ import annotations
+
+import json
+import uuid
+from collections import deque
+from contextlib import AbstractAsyncContextManager
+from dataclasses import dataclass, field
+
+__all__ = ["FakeSnsBroker"]
+
+
+class QueueDoesNotExist(Exception):
+    """Raised by the fake SQS client the same way the real SDK's
+    client.exceptions.QueueDoesNotExist would be."""
+
+
+@dataclass(slots=True)
+class _Exceptions:
+    QueueDoesNotExist: type[Exception] = QueueDoesNotExist
+
+
+@dataclass(slots=True)
+class _Queue:
+    pending: deque[dict[str, str]] = field(default_factory=deque)
+    in_flight: dict[str, dict[str, str]] = field(default_factory=dict)
+
+
+def _topic_arn(name: str) -> str:
+    return f"arn:aws:sns:fake:000000000000:{name}"
+
+
+@dataclass(slots=True)
+class _FakeSnsClient:
+    _broker: FakeSnsBroker
+
+    async def create_topic(self, *, Name: str) -> dict[str, str]:
+        arn = _topic_arn(Name)
+        self._broker._topics.setdefault(arn, set())
+        return {"TopicArn": arn}
+
+    async def delete_topic(self, *, TopicArn: str) -> None:
+        self._broker._topics.pop(TopicArn, None)
+
+    async def subscribe(self, *, TopicArn: str, Protocol: str, Endpoint: str) -> dict[str, str]:
+        self._broker._topics.setdefault(TopicArn, set()).add(Endpoint)
+        return {"SubscriptionArn": f"{TopicArn}:{uuid.uuid4()}"}
+
+    async def publish(self, *, TopicArn: str, Message: str) -> dict[str, str]:
+        envelope = json.dumps(
+            {
+                "Type": "Notification",
+                "MessageId": str(uuid.uuid4()),
+                "TopicArn": TopicArn,
+                "Message": Message,
+            }
+        )
+        for queue_url in self._broker._topics.get(TopicArn, set()):
+            queue = self._broker._queues.setdefault(queue_url, _Queue())
+            queue.pending.append({"Body": envelope})
+        return {"MessageId": str(uuid.uuid4())}
+
+
+@dataclass(slots=True)
+class _FakeSqsClient:
+    _broker: FakeSnsBroker
+    exceptions: _Exceptions = field(default_factory=_Exceptions)
+
+    async def get_queue_url(self, *, QueueName: str) -> dict[str, str]:
+        if QueueName not in self._broker._queues:
+            raise self.exceptions.QueueDoesNotExist(QueueName)
+        return {"QueueUrl": QueueName}
+
+    async def create_queue(self, *, QueueName: str) -> dict[str, str]:
+        self._broker._queues.setdefault(QueueName, _Queue())
+        return {"QueueUrl": QueueName}
+
+    async def get_queue_attributes(
+        self, *, QueueUrl: str, AttributeNames: list[str]
+    ) -> dict[str, dict[str, str]]:
+        # This fake uses the queue URL as its own ARN too — good enough
+        # since nothing here parses ARN structure, only threads the value
+        # through to subscribe()'s Endpoint, which this fake also keys by
+        # queue URL.
+        return {"Attributes": {"QueueArn": QueueUrl}}
+
+    async def set_queue_attributes(self, *, QueueUrl: str, Attributes: dict[str, str]) -> None:
+        return None
+
+    async def receive_message(
+        self, *, QueueUrl: str, MaxNumberOfMessages: int = 1, WaitTimeSeconds: int = 0
+    ) -> dict[str, list[dict[str, str]]]:
+        queue = self._broker._queues.setdefault(QueueUrl, _Queue())
+        messages = []
+        for _ in range(min(MaxNumberOfMessages, len(queue.pending))):
+            body = queue.pending.popleft()
+            receipt_handle = str(uuid.uuid4())
+            queue.in_flight[receipt_handle] = body
+            messages.append({"Body": body["Body"], "ReceiptHandle": receipt_handle})
+        return {"Messages": messages}
+
+    async def delete_message(self, *, QueueUrl: str, ReceiptHandle: str) -> None:
+        queue = self._broker._queues.setdefault(QueueUrl, _Queue())
+        queue.in_flight.pop(ReceiptHandle, None)
+
+    async def change_message_visibility(
+        self, *, QueueUrl: str, ReceiptHandle: str, VisibilityTimeout: int
+    ) -> None:
+        queue = self._broker._queues.setdefault(QueueUrl, _Queue())
+        body = queue.in_flight.pop(ReceiptHandle, None)
+        if body is not None and VisibilityTimeout == 0:
+            queue.pending.appendleft(body)
+
+
+class _FakeSnsContext(AbstractAsyncContextManager[tuple["_FakeSnsClient", "_FakeSqsClient"]]):
+    def __init__(self, broker: FakeSnsBroker) -> None:
+        self._broker = broker
+
+    async def __aenter__(self) -> tuple[_FakeSnsClient, _FakeSqsClient]:
+        return _FakeSnsClient(_broker=self._broker), _FakeSqsClient(_broker=self._broker)
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        return None
+
+
+@dataclass(slots=True)
+class FakeSnsBroker:
+    """An isolated in-memory SNS+SQS double. Pass `broker.client` as the
+    `client_factory=` argument to SnsTaskQueue in place of the default
+    aioboto3-session-based factory."""
+
+    _topics: dict[str, set[str]] = field(default_factory=dict, init=False)
+    _queues: dict[str, _Queue] = field(default_factory=dict, init=False)
+
+    def client(
+        self, dsn: object
+    ) -> AbstractAsyncContextManager[tuple[_FakeSnsClient, _FakeSqsClient]]:
+        return _FakeSnsContext(self)

taskqueue_toolkit/testing/sqs.py

@@ -0,0 +1,109 @@
+"""An in-memory double of the slice of aioboto3's SQS client that
+SqsTaskQueue calls, for testing code that uses this package without a real
+queue.
+
+Usage:
+    broker = FakeSqsBroker()
+    queue = SqsTaskQueue(dsn=dsn, encode=encode, decode=decode, client_factory=broker.client)
+
+Each FakeSqsBroker instance owns its own isolated state — create a new one
+per test rather than sharing one, and there is nothing to reset between
+tests.
+"""
+
+from __future__ import annotations
+
+import uuid
+from collections import deque
+from contextlib import AbstractAsyncContextManager
+from dataclasses import dataclass, field
+
+__all__ = ["FakeSqsBroker"]
+
+
+class QueueDoesNotExist(Exception):
+    """Raised by the fake client the same way the real SDK's
+    client.exceptions.QueueDoesNotExist would be — SqsTaskQueue catches
+    this via `except client.exceptions.QueueDoesNotExist`, which this fake
+    client exposes as an instance attribute for exactly that reason."""
+
+
+@dataclass(slots=True)
+class _Exceptions:
+    QueueDoesNotExist: type[Exception] = QueueDoesNotExist
+
+
+@dataclass(slots=True)
+class _Queue:
+    pending: deque[dict[str, str]] = field(default_factory=deque)
+    in_flight: dict[str, dict[str, str]] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class _FakeSqsClient:
+    _broker: FakeSqsBroker
+    exceptions: _Exceptions = field(default_factory=_Exceptions)
+
+    async def get_queue_url(self, *, QueueName: str) -> dict[str, str]:
+        if QueueName not in self._broker._queues:
+            raise self.exceptions.QueueDoesNotExist(QueueName)
+        return {"QueueUrl": QueueName}
+
+    async def create_queue(self, *, QueueName: str) -> dict[str, str]:
+        self._broker._queues.setdefault(QueueName, _Queue())
+        return {"QueueUrl": QueueName}
+
+    async def delete_queue(self, *, QueueUrl: str) -> None:
+        self._broker._queues.pop(QueueUrl, None)
+
+    async def send_message(self, *, QueueUrl: str, MessageBody: str) -> dict[str, str]:
+        queue = self._broker._queues.setdefault(QueueUrl, _Queue())
+        queue.pending.append({"Body": MessageBody})
+        return {"MessageId": str(uuid.uuid4())}
+
+    async def receive_message(
+        self, *, QueueUrl: str, MaxNumberOfMessages: int = 1, WaitTimeSeconds: int = 0
+    ) -> dict[str, list[dict[str, str]]]:
+        queue = self._broker._queues.setdefault(QueueUrl, _Queue())
+        messages = []
+        for _ in range(min(MaxNumberOfMessages, len(queue.pending))):
+            body = queue.pending.popleft()
+            receipt_handle = str(uuid.uuid4())
+            queue.in_flight[receipt_handle] = body
+            messages.append({"Body": body["Body"], "ReceiptHandle": receipt_handle})
+        return {"Messages": messages}
+
+    async def delete_message(self, *, QueueUrl: str, ReceiptHandle: str) -> None:
+        queue = self._broker._queues.setdefault(QueueUrl, _Queue())
+        queue.in_flight.pop(ReceiptHandle, None)
+
+    async def change_message_visibility(
+        self, *, QueueUrl: str, ReceiptHandle: str, VisibilityTimeout: int
+    ) -> None:
+        queue = self._broker._queues.setdefault(QueueUrl, _Queue())
+        body = queue.in_flight.pop(ReceiptHandle, None)
+        if body is not None and VisibilityTimeout == 0:
+            queue.pending.appendleft(body)
+
+
+class _FakeClientContext(AbstractAsyncContextManager["_FakeSqsClient"]):
+    def __init__(self, broker: FakeSqsBroker) -> None:
+        self._broker = broker
+
+    async def __aenter__(self) -> _FakeSqsClient:
+        return _FakeSqsClient(_broker=self._broker)
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        return None
+
+
+@dataclass(slots=True)
+class FakeSqsBroker:
+    """An isolated in-memory SQS double. Pass `broker.client` as the
+    `client_factory=` argument to SqsTaskQueue in place of the default
+    aioboto3-session-based factory."""
+
+    _queues: dict[str, _Queue] = field(default_factory=dict, init=False)
+
+    def client(self, dsn: object) -> AbstractAsyncContextManager[_FakeSqsClient]:
+        return _FakeClientContext(self)