forked from mtusi2026/mtusi2026lab5
121 lines
4.6 KiB
Python
121 lines
4.6 KiB
Python
import os
|
|
import re
|
|
import subprocess
|
|
import time
|
|
from collections.abc import AsyncIterator, Iterator
|
|
from contextlib import asynccontextmanager
|
|
from uuid import uuid4
|
|
|
|
import httpx
|
|
import pytest
|
|
|
|
from conftest import STARTUP_SECONDS, container, free_port, image, published
|
|
from messenger.attachments.application.errors import ObjectMissingError
|
|
from messenger.attachments.infrastructure.s3 import S3ObjectStorage, s3_client
|
|
from messenger.shared.application.errors import Unavailable
|
|
|
|
RUSTFS_IMAGE = re.compile(r"image: (rustfs/rustfs:\S+)")
|
|
ROOT_KEY, ROOT_SECRET = "testroot", "testroot-secret-key"
|
|
BUCKET = "messenger-attachments"
|
|
|
|
|
|
@pytest.fixture(scope="session")
|
|
def rustfs() -> Iterator[str]:
|
|
name = f"mtusi-lab5-test-rustfs-{uuid4().hex[:8]}"
|
|
keys = ["-e", f"RUSTFS_ACCESS_KEY={ROOT_KEY}", "-e", f"RUSTFS_SECRET_KEY={ROOT_SECRET}"]
|
|
container(name, *keys, "-p", f"127.0.0.1:{free_port()}:9000", image(RUSTFS_IMAGE))
|
|
try:
|
|
endpoint = f"http://127.0.0.1:{published(name, 9000)}"
|
|
deadline = time.monotonic() + STARTUP_SECONDS
|
|
while True:
|
|
try:
|
|
if httpx.get(f"{endpoint}/health/ready", timeout=1).status_code == 200:
|
|
break
|
|
except httpx.TransportError:
|
|
pass
|
|
assert time.monotonic() < deadline, "RustFS не стал готов"
|
|
time.sleep(0.3)
|
|
yield endpoint
|
|
finally:
|
|
subprocess.run(["docker", "rm", "-f", name], capture_output=True, check=False)
|
|
|
|
|
|
@asynccontextmanager
|
|
async def storage(endpoint: str) -> AsyncIterator[S3ObjectStorage]:
|
|
async with s3_client(
|
|
endpoint=endpoint,
|
|
region="us-east-1",
|
|
access_key_id=ROOT_KEY,
|
|
secret_access_key=ROOT_SECRET,
|
|
connect_timeout=1,
|
|
read_timeout=2,
|
|
max_attempts=2,
|
|
) as client:
|
|
buckets = await client.list_buckets()
|
|
if BUCKET not in {bucket["Name"] for bucket in buckets.get("Buckets", [])}:
|
|
await client.create_bucket(Bucket=BUCKET)
|
|
yield S3ObjectStorage(client, BUCKET)
|
|
|
|
|
|
async def test_round_trip_of_the_largest_object(rustfs: str) -> None:
|
|
data = os.urandom(10_485_760)
|
|
key = f"attachments/{uuid4()}"
|
|
async with storage(rustfs) as objects:
|
|
await objects.put(key, data, "image/png")
|
|
content = await objects.open(key)
|
|
assert content.size == len(data)
|
|
assert b"".join([chunk async for chunk in content.chunks]) == data
|
|
await objects.delete(key)
|
|
with pytest.raises(ObjectMissingError):
|
|
await objects.open(key)
|
|
await objects.delete(key)
|
|
|
|
|
|
async def test_listing_is_paged_in_byte_order_and_stat_reads_size(rustfs: str) -> None:
|
|
prefix = f"reconcile-{uuid4().hex}/"
|
|
keys = [f"{prefix}{name}" for name in ("b", "a", "Z", "a-1", "é")]
|
|
async with storage(rustfs) as objects:
|
|
for size, key in enumerate(keys, start=1):
|
|
await objects.put(key, b"x" * size, "image/png")
|
|
pages = [page async for page in objects.listing(prefix, 2)]
|
|
assert [len(page) for page in pages] == [2, 2, 1]
|
|
listed = [item.key for page in pages for item in page]
|
|
assert listed == sorted(keys, key=str.encode)
|
|
sizes = {item.key: item.size for page in pages for item in page}
|
|
assert sizes == {key: size for size, key in enumerate(keys, start=1)}
|
|
found = await objects.stat(keys[0])
|
|
assert found is not None
|
|
assert found.size == 1
|
|
assert await objects.stat(f"{prefix}absent") is None
|
|
for key in keys:
|
|
await objects.delete(key)
|
|
assert not [item async for page in objects.listing(prefix, 2) for item in page]
|
|
|
|
|
|
async def test_unreachable_endpoint_is_unavailable_in_bounded_time() -> None:
|
|
started = time.monotonic()
|
|
async with storage_without_bucket("http://127.0.0.1:1") as objects:
|
|
with pytest.raises(Unavailable):
|
|
await objects.put("attachments/x", b"x", "image/png")
|
|
with pytest.raises(Unavailable):
|
|
await objects.open("attachments/x")
|
|
with pytest.raises(Unavailable):
|
|
await objects.stat("attachments/x")
|
|
with pytest.raises(Unavailable):
|
|
await anext(aiter(objects.listing("attachments/", 10)))
|
|
assert time.monotonic() - started < 12
|
|
|
|
|
|
@asynccontextmanager
|
|
async def storage_without_bucket(endpoint: str) -> AsyncIterator[S3ObjectStorage]:
|
|
async with s3_client(
|
|
endpoint=endpoint,
|
|
region="us-east-1",
|
|
access_key_id=ROOT_KEY,
|
|
secret_access_key=ROOT_SECRET,
|
|
connect_timeout=1,
|
|
read_timeout=2,
|
|
max_attempts=2,
|
|
) as client:
|
|
yield S3ObjectStorage(client, BUCKET)
|