Files
mtusi2026lab6/service-tests/fakes/clients.py
T

252 lines
7.6 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Фейки клиентов: настоящие `chat_cache` и `attachment_object` работают поверх
них, ключи и формат значения не дублируются (design change `unit-of-work`,
решение 8). Журнал и заданные отказы — общие с `FakeDatabase`: порядок вызовов S3
и издателя виден рядом с блоками.
"""
from collections import Counter
from collections.abc import AsyncIterator, Sequence
from contextlib import asynccontextmanager
from datetime import UTC, datetime
from types import MappingProxyType
from typing import BinaryIO
from uuid import UUID
from src.core import exceptions
from src.infra.s3 import (
StorageStats,
StoredObjectInfo,
StoredObjectPage,
)
from src.schemas.dataclasses import JobPublicationDTO, RenderedVariantsDTO
from .database import FakeDatabase
_FAR_PAST = datetime(2000, 1, 1, tzinfo=UTC)
_CHUNK_BYTES = 1024
_CALL_NAMES = ("list", "head", "get", "delete", "put")
class FakeCache:
"""`failing` — Valkey недоступен: промах и пропуск, как у `Cache`."""
def __init__(
self,
database: FakeDatabase,
*,
namespace: str = "testdb",
) -> None:
self.namespace = namespace
self._db = database
self.values: dict[str, str] = {}
self.failing = False
async def get(self, key: str) -> str | None:
self._db.events.append("cache.get")
return None if self.failing else self.values.get(key)
async def set(self, key: str, value: str, *, ttl_seconds: int) -> bool:
self._db.events.append("cache.set")
if self.failing:
return False
self.values[key] = value
return True
async def aclose(self) -> None:
return None
class FakeStoredObject:
def __init__(self, info: StoredObjectInfo, data: bytes, storage) -> None:
self.info = info
self._data = data
self._storage = storage
@property
def size(self) -> int:
return self.info.size
@property
def content_type(self) -> str | None:
return self.info.content_type
async def iter_chunks(
self,
chunk_bytes: int = _CHUNK_BYTES,
) -> AsyncIterator[bytes]:
for start in range(0, len(self._data), chunk_bytes):
chunk = self._data[start : start + chunk_bytes]
self._storage.read_bytes += len(chunk)
yield chunk
async def read(self) -> bytes:
self._storage.read_bytes += len(self._data)
return self._data
class FakeObjectStorage:
"""Объекты в памяти. Событие — `storage.<операция>`, отказ — `fail_on` базы
(`storage.put`, `storage.list`, …): счётчик растёт до вызова, как у клиента.
`seed` кладёт объект мимо счётчиков и журнала."""
def __init__(
self,
database: FakeDatabase,
*,
namespace: str = "testdb",
) -> None:
self.namespace = namespace
self._db = database
self.objects: dict[str, tuple[bytes, str | None, datetime]] = {}
self.calls: Counter[str] = Counter()
self.listed_keys = 0
self.read_bytes = 0
def seed(
self,
key: str,
data: bytes = b"x",
*,
content_type: str | None = "image/png",
last_modified: datetime = _FAR_PAST,
) -> None:
self.objects[key] = (data, content_type, last_modified)
def _call(self, name: str) -> None:
self.calls[name] += 1
self._db.record(f"storage.{name}")
def _info(self, key: str) -> StoredObjectInfo:
data, content_type, last_modified = self.objects[key]
return StoredObjectInfo(
key=key,
size=len(data),
content_type=content_type,
last_modified=last_modified,
)
def stats(self) -> StorageStats:
return StorageStats(
calls=MappingProxyType(
{name: self.calls[name] for name in _CALL_NAMES},
),
listed_keys=self.listed_keys,
read_bytes=self.read_bytes,
)
async def start(self) -> None:
return None
async def aclose(self) -> None:
return None
async def put(
self,
key: str,
body: BinaryIO,
*,
size: int,
content_type: str,
) -> None:
self._call("put")
self.objects[key] = (
body.read(),
content_type,
datetime.now(tz=UTC),
)
async def head(self, key: str) -> StoredObjectInfo | None:
self._call("head")
return self._info(key) if key in self.objects else None
async def list_page(
self,
prefix: str,
*,
token: str | None,
max_keys: int,
) -> StoredObjectPage:
self._call("list")
keys = sorted(
key
for key in self.objects
if key.startswith(prefix) and (token is None or key > token)
)
page = keys[:max_keys]
self.listed_keys += len(page)
return StoredObjectPage(
objects=tuple(self._info(key) for key in page),
next_token=page[-1] if len(keys) > max_keys else None,
)
@asynccontextmanager
async def open(self, key: str) -> AsyncIterator[FakeStoredObject]:
self._call("get")
if key not in self.objects:
raise exceptions.StoredObjectMissing
yield FakeStoredObject(self._info(key), self.objects[key][0], self)
async def delete(self, key: str) -> None:
self._call("delete")
self.objects.pop(key, None)
class FakeJobPublisher:
"""Подтверждает всё или заданное подмножество (`unconfirmed`); журнал —
`publisher.publish_many`, `publisher.ready_messages`."""
def __init__(
self,
database: FakeDatabase,
*,
namespace: str = "testdb",
) -> None:
self.namespace = namespace
self.queue = f"{namespace}.attachment.process.v1"
self._db = database
self.unconfirmed: set[UUID] = set()
self.ready = 0
self.published: list[UUID] = []
# элементы публикаций с контекстом и номером попытки (design change
# job-trace-propagation, решение 3)
self.items: list[JobPublicationDTO] = []
async def publish_many(
self,
items: Sequence[JobPublicationDTO],
) -> set[UUID]:
self._db.record("publisher.publish_many")
confirmed = {
item.job_id
for item in items
if item.job_id not in self.unconfirmed
}
self.published.extend(item.job_id for item in items)
self.items.extend(items)
return confirmed
async def ready_messages(self) -> int:
self._db.record("publisher.ready_messages")
return self.ready
async def aclose(self) -> None:
return None
class FakeImageRenderer:
"""`result` — итог, `fail_on["renderer.render"]` — отказ процесса обработки."""
def __init__(
self,
database: FakeDatabase,
result: RenderedVariantsDTO | None = None,
) -> None:
self._db = database
self.result = result
async def render(self, data: bytes) -> RenderedVariantsDTO:
self._db.record("renderer.render")
if self.result is None:
raise AssertionError("FakeImageRenderer has no result")
return self.result