252 lines
7.6 KiB
Python
252 lines
7.6 KiB
Python
"""Фейки клиентов: настоящие `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
|