dtf-system/tests/test_printfile.py

"""The print file must reproduce the reviewed layout: size, place, turn and mirror.

Runs where Pillow is installed (the API image, or a local virtualenv). The
raster checks additionally need PyMuPDF to draw the page, and skip without it;
the structural checks do not.
"""
import io
import os
import re
import tempfile
import unittest
import zlib

from PIL import Image

from app.printfile import PT_PER_CM, Unsupported, placement_matrix, render

try:
    import fitz  # PyMuPDF, a development-only rasteriser
except ImportError:
    fitz = None

RED, GREEN, BLUE, YELLOW = (255, 0, 0), (0, 160, 0), (0, 0, 255), (255, 220, 0)


def quadrants(width=80, height=40, alpha=False):
    """Top-left red, top-right green, bottom-left blue, bottom-right yellow."""
    image = Image.new('RGBA' if alpha else 'RGB', (width, height))
    for x in range(width):
        for y in range(height):
            left, top = x < width // 2, y < height // 2
            color = RED if left and top else GREEN if top else BLUE if left else YELLOW
            image.putpixel((x, y), color + ((255,) if alpha else ()))
    return image


def item(placements, sources, height_cm, billed='1.0', film=57):
    return {'mode': 'avulsa', 'billed_metres': billed,
            'production': {'version': 2, 'film_width_cm': film, 'height_cm': height_cm,
                           'sources': sources, 'placements': placements}}


def source(width_cm, length_cm, copies=1, rotation=0, mirrored=False):
    return {'upload_id': '00000000-0000-0000-0000-000000000000', 'kind': 'artwork',
            'width_cm': width_cm, 'length_cm': length_cm, 'copies': copies,
            'rotation_degrees': rotation, 'mirrored': mirrored, 'measurement': 'file'}


def placement(x, y, width, length, rotation=0, mirrored=False, index=0, copy=0):
    return {'source_index': index, 'copy_index': copy, 'x_cm': x, 'y_cm': y,
            'width_cm': width, 'length_cm': length,
            'rotation_degrees': rotation, 'mirrored': mirrored}


