"""Исполняется внутри API-контейнера: реальные S3/БД и управляемые отказы.""" import asyncio import base64 from datetime import datetime, timedelta, timezone import json import sys from uuid import UUID from minio.error import S3Error from sqlalchemy import select from sqlalchemy.exc import OperationalError from app.core.config import Settings from app.core.database import create_db_engine, create_session_factory from app.domain import attachments as domain from app.errors.exceptions import unavailable from app.models.attachment import UploadIntent from app.schemas.user import User from app.storage import attachments as repository from app.storage.s3 import create_s3_storage async def object_exists(storage, key): exists = True try: await storage.stat_object(key) except S3Error as error: if error.code not in {'NoSuchKey', 'NoSuchObject'}: raise exists = False return exists async def main(): payload = json.load(sys.stdin) settings = Settings() engine = create_db_engine(settings) factory = create_session_factory(engine) storage = create_s3_storage(settings.s3) user = User.model_validate(payload['user']) chat_id = UUID(payload['chat_id']) original = base64.b64decode(payload['image']) keys = [] create_record = repository.create_attachment put_file, delete_object = storage.put_file, storage.delete_object async def capture_put(key, path, **metadata): keys.append(key) await put_file(key, path, **metadata) async def fail_metadata(*args, **kwargs): raise OperationalError('injected metadata failure after real S3 PUT', {}, None) async def fail_delete(*args): raise unavailable('injected compensation failure') async def chunks(): yield original async def attempt(): raised = False async with factory() as session: try: await domain.upload_attachment(session, storage, user, chat_id, filename='fault.png', content_type='image/png', chunks=chunks()) except OperationalError: raised = True assert raised, 'injected database failure was not raised' storage.put_file = capture_put repository.create_attachment = fail_metadata try: await attempt() assert not await object_exists(storage, keys[-1]), 'compensation left original' async with factory() as session: intent = await session.scalar(select(UploadIntent).where(UploadIntent.object_key == keys[-1])) assert intent is None, 'compensated upload left intent' storage.delete_object = fail_delete await attempt() key = keys[-1] assert await object_exists(storage, key), 'fault did not leave real S3 object' storage.delete_object = delete_object async with factory() as session: result = await domain.reconcile_attachments(session, storage, dry_run=False) assert result.deleted == 0, 'fresh object deleted before grace period' intent = await session.scalar(select(UploadIntent).where(UploadIntent.object_key == key)) assert intent is not None, 'durable intent missing' intent.created_at = datetime.now(timezone.utc) - timedelta(days=2) await session.commit() dry_run = await domain.reconcile_attachments(session, storage) assert dry_run.candidates == 1 and dry_run.deleted == 0 assert await object_exists(storage, key), 'dry-run removed original' applied = await domain.reconcile_attachments(session, storage, dry_run=False) assert applied.deleted == 1 and not await object_exists(storage, key) repeated = await domain.reconcile_attachments(session, storage, dry_run=False) assert repeated.examined == repeated.deleted == 0 print(json.dumps({'compensation': True, 'durable_intent': True, 'grace_period': True, 'dry_run': True, 'cleanup': True, 'idempotent_cleanup': True})) finally: repository.create_attachment = create_record storage.put_file, storage.delete_object = put_file, delete_object await storage.aclose() await engine.dispose() if __name__ == '__main__': asyncio.run(main())