195 lines
7.7 KiB
Python
195 lines
7.7 KiB
Python
"""Фоновая обработка (лаба 5) по HTTP: 202 → ready с тремя вариантами,
|
||
геометрия и форматы вариантов, `failed` с безопасным кодом.
|
||
|
||
Размеры — по contracts/README.md, «Фоновая обработка»: thumbnail JPEG
|
||
вписан в 256×256 вниз без увеличения, crop JPEG ровно 128×128, optimized
|
||
WebP вписан в 1280×1280 без увеличения и без EXIF. Варианты проверяются
|
||
декодером (Pillow в dev-окружении), а не только метаданными.
|
||
"""
|
||
|
||
import hashlib
|
||
from typing import Any
|
||
|
||
import httpx
|
||
import pytest
|
||
|
||
import images
|
||
from helpers import (
|
||
SAMPLE_JPEG,
|
||
SAMPLE_PNG,
|
||
VARIANT_NAMES,
|
||
assert_error,
|
||
attachment_content,
|
||
create_chat,
|
||
ready_upload,
|
||
register,
|
||
send,
|
||
settled,
|
||
uploaded,
|
||
)
|
||
|
||
EXPECTED_TYPES = {
|
||
"thumbnail": ("image/jpeg", "JPEG"),
|
||
"crop": ("image/jpeg", "JPEG"),
|
||
"optimized": ("image/webp", "WEBP"),
|
||
}
|
||
|
||
|
||
@pytest.fixture
|
||
def members(client: httpx.Client) -> dict[str, Any]:
|
||
alice, bob = register(client, "alice"), register(client, "bob")
|
||
return {"alice": alice, "bob": bob, "chat": create_chat(client, alice, bob)}
|
||
|
||
|
||
def variants_of(
|
||
client: httpx.Client, user: dict, meta: dict[str, Any]
|
||
) -> dict[str, tuple[dict, bytes]]:
|
||
"""Метаданные и байты каждого варианта; байты сходятся с метаданными."""
|
||
found = {}
|
||
for variant in meta["variants"]:
|
||
assert set(variant) == {
|
||
"name",
|
||
"content_type",
|
||
"size_bytes",
|
||
"width",
|
||
"height",
|
||
"sha256",
|
||
}
|
||
response = attachment_content(client, user, meta["id"], variant=variant["name"])
|
||
assert response.status_code == 200, response.text
|
||
assert response.headers["content-type"] == variant["content_type"]
|
||
assert len(response.content) == variant["size_bytes"]
|
||
assert hashlib.sha256(response.content).hexdigest() == variant["sha256"]
|
||
found[variant["name"]] = (variant, response.content)
|
||
assert sorted(found) == VARIANT_NAMES
|
||
return found
|
||
|
||
|
||
@pytest.mark.parametrize(
|
||
("data", "content_type", "size", "thumb", "optimized"),
|
||
[
|
||
# фикстура skeleton: 320×200 → 256×160 (contracts/README.md)
|
||
(SAMPLE_PNG, "image/png", (320, 200), (256, 160), (320, 200)),
|
||
(SAMPLE_JPEG, "image/jpeg", (320, 200), (256, 160), (320, 200)),
|
||
# большой: оба вниз, 2000×1000 → 256×128 и 1280×640
|
||
(
|
||
images.pillow_image(2000, 1000, fmt="PNG"),
|
||
"image/png",
|
||
(2000, 1000),
|
||
(256, 128),
|
||
(1280, 640),
|
||
),
|
||
# вертикальный с округлением вниз: 300×1000 → 76×256 (76,8)
|
||
(
|
||
images.pillow_image(300, 1000, fmt="JPEG"),
|
||
"image/jpeg",
|
||
(300, 1000),
|
||
(76, 256),
|
||
(300, 1000),
|
||
),
|
||
# маленький не увеличивается, кроме crop
|
||
(images.pillow_image(10, 6, fmt="PNG"), "image/png", (10, 6), (10, 6), (10, 6)),
|
||
],
|
||
ids=["fixture-png", "fixture-jpeg", "wide", "tall", "tiny"],
|
||
)
|
||
def test_variants_geometry(
|
||
client: httpx.Client,
|
||
members: dict,
|
||
data: bytes,
|
||
content_type: str,
|
||
size: tuple[int, int],
|
||
thumb: tuple[int, int],
|
||
optimized: tuple[int, int],
|
||
) -> None:
|
||
meta = ready_upload(
|
||
client, members["alice"], members["chat"], data, content_type=content_type
|
||
)
|
||
# о размере и SHA-256 оригинала говорят поля вложения, не вариантов
|
||
assert meta["size_bytes"] == len(data)
|
||
assert meta["sha256"] == hashlib.sha256(data).hexdigest()
|
||
found = variants_of(client, members["bob"], meta)
|
||
expected = {"thumbnail": thumb, "crop": (128, 128), "optimized": optimized}
|
||
for name, (variant, body) in found.items():
|
||
mime, fmt = EXPECTED_TYPES[name]
|
||
assert variant["content_type"] == mime
|
||
actual_fmt, actual_size, _, has_exif = images.decoded(body)
|
||
assert actual_fmt == fmt
|
||
assert actual_size == expected[name] == (variant["width"], variant["height"])
|
||
# метаданные исходника в варианты не переносятся
|
||
assert not has_exif, name
|
||
|
||
|
||
def test_exif_orientation_is_applied(client: httpx.Client, members: dict) -> None:
|
||
# хранится 320×200, EXIF 6 — «повернуть на 90°»: на экране 200×320
|
||
data = images.pillow_image(320, 200, fmt="JPEG", orientation=6)
|
||
meta = ready_upload(
|
||
client, members["alice"], members["chat"], data, content_type="image/jpeg"
|
||
)
|
||
found = variants_of(client, members["alice"], meta)
|
||
assert images.decoded(found["thumbnail"][1])[1] == (160, 256)
|
||
assert images.decoded(found["optimized"][1])[1] == (200, 320)
|
||
|
||
|
||
def test_alpha_goes_white_in_jpeg_and_stays_in_webp(
|
||
client: httpx.Client, members: dict
|
||
) -> None:
|
||
data = images.pillow_image(64, 48, fmt="PNG", mode="RGBA")
|
||
meta = ready_upload(client, members["alice"], members["chat"], data)
|
||
found = variants_of(client, members["alice"], meta)
|
||
assert images.decoded(found["thumbnail"][1])[2] == "RGB"
|
||
assert images.decoded(found["optimized"][1])[2] == "RGBA"
|
||
|
||
|
||
def test_original_is_unchanged_after_processing(
|
||
client: httpx.Client, members: dict
|
||
) -> None:
|
||
meta = ready_upload(client, members["alice"], members["chat"])
|
||
original = attachment_content(client, members["bob"], meta["id"])
|
||
assert original.content == SAMPLE_PNG
|
||
# повторное чтение метаданных — тот же набор вариантов: второго нет
|
||
again = settled(client, members["bob"], meta["id"])
|
||
assert again == meta
|
||
|
||
|
||
def test_undecodable_image_fails_with_safe_code(
|
||
client: httpx.Client, members: dict
|
||
) -> None:
|
||
"""Прошло структурную проверку API (202), но не декодируется: failed,
|
||
`invalid_image`, без вариантов; байты — 409, прикрепить — 409."""
|
||
alice, chat = members["alice"], members["chat"]
|
||
data = images.jpeg_without_tables(SAMPLE_JPEG)
|
||
accepted = uploaded(client, alice, chat, data, content_type="image/jpeg")
|
||
meta = settled(client, alice, accepted["id"])
|
||
assert meta["status"] == "failed"
|
||
assert meta["error_code"] == "invalid_image"
|
||
assert meta["variants"] == []
|
||
# размер и SHA-256 по-прежнему про оригинал
|
||
assert meta["sha256"] == hashlib.sha256(data).hexdigest()
|
||
for variant in ("original", "thumbnail"):
|
||
assert_error(
|
||
attachment_content(client, alice, meta["id"], variant=variant),
|
||
409,
|
||
"conflict",
|
||
)
|
||
assert_error(
|
||
send(client, alice, chat, "битое", attachment_ids=[meta["id"]]),
|
||
409,
|
||
"conflict",
|
||
)
|
||
# готовое вложение рядом с failed — 409, а не тихое сообщение без него
|
||
good = ready_upload(client, alice, chat)
|
||
assert_error(
|
||
send(client, alice, chat, "смесь", attachment_ids=[good["id"], meta["id"]]),
|
||
409,
|
||
"conflict",
|
||
)
|
||
|
||
|
||
def test_queued_attachment_can_be_linked(client: httpx.Client, members: dict) -> None:
|
||
"""Ссылка на ещё не обработанное вложение — сразу после 202."""
|
||
alice, bob, chat = members["alice"], members["bob"], members["chat"]
|
||
accepted = uploaded(client, alice, chat)
|
||
sent = send(client, alice, chat, "", attachment_ids=[accepted["id"]])
|
||
assert sent.status_code == 201, sent.text
|
||
assert settled(client, bob, accepted["id"])["status"] == "ready"
|