class PrintFileTests(unittest.TestCase):
    def setUp(self):
        self.dir = tempfile.TemporaryDirectory()
        self.addCleanup(self.dir.cleanup)

    def save(self, image, name, **options):
        path = os.path.join(self.dir.name, name)
        image.save(path, **options)
        return path

    def render(self, spec, paths):
        out = io.BytesIO()
        detail = render(spec, {i: (p, os.path.basename(p)) for i, p in enumerate(paths)}, out, 'test')
        return out.getvalue(), detail

    def test_page_is_the_film_and_the_layout_length(self):
        path = self.save(quadrants(), 'a.png')
        pdf, detail = self.render(item([placement(0, 0, 20, 10), placement(20, 0, 20, 10, copy=1)],
                                       [source(20, 10, copies=2)], 10), [path])
        box = re.search(rb'/MediaBox \[0 0 ([\d.]+) ([\d.]+)\]', pdf)
        self.assertAlmostEqual(float(box.group(1)), 57 * PT_PER_CM, places=2)
        self.assertAlmostEqual(float(box.group(2)), 10 * PT_PER_CM, places=2)
        # One embedded image, drawn once per copy.
        self.assertEqual(pdf.count(b'/Subtype /Image'), 1)
        content = self.content(pdf)
        self.assertEqual(content.count(b' Do '), 2)
        self.assertEqual(detail['placements'], 2)
        self.assertEqual(detail['min_dpi'], round(80 / (20 / 2.54)))
        self.assertTrue(pdf.startswith(b'%PDF-1.6') and pdf.rstrip().endswith(b'%%EOF'))

    def content(self, pdf):
        # The page content is the last Flate stream before the page object.
        streams = re.findall(rb'/Filter /FlateDecode/Length \d+ 0 R>>\nstream\n(.*?)\nendstream', pdf, re.S)
        return zlib.decompress(streams[-1])

    def test_jpeg_bytes_are_embedded_unchanged(self):
        path = self.save(quadrants(), 'a.jpg', quality=90)
        pdf, _ = self.render(item([placement(0, 0, 20, 10)], [source(20, 10)], 10), [path])
        with open(path, 'rb') as original:
            self.assertIn(original.read(), pdf)
        self.assertIn(b'/DCTDecode', pdf)

    def test_transparency_survives_as_a_soft_mask(self):
        image = quadrants(alpha=True)
        image.putpixel((0, 0), (0, 0, 0, 0))
        path = self.save(image, 'a.png')
        pdf, _ = self.render(item([placement(0, 0, 20, 10)], [source(20, 10)], 10), [path])
        self.assertIn(b'/SMask', pdf)
        self.assertEqual(pdf.count(b'/Subtype /Image'), 2)

    def test_exif_orientation_is_honoured_like_a_browser(self):
        # Stored landscape, tagged "rotate 90": browsers show it portrait.
        image = quadrants(80, 40)
        exif = Image.Exif()
        exif[0x0112] = 6
        path = self.save(image, 'a.jpg', exif=exif)
        pdf, _ = self.render(item([placement(0, 0, 10, 20)], [source(10, 20)], 20), [path])
        self.assertNotIn(b'/DCTDecode', pdf)
        with self.assertRaises(Unsupported):
            self.render(item([placement(0, 0, 20, 10)], [source(20, 10)], 10), [path])

    def test_refuses_what_it_cannot_reproduce(self):
        png = self.save(quadrants(), 'a.png')
        with self.assertRaisesRegex(Unsupported, 'proportions'):
            self.render(item([placement(0, 0, 20, 20)], [source(20, 20)], 20), [png])
        with self.assertRaisesRegex(Unsupported, 'billed'):
            self.render(item([placement(0, 0, 20, 10)], [source(20, 10)], 150, billed='1.0'), [png])
        fake_pdf = os.path.join(self.dir.name, 'art.pdf')
        with open(fake_pdf, 'wb') as handle:
            handle.write(b'%PDF-1.4\n%%EOF\n')
        with self.assertRaisesRegex(Unsupported, 'not an image'):
            self.render(item([placement(0, 0, 20, 10)], [source(20, 10)], 10), [fake_pdf])

    def test_long_layouts_scale_user_space_instead_of_splitting(self):
        # 6 m is longer than a PDF page may be (about 5.08 m).
        path = self.save(quadrants(40, 800), 'a.png')
        pdf, detail = self.render(item([placement(0, 0, 30, 600)], [source(30, 600)], 600,
                                       billed='6.0'), [path])
        self.assertEqual(detail['user_unit'], 2)
        self.assertIn(b'/UserUnit 2', pdf)

    def test_matrix_maps_corners_like_the_canvas(self):
        # Box 20 x 10 cm at the page's top-left; which image corner lands where.
        page = 10 * PT_PER_CM

        def corner(matrix, u, v):
            a, b, c, d, e, f = matrix
            x, y = a * u + c * v + e, b * u + d * v + f
            return round(x / PT_PER_CM, 6), round((page - y) / PT_PER_CM, 6)

        # Image top-left is unit (0, 1).
        cases = {(0, False): (0, 0), (90, False): (20, 0), (180, False): (20, 10),
                 (270, False): (0, 10), (0, True): (20, 0), (90, True): (20, 10)}
        for (rotation, mirrored), expected in cases.items():
            matrix = placement_matrix(placement(0, 0, 20, 10, rotation, mirrored), page)
            self.assertEqual(corner(matrix, 0, 1), expected, (rotation, mirrored))

    @unittest.skipIf(fitz is None, 'PyMuPDF is not installed')
    def test_drawn_page_matches_the_layout(self):
        # Each case: the colour expected in the box's TL, TR, BL, BR quadrant.
        cases = {
            (0, False): (RED, GREEN, BLUE, YELLOW),
            (90, False): (BLUE, RED, YELLOW, GREEN),
            (180, False): (YELLOW, BLUE, GREEN, RED),
            (0, True): (GREEN, RED, YELLOW, BLUE),
            (90, True): (YELLOW, GREEN, BLUE, RED),
        }
        image = quadrants(80, 40)
        for (rotation, mirrored), expected in cases.items():
            turned = rotation % 180 == 90
            width, length = (10, 20) if turned else (20, 10)
            path = self.save(image, f'q{rotation}{mirrored}.png')
            # Sources are described after the customer's turn, like the box.
            spec = item([placement(12, 5, width, length, rotation, mirrored)],
                        [source(width, length, rotation=rotation % 180, mirrored=mirrored)], 30)
            pdf, _ = self.render(spec, [path])
            page = fitz.open(stream=pdf, filetype='pdf')[0]
            dpi = 40
            pixmap = page.get_pixmap(dpi=dpi, alpha=False)

            def sample(x_cm, y_cm):
                px = int(x_cm / 2.54 * dpi)
                py = int(y_cm / 2.54 * dpi)
                return pixmap.pixel(px, py)

            got = (sample(12 + width * .25, 5 + length * .25), sample(12 + width * .75, 5 + length * .25),
                   sample(12 + width * .25, 5 + length * .75), sample(12 + width * .75, 5 + length * .75))
            for actual, wanted in zip(got, expected):
                self.assertTrue(all(abs(a - w) < 40 for a, w in zip(actual, wanted)),
                                f'rotation {rotation} mirrored {mirrored}: {got} != {expected}')
            # Outside the box the film stays empty.
            self.assertEqual(sample(2, 2), (255, 255, 255))


if __name__ == '__main__':
    unittest.main()