forked from mtusi2026/mtusi2026lab6
179 lines
8.5 KiB
Python
179 lines
8.5 KiB
Python
"""lab5: асинхронный pipeline вложений через балансировщик (HTTP, только stdlib).
|
||
|
||
BASE_URL=http://127.0.0.1:8080 python -m unittest discover -s student-tests -p test_pipeline.py -v
|
||
|
||
Проверяет контракт вариантов по ФАКТИЧЕСКИМ байтам (а не только по метаданным):
|
||
* 202 queued -> ready; варианты thumbnail (JPEG, вписан в 256), crop (JPEG 128x128),
|
||
optimized (WebP, вписан в 1280, без увеличения); size/sha256 совпадают с байтами;
|
||
* EXIF orientation применяется (400x100 с orientation=6 -> 64x256);
|
||
* маленький исходник не увеличивается в thumbnail/optimized, crop увеличивается;
|
||
* прозрачность компонуется на белый (JPEG thumbnail прозрачного PNG — белый);
|
||
* в вариантах нет EXIF (APP1) — метаданные удалены;
|
||
* original после обработки неизменен (SHA-256), variant=original совпадает;
|
||
* повторный GET стабилен (повтор не создаёт новых вариантов);
|
||
* сообщение может ссылаться на queued-вложение; посторонний не видит вариантов.
|
||
"""
|
||
import hashlib
|
||
import struct
|
||
import sys
|
||
import time
|
||
import unittest
|
||
import uuid
|
||
from pathlib import Path
|
||
from urllib.parse import quote
|
||
|
||
HERE = Path(__file__).resolve().parent
|
||
sys.path.insert(0, str(HERE))
|
||
sys.path.insert(0, str(HERE.parent / "tests"))
|
||
from common import BASE_URL, actor, create_chat, reachable, request, wait_ready # noqa: E402
|
||
from image_probe import jpeg_size # noqa: E402
|
||
from test_attachments import raw_get, upload # noqa: E402
|
||
|
||
FIX = HERE / "fixtures"
|
||
|
||
|
||
def webp_size(data):
|
||
"""Размеры WebP по заголовку RIFF (VP8 / VP8L / VP8X)."""
|
||
if data[:4] != b"RIFF" or data[8:12] != b"WEBP":
|
||
raise AssertionError("not a WebP file")
|
||
chunk = data[12:16]
|
||
if chunk == b"VP8 ":
|
||
w, h = struct.unpack("<HH", data[26:30])
|
||
return w & 0x3FFF, h & 0x3FFF
|
||
if chunk == b"VP8L":
|
||
b = data[21:25]
|
||
bits = int.from_bytes(b, "little")
|
||
return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1
|
||
if chunk == b"VP8X":
|
||
w = int.from_bytes(data[24:27], "little") + 1
|
||
h = int.from_bytes(data[27:30], "little") + 1
|
||
return w, h
|
||
raise AssertionError("unknown WebP chunk %r" % chunk)
|
||
|
||
|
||
def jpeg_has_exif(data):
|
||
i = 2
|
||
while i + 4 <= len(data) and data[i] == 0xFF:
|
||
marker = data[i + 1]
|
||
if marker == 0xDA:
|
||
return False
|
||
length = int.from_bytes(data[i + 2:i + 4], "big")
|
||
if marker == 0xE1 and data[i + 4:i + 10] == b"Exif\x00\x00":
|
||
return True
|
||
i += 2 + length
|
||
return False
|
||
|
||
|
||
def jpeg_center_is_white(data):
|
||
"""Грубая проверка без декодера: JPEG целиком белого кадра очень мал и его
|
||
размеры совпадают; точную проверку цвета делает test_pipeline_faults (Pillow)."""
|
||
return len(data) < 2000
|
||
|
||
|
||
@unittest.skipUnless(reachable(BASE_URL), "API is not reachable at %s" % BASE_URL)
|
||
class PipelineTests(unittest.TestCase):
|
||
|
||
@classmethod
|
||
def setUpClass(cls):
|
||
cls.alice = actor("pipe_a")
|
||
cls.bob = actor("pipe_b")
|
||
cls.eve = actor("pipe_e")
|
||
cls.chat = create_chat(cls.alice, cls.bob)
|
||
|
||
def accept(self, data, ctype, name):
|
||
r = upload(self.alice["_token"], self.chat["id"], data, ctype, name)
|
||
self.assertEqual(r.status, 202, r.json)
|
||
self.assertEqual(r.json["status"], "queued")
|
||
self.assertEqual(r.json["variants"], [])
|
||
self.assertIsNone(r.json["error_code"])
|
||
return r.json
|
||
|
||
def variants_of(self, att):
|
||
return {v["name"]: v for v in att["variants"]}
|
||
|
||
def fetch_variant(self, att, name):
|
||
status, headers, body = raw_get("/api/v1/attachments/%s/content?variant=%s" % (att["id"], name),
|
||
self.bob["_token"])
|
||
self.assertEqual(status, 200, name)
|
||
v = self.variants_of(att)[name]
|
||
self.assertEqual(headers.get_content_type(), v["content_type"])
|
||
self.assertEqual(len(body), v["size_bytes"])
|
||
self.assertEqual(hashlib.sha256(body).hexdigest(), v["sha256"])
|
||
return body
|
||
|
||
def check_all(self, data, ctype, name, thumb, opt):
|
||
att = self.accept(data, ctype, name)
|
||
ready = wait_ready(self.bob["_token"], att["id"])
|
||
self.assertIsNone(ready["error_code"])
|
||
v = self.variants_of(ready)
|
||
self.assertEqual(sorted(v), ["crop", "optimized", "thumbnail"])
|
||
self.assertEqual((v["thumbnail"]["content_type"], v["crop"]["content_type"], v["optimized"]["content_type"]),
|
||
("image/jpeg", "image/jpeg", "image/webp"))
|
||
self.assertEqual((v["thumbnail"]["width"], v["thumbnail"]["height"]), thumb)
|
||
self.assertEqual((v["crop"]["width"], v["crop"]["height"]), (128, 128))
|
||
self.assertEqual((v["optimized"]["width"], v["optimized"]["height"]), opt)
|
||
t = self.fetch_variant(ready, "thumbnail")
|
||
c = self.fetch_variant(ready, "crop")
|
||
o = self.fetch_variant(ready, "optimized")
|
||
self.assertEqual(jpeg_size(t), thumb)
|
||
self.assertEqual(jpeg_size(c), (128, 128))
|
||
self.assertEqual(webp_size(o), opt)
|
||
self.assertFalse(jpeg_has_exif(t) or jpeg_has_exif(c), "EXIF must be stripped from variants")
|
||
self.assertNotIn(b"Exif\x00\x00", o)
|
||
# Оригинал неизменен.
|
||
status, headers, body = raw_get("/api/v1/attachments/%s/content" % att["id"], self.bob["_token"])
|
||
self.assertEqual((status, body, headers.get_content_type()), (200, data, ctype))
|
||
status, _, body2 = raw_get("/api/v1/attachments/%s/content?variant=original" % att["id"], self.bob["_token"])
|
||
self.assertEqual((status, body2), (200, data))
|
||
return ready, t
|
||
|
||
def test_fixture_320x200(self):
|
||
data = (HERE.parent / "tests/fixtures/sample.png").read_bytes()
|
||
self.check_all(data, "image/png", "sample.png", (256, 160), (320, 200))
|
||
|
||
def test_exif_orientation_applied_and_stripped(self):
|
||
data = (FIX / "orient6.jpg").read_bytes()
|
||
self.assertIn(b"Exif", data)
|
||
self.check_all(data, "image/jpeg", "orient6.jpg", (64, 256), (100, 400))
|
||
|
||
def test_small_source_not_upscaled_except_crop(self):
|
||
data = (FIX / "small.png").read_bytes()
|
||
self.check_all(data, "image/png", "small.png", (40, 20), (40, 20))
|
||
|
||
def test_transparency_on_white(self):
|
||
data = (FIX / "transparent.png").read_bytes()
|
||
_, thumb = self.check_all(data, "image/png", "transparent.png", (256, 128), (600, 300))
|
||
self.assertTrue(jpeg_center_is_white(thumb))
|
||
|
||
def test_progressive_jpeg(self):
|
||
data = (FIX / "sample_progressive.jpg").read_bytes()
|
||
self.check_all(data, "image/jpeg", "p.jpg", (256, 160), (320, 200))
|
||
|
||
def test_result_is_stable_and_private(self):
|
||
data = (FIX / "sample.jpg").read_bytes()
|
||
att = self.accept(data, "image/jpeg", "stable.jpg")
|
||
# queued/processing-вложение уже можно прикрепить к сообщению.
|
||
m = request("POST", "/api/v1/chats/%s/messages" % self.chat["id"], token=self.alice["_token"],
|
||
payload={"text": "", "attachment_ids": [att["id"]]},
|
||
headers={"Idempotency-Key": uuid.uuid4().hex})
|
||
self.assertEqual(m.status, 201, m.json)
|
||
ready = wait_ready(self.alice["_token"], att["id"])
|
||
time.sleep(1.0)
|
||
again = request("GET", "/api/v1/attachments/" + att["id"], token=self.bob["_token"]).json
|
||
self.assertEqual(again, ready) # повторные чтения не меняют результат
|
||
for suffix in ("", "/content?variant=thumbnail", "/content?variant=crop"):
|
||
r = request("GET", "/api/v1/attachments/" + att["id"] + suffix, token=self.eve["_token"])
|
||
self.assertEqual(r.status, 404)
|
||
|
||
def test_unknown_variant_is_400(self):
|
||
data = (FIX / "small.png").read_bytes()
|
||
att = self.accept(data, "image/png", "v.png")
|
||
wait_ready(self.bob["_token"], att["id"])
|
||
r = request("GET", "/api/v1/attachments/%s/content?variant=%s" % (att["id"], quote("big")),
|
||
token=self.bob["_token"])
|
||
self.assertEqual(r.status, 400)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
unittest.main()
|