Files
mtusi2026lab2/student-tests/fakes.py
T
Artyom 12db77133f Forward the lab 5 foundation while preserving lab 6 telemetry
Source: immutable lab5 snapshot f88e9ba43cdfd7eb6a5a7ae5feb4247b4e820071; forward the allowed diff from 64d5c67. Carry SQLAlchemy, Alembic, reliability fixes, versioned jobs, infrastructure and student tests without changing protected coursework files.

Validation: make check, validate, lint; 515 student tests passed with one Linux-only skip; public smoke with telemetry enabled and repeat migration passed. Stop the owned stack and retain volumes. Preserve the existing OTel work in progress; grade implementation remains a separate phase.
2026-11-06 12:29:35 +03:00

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)