forked from mtusi2026/mtusi2026lab5
169 lines
8.2 KiB
Python
169 lines
8.2 KiB
Python
import hashlib
|
|
from pathlib import Path
|
|
import tempfile
|
|
import threading
|
|
import unittest
|
|
from unittest.mock import Mock, patch
|
|
import uuid
|
|
|
|
from PIL import Image
|
|
|
|
from messenger.image_process import InvalidImage, fit_dimensions, process_image
|
|
from messenger.worker import ProcessingError, Worker, retry_delay
|
|
|
|
|
|
class ImagePipelineTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temp = tempfile.TemporaryDirectory()
|
|
self.directory = Path(self.temp.name)
|
|
self.addCleanup(self.temp.cleanup)
|
|
|
|
def source(self, size, mode='RGB', color='red', fmt='PNG', **options):
|
|
path = self.directory / 'original'
|
|
image = Image.new(mode, size, color)
|
|
image.save(path, format=fmt, **options)
|
|
image.close()
|
|
return path
|
|
|
|
def test_all_variants_and_original_checksum(self):
|
|
source = self.source((320, 200))
|
|
original = source.read_bytes()
|
|
variants = process_image(source, self.directory, 'image/png')
|
|
self.assertEqual(source.read_bytes(), original)
|
|
self.assertEqual({v['name'] for v in variants}, {'thumbnail', 'crop', 'optimized'})
|
|
for metadata in variants:
|
|
filename = {'thumbnail': 'thumbnail.jpg', 'crop': 'crop.jpg', 'optimized': 'optimized.webp'}[metadata['name']]
|
|
content = (self.directory / filename).read_bytes()
|
|
self.assertEqual(metadata['size_bytes'], len(content))
|
|
self.assertEqual(metadata['sha256'], hashlib.sha256(content).hexdigest())
|
|
with Image.open(self.directory / 'thumbnail.jpg') as image:
|
|
self.assertEqual(image.format, 'JPEG')
|
|
self.assertEqual(image.size, (256, 160))
|
|
with Image.open(self.directory / 'crop.jpg') as image:
|
|
self.assertEqual(image.size, (128, 128))
|
|
with Image.open(self.directory / 'optimized.webp') as image:
|
|
self.assertEqual(image.format, 'WEBP')
|
|
self.assertEqual(image.size, (320, 200))
|
|
|
|
def test_small_alpha_is_flattened_white_without_upscale(self):
|
|
source = self.source((12, 7), 'RGBA', (255, 0, 0, 0))
|
|
process_image(source, self.directory, 'image/png')
|
|
with Image.open(self.directory / 'thumbnail.jpg') as image:
|
|
self.assertEqual(image.size, (12, 7))
|
|
self.assertTrue(all(channel >= 250 for channel in image.getpixel((1, 1))))
|
|
with Image.open(self.directory / 'optimized.webp') as image:
|
|
self.assertEqual(image.size, (12, 7))
|
|
with Image.open(self.directory / 'crop.jpg') as image:
|
|
self.assertEqual(image.size, (128, 128))
|
|
|
|
def test_exif_orientation_applied_and_metadata_removed(self):
|
|
exif = Image.Exif()
|
|
exif[274] = 6
|
|
exif[315] = 'metadata must disappear'
|
|
source = self.source((320, 200), fmt='JPEG', exif=exif)
|
|
process_image(source, self.directory, 'image/jpeg')
|
|
for name in ('thumbnail.jpg', 'crop.jpg', 'optimized.webp'):
|
|
with Image.open(self.directory / name) as image:
|
|
self.assertFalse(image.getexif())
|
|
self.assertNotIn('icc_profile', image.info)
|
|
with Image.open(self.directory / 'thumbnail.jpg') as image:
|
|
self.assertEqual(image.size, (160, 256))
|
|
|
|
def test_center_crop_uses_center_pixels(self):
|
|
source = self.source((300, 100), color='red')
|
|
with Image.open(source) as image:
|
|
image.paste('blue', (100, 0, 200, 100))
|
|
image.save(source, format='PNG')
|
|
process_image(source, self.directory, 'image/png')
|
|
with Image.open(self.directory / 'crop.jpg') as image:
|
|
pixel = image.getpixel((64, 64))
|
|
self.assertGreater(pixel[2], 240)
|
|
self.assertLess(pixel[0], 15)
|
|
|
|
def test_invalid_pixels_and_mime_rejected(self):
|
|
source = self.source((11, 10))
|
|
with self.assertRaises(InvalidImage) as error:
|
|
process_image(source, self.directory, 'image/png', max_pixels=100)
|
|
self.assertEqual(error.exception.code, 'image_too_large')
|
|
with self.assertRaises(InvalidImage):
|
|
process_image(source, self.directory, 'image/jpeg')
|
|
source.write_bytes(b'not an image')
|
|
with self.assertRaises(InvalidImage):
|
|
process_image(source, self.directory, 'image/png')
|
|
|
|
def test_floor_dimensions_and_extreme_aspect_ratio(self):
|
|
self.assertEqual(fit_dimensions(321, 200, 256), (256, 159))
|
|
self.assertEqual(fit_dimensions(10_000, 1, 256), (256, 1))
|
|
self.assertEqual(fit_dimensions(1, 10_000, 1280), (1, 1280))
|
|
|
|
def test_decoder_subprocess_under_production_limits(self):
|
|
self.source((2000, 1500), 'RGBA', (200, 10, 50, 128)).rename(self.directory / 'source')
|
|
worker = Worker(Mock(), Mock(), threading.Event())
|
|
variants = worker._decode({'content_type': 'image/png'}, self.directory)
|
|
self.assertEqual({v['name'] for v in variants}, {'thumbnail', 'crop', 'optimized'})
|
|
optimized = next(v for v in variants if v['name'] == 'optimized')
|
|
self.assertEqual((optimized['width'], optimized['height']), (1280, 960))
|
|
|
|
|
|
class WorkerDurabilityTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.jobs, self.broker = Mock(), Mock()
|
|
self.worker = Worker(self.jobs, Mock(), threading.Event())
|
|
self.claim = {'job_id': uuid.uuid4(), 'attachment_id': uuid.uuid4(), 'attempt': 1,
|
|
'run_attempts': 1, 'pipeline_version': 1}
|
|
self.payload = {'job_id': str(self.claim['job_id']),
|
|
'attachment_id': str(self.claim['attachment_id']), 'pipeline_version': 1}
|
|
self.jobs.claim.return_value = self.claim
|
|
|
|
def test_ack_follows_committed_result(self):
|
|
with patch.object(self.worker, 'process', return_value=True):
|
|
self.worker.handle(self.broker, '1-0', self.payload, 'consumer')
|
|
self.broker.ack.assert_called_once_with('1-0')
|
|
|
|
def test_lost_fence_is_left_pending(self):
|
|
with patch.object(self.worker, 'process', return_value=False):
|
|
self.worker.handle(self.broker, '1-0', self.payload, 'consumer')
|
|
self.broker.ack.assert_not_called()
|
|
|
|
def test_retry_ack_requires_durable_failure_record(self):
|
|
self.jobs.fail.return_value = True
|
|
with patch.object(self.worker, 'process', side_effect=ProcessingError('dependency_unavailable')):
|
|
self.worker.handle(self.broker, '1-0', self.payload, 'consumer')
|
|
self.jobs.fail.assert_called_once()
|
|
self.assertFalse(self.jobs.fail.call_args.args[2])
|
|
self.broker.ack.assert_called_once_with('1-0')
|
|
self.jobs.fail.return_value = False
|
|
self.broker.reset_mock()
|
|
with patch.object(self.worker, 'process', side_effect=ProcessingError('dependency_unavailable')):
|
|
self.worker.handle(self.broker, '1-0', self.payload, 'consumer')
|
|
self.broker.ack.assert_not_called()
|
|
|
|
def test_permanent_failure_has_no_automatic_processing_retry(self):
|
|
self.jobs.fail.return_value = True
|
|
with patch.object(self.worker, 'process', side_effect=ProcessingError('invalid_image', permanent=True)):
|
|
self.worker.handle(self.broker, '1-0', self.payload, 'consumer')
|
|
self.assertTrue(self.jobs.fail.call_args.args[2])
|
|
self.broker.ack.assert_called_once_with('1-0')
|
|
|
|
def test_active_redelivery_does_not_ack_and_ready_is_noop(self):
|
|
self.jobs.claim.return_value = None
|
|
self.jobs.delivery_state.return_value = {'status': 'processing', 'variant_count': 0}
|
|
self.worker.handle(self.broker, '1-0', self.payload, 'consumer')
|
|
self.broker.ack.assert_not_called()
|
|
self.jobs.delivery_state.return_value = {'status': 'ready', 'variant_count': 3}
|
|
with patch.object(self.worker, 'process') as process:
|
|
self.worker.handle(self.broker, '1-0', self.payload, 'consumer')
|
|
process.assert_not_called()
|
|
self.broker.ack.assert_called_once_with('1-0')
|
|
|
|
def test_backoff_bounds_and_cap(self):
|
|
rng = Mock()
|
|
rng.uniform.side_effect = lambda low, high: high
|
|
self.assertEqual(retry_delay(1, rng, base_seconds=1, max_seconds=30), 1)
|
|
self.assertEqual(retry_delay(100, rng, base_seconds=1, max_seconds=30), 30)
|
|
rng.uniform.assert_called_with(15, 30)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|