Files
mtusi2026lab5/student-tests/adapters/test_rabbitmq.py
T

260 lines
8.1 KiB
Python

import asyncio
import base64
import hashlib
import json
import os
import re
import subprocess
import time
from collections.abc import AsyncIterator, Iterator
from contextlib import asynccontextmanager
from datetime import UTC, datetime
from typing import Any
from uuid import uuid4
import pytest
from dishka import Provider, Scope, make_async_container, provide
from dishka_faststream import setup_dishka
from faststream.rabbit import Channel, RabbitBroker
from conftest import ROOT, STARTUP_SECONDS, container, free_port, image, published
from fakes import NullLogger
from messenger.attachments.application.bus import AttachmentsCommandBus
from messenger.attachments.application.commands import ProcessJob
from messenger.attachments.domain.jobs import Job, Outcome
from messenger.attachments.entrypoints.worker import subscribe
from messenger.attachments.infrastructure.rabbitmq import RabbitJobPublisher
from messenger.shared.application.errors import Unavailable
from messenger.shared.application.ports import Logger
RABBITMQ_IMAGE = re.compile(r"image: (rabbitmq:\S+)")
PASSWORDS = {role: os.urandom(12).hex() for role in ("api", "worker", "ops")}
GRANTS = {
"api": ("^$", "^attachments$", "^$"),
"worker": ("^$", "^$", "^attachments\\.process$"),
"ops": (".*", ".*", ".*"),
}
def user(role: str) -> dict[str, Any]:
salt = os.urandom(4)
digest = hashlib.sha256(salt + PASSWORDS[role].encode()).digest()
return {
"name": f"messenger-{role}",
"password_hash": base64.b64encode(salt + digest).decode(),
"hashing_algorithm": "rabbit_password_hashing_sha256",
"tags": ["administrator"] if role == "ops" else [],
}
def definitions() -> dict[str, Any]:
return {
"users": [user(role) for role in PASSWORDS],
"permissions": [
{
"user": f"messenger-{role}",
"vhost": "messenger",
**dict(zip(("configure", "write", "read"), grant, strict=True)),
}
for role, grant in GRANTS.items()
],
}
def ready(name: str) -> bool:
probe = ["docker", "exec", name, "rabbitmq-diagnostics", "-q", "check_port_connectivity"]
return subprocess.run(probe, capture_output=True, check=False).returncode == 0
@pytest.fixture(scope="session")
def rabbitmq() -> Iterator[dict[str, Any]]:
name = f"mtusi-lab5-test-rabbitmq-{uuid4().hex[:8]}"
folder = ROOT / "build" / name
folder.mkdir(parents=True)
users = folder / "20-users.json"
users.write_text(json.dumps(definitions()))
users.chmod(0o644)
infra = ROOT / "infra" / "rabbitmq"
mounts = [
f"{infra / 'rabbitmq.conf'}:/etc/rabbitmq/conf.d/20-messenger.conf:ro",
f"{infra / 'enabled_plugins'}:/etc/rabbitmq/enabled_plugins:ro",
f"{infra / 'definitions.json'}:/etc/rabbitmq/definitions.d/10-topology.json:ro",
f"{users}:/etc/rabbitmq/definitions.d/20-users.json:ro",
]
volumes = [part for mount in mounts for part in ("-v", mount)]
container(
name,
"--hostname",
"broker",
"--user",
"100:101",
*volumes,
"-p",
f"127.0.0.1:{free_port()}:5672",
image(RABBITMQ_IMAGE),
)
try:
deadline = time.monotonic() + STARTUP_SECONDS * 2
while not ready(name):
assert time.monotonic() < deadline, "RabbitMQ не стал готов"
time.sleep(1)
port = published(name, 5672)
urls = {
role: f"amqp://messenger-{role}:{secret}@127.0.0.1:{port}/messenger"
for role, secret in PASSWORDS.items()
}
yield {"name": name, "urls": urls}
finally:
subprocess.run(["docker", "rm", "-f", name], capture_output=True, check=False)
users.unlink()
folder.rmdir()
def depth(broker: dict[str, Any], queue: str) -> int:
listing = subprocess.run(
[
"docker",
"exec",
broker["name"],
"rabbitmqctl",
"-q",
"list_queues",
"-p",
"messenger",
"name",
"messages",
"--formatter",
"json",
],
capture_output=True,
check=True,
text=True,
).stdout
return {row["name"]: row["messages"] for row in json.loads(listing)}[queue]
async def wait_for(probe: Any, seconds: float = 20) -> None:
deadline = time.monotonic() + seconds
while not probe():
assert time.monotonic() < deadline
await asyncio.sleep(0.1)
class NoEvents:
@asynccontextmanager
async def transaction(self) -> AsyncIterator[None]:
yield
async def commit(self) -> None: ...
def record(self, event: object) -> None: ...
def collect_new_events(self) -> list[Any]:
return []
class Recorder:
def __init__(self) -> None:
self.jobs: list[Job] = []
self.failures = 0
async def __call__(self, command: ProcessJob) -> Outcome:
if self.failures:
self.failures -= 1
raise Unavailable("PostgreSQL недоступен")
self.jobs.append(command.job)
return Outcome.DONE
class FakeBus(Provider):
def __init__(self, recorder: Recorder) -> None:
super().__init__()
self._recorder = recorder
@provide(scope=Scope.APP)
def logger(self) -> Logger:
return NullLogger()
@provide(scope=Scope.REQUEST)
def bus(self) -> AttachmentsCommandBus:
return AttachmentsCommandBus({ProcessJob: self._recorder}, NoEvents(), NoPublisher())
class NoPublisher:
async def publish(self, events: Any) -> None: ...
@asynccontextmanager
async def worker(rabbitmq: dict[str, Any], recorder: Recorder) -> AsyncIterator[None]:
broker = RabbitBroker(rabbitmq["urls"]["worker"], logger=None, graceful_timeout=2)
subscribe(broker, 2)
setup_dishka(make_async_container(FakeBus(recorder)), broker=broker, auto_inject=True)
await broker.start()
try:
yield
finally:
await broker.stop()
@asynccontextmanager
async def publisher(
rabbitmq: dict[str, Any], role: str = "api"
) -> AsyncIterator[RabbitJobPublisher]:
broker = RabbitBroker(
rabbitmq["urls"][role],
default_channel=Channel(publisher_confirms=True, on_return_raises=True),
logger=None,
)
await broker.connect()
try:
yield RabbitJobPublisher(broker, 5)
finally:
await broker.stop()
def job() -> Job:
return Job(uuid4(), uuid4(), 1, 1, datetime.now(UTC))
def body(payload: dict[str, Any]) -> bytes:
return json.dumps(payload).encode()
async def test_confirmed_job_is_consumed_and_acked(rabbitmq: dict[str, Any]) -> None:
recorder, sent = Recorder(), job()
async with publisher(rabbitmq) as jobs:
await jobs.publish(sent.id, body(sent.payload()))
await wait_for(lambda: depth(rabbitmq, "attachments.process") == 1)
async with worker(rabbitmq, recorder):
await wait_for(lambda: recorder.jobs)
await wait_for(lambda: depth(rabbitmq, "attachments.process") == 0)
assert recorder.jobs == [sent]
async def test_message_off_the_schema_goes_to_the_dead_letter_queue(
rabbitmq: dict[str, Any],
) -> None:
before = depth(rabbitmq, "attachments.process.dlq")
async with publisher(rabbitmq) as jobs:
await jobs.publish(uuid4(), body({"schema_version": 2, "job_id": str(uuid4())}))
async with worker(rabbitmq, Recorder()):
await wait_for(lambda: depth(rabbitmq, "attachments.process.dlq") == before + 1)
assert depth(rabbitmq, "attachments.process") == 0
async def test_failed_processing_is_requeued_and_retried(rabbitmq: dict[str, Any]) -> None:
recorder, sent = Recorder(), job()
recorder.failures = 1
async with publisher(rabbitmq) as jobs:
await jobs.publish(sent.id, body(sent.payload()))
async with worker(rabbitmq, recorder):
await wait_for(lambda: recorder.jobs)
assert recorder.jobs == [sent]
async def test_worker_account_cannot_publish(rabbitmq: dict[str, Any]) -> None:
sent = job()
with pytest.raises(Unavailable):
async with publisher(rabbitmq, "worker") as jobs:
await jobs.publish(sent.id, body(sent.payload()))