Files
mtusi2026lab2/student-tests/fakes.py
T

114 lines
3.9 KiB
Python

import asyncio
from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
from datetime import UTC, datetime, timedelta
from typing import Any
from dishka import Provider, Scope, provide
from messenger.attachments.application.errors import ObjectMissingError
from messenger.attachments.application.ports import ObjectContent, ObjectStorage, StoredObject
from messenger.shared.application.errors import Unavailable
class NullLogger:
__slots__ = ()
def info(self, event: str, /, **fields: Any) -> None: ...
def warning(self, event: str, /, **fields: Any) -> None: ...
def error(self, event: str, /, **fields: Any) -> None: ...
class FrozenClock:
__slots__ = ("_current",)
def __init__(self, start: datetime) -> None:
self._current = start
def now(self) -> datetime:
self._current += timedelta(microseconds=1)
return self._current
async def pieces(data: bytes, size: int = 65_536, delay: float = 0.0) -> AsyncIterator[bytes]:
for start in range(0, len(data), size):
await asyncio.sleep(delay)
yield data[start : start + size]
class MemoryObjectStorage:
__slots__ = ("after_page", "after_put", "delay", "failing", "modified", "objects")
def __init__(self) -> None:
self.objects: dict[str, tuple[bytes, str]] = {}
self.modified: dict[str, datetime] = {}
self.failing = False
self.delay = 0.0
self.after_put: Callable[[str], Awaitable[None]] | None = None
self.after_page: Callable[[], Awaitable[None]] | None = None
async def put(self, key: str, data: bytes, content_type: str) -> None:
if self.failing:
raise Unavailable("S3 недоступно")
self.objects[key] = (bytes(data), content_type)
self.modified[key] = datetime.now(UTC)
if self.after_put is not None:
await self.after_put(key)
async def listing(self, prefix: str, page_size: int) -> AsyncIterator[Sequence[StoredObject]]:
if self.failing:
raise Unavailable("S3 недоступно")
keys = sorted(key for key in self.objects if key.startswith(prefix))
for start in range(0, len(keys), page_size):
yield [self._stored(key) for key in keys[start : start + page_size]]
if self.after_page is not None:
await self.after_page()
async def stat(self, key: str) -> StoredObject | None:
return self._stored(key) if key in self.objects else None
def _stored(self, key: str) -> StoredObject:
return StoredObject(key, len(self.objects[key][0]), self.modified[key])
async def open(self, key: str) -> ObjectContent:
if self.failing:
raise Unavailable("S3 недоступно")
if key not in self.objects:
raise ObjectMissingError(key)
data = self.objects[key][0]
return ObjectContent(size=len(data), chunks=pieces(data, delay=self.delay))
async def read(self, key: str) -> bytes:
content = await self.open(key)
return b"".join([chunk async for chunk in content.chunks])
async def copy(self, source: str, target: str) -> None:
if self.failing:
raise Unavailable("S3 недоступно")
if source not in self.objects:
raise ObjectMissingError(source)
self.objects[target] = self.objects[source]
async def delete(self, key: str) -> None:
if self.failing:
raise Unavailable("S3 недоступно")
self.objects.pop(key, None)
self.modified.pop(key, None)
class MemoryStorageProvider(Provider):
@provide(scope=Scope.APP)
def storage(self) -> ObjectStorage:
return MemoryObjectStorage()
class RecordingPublisher:
__slots__ = ("events",)
def __init__(self) -> None:
self.events: list[Any] = []
async def publish(self, events: Sequence[Any]) -> None:
self.events.extend(events)