| |
| |
| import { beforeEach, describe, expect, it, vi } from "vitest"; |
|
|
| const mocks = vi.hoisted(() => ({ |
| convertImageToPng: vi.fn(), |
| encode: vi.fn(), |
| probe: vi.fn(), |
| })); |
|
|
| vi.mock("../../media/image-ops.js", () => ({ |
| convertImageToPng: mocks.convertImageToPng, |
| createImageProcessor: () => ({ |
| encode: mocks.encode, |
| probe: mocks.probe, |
| }), |
| })); |
|
|
| import { processImage } from "./image-resize.js"; |
|
|
| describe("image resize utility", () => { |
| beforeEach(() => { |
| mocks.convertImageToPng.mockReset(); |
| mocks.encode.mockReset(); |
| mocks.probe.mockReset(); |
| }); |
|
|
| it("keeps images that exactly fit the inline limits", async () => { |
| const input = "a".repeat(4.5 * 1024 * 1024); |
| mocks.probe.mockResolvedValue({ |
| bytes: Buffer.byteLength(input, "base64"), |
| format: "png", |
| hasAlpha: false, |
| height: 20, |
| orientation: null, |
| width: 10, |
| }); |
|
|
| const result = await processImage( |
| { type: "image", data: input, mimeType: "image/png" }, |
| { autoResizeImages: true }, |
| ); |
|
|
| expect(result).toStrictEqual({ |
| ok: true, |
| image: { type: "image", data: input, mimeType: "image/png" }, |
| hints: [], |
| }); |
| expect(mocks.encode).not.toHaveBeenCalled(); |
| }); |
|
|
| it("uses Rastermill limits, base64 budget, and orientation-aware source dimensions", async () => { |
| |
| |
| const inputBuffer = Buffer.from("large image"); |
| const outputBuffer = Buffer.from("jpeg output"); |
| mocks.probe.mockResolvedValue({ |
| bytes: inputBuffer.byteLength, |
| format: "jpeg", |
| hasAlpha: false, |
| height: 1200, |
| orientation: 6, |
| width: 3000, |
| }); |
| mocks.encode.mockResolvedValue({ |
| base64Bytes: Buffer.byteLength(outputBuffer.toString("base64"), "utf8"), |
| bytes: outputBuffer.byteLength, |
| chosen: { format: "jpeg", quality: 70 }, |
| data: outputBuffer, |
| format: "jpeg", |
| height: 1600, |
| metadata: "stripped", |
| mimeType: "image/jpeg", |
| resized: true, |
| width: 640, |
| withinBudget: true, |
| }); |
|
|
| const result = await processImage( |
| { type: "image", data: inputBuffer.toString("base64"), mimeType: "image/jpeg" }, |
| { autoResizeImages: true }, |
| ); |
|
|
| expect(mocks.encode).toHaveBeenCalledWith(inputBuffer, { |
| format: "auto", |
| limits: { |
| maxHeight: 2_000, |
| maxWidth: 2_000, |
| }, |
| maxBase64Bytes: 4.5 * 1024 * 1024, |
| opaque: { format: "jpeg", quality: 80 }, |
| search: { |
| compressionLevel: [6, 9], |
| quality: [80, 85, 70, 55, 40, 35], |
| }, |
| transparent: { format: "png" }, |
| }); |
| expect(result).toStrictEqual({ |
| ok: true, |
| image: { |
| type: "image", |
| data: outputBuffer.toString("base64"), |
| mimeType: "image/jpeg", |
| }, |
| hints: [ |
| "[Image: original 1200x3000, displayed at 640x1600. Multiply coordinates by 1.88 to map to original image.]", |
| ], |
| }); |
| }); |
|
|
| it("omits images when Rastermill cannot satisfy the base64 budget", async () => { |
| const inputBuffer = Buffer.from("too large"); |
| mocks.probe.mockResolvedValue({ |
| bytes: inputBuffer.byteLength, |
| format: "png", |
| hasAlpha: false, |
| height: 4000, |
| orientation: null, |
| width: 4000, |
| }); |
| mocks.encode.mockResolvedValue({ |
| base64Bytes: 120, |
| bytes: 90, |
| chosen: { format: "png" }, |
| data: Buffer.alloc(90), |
| format: "png", |
| height: 1, |
| metadata: "stripped", |
| mimeType: "image/png", |
| resized: true, |
| width: 1, |
| withinBudget: false, |
| }); |
|
|
| await expect( |
| processImage( |
| { type: "image", data: inputBuffer.toString("base64"), mimeType: "image/png" }, |
| { autoResizeImages: true }, |
| ), |
| ).resolves.toStrictEqual({ |
| ok: false, |
| message: "[Image omitted: could not be resized below the inline image size limit.]", |
| }); |
| }); |
|
|
| it("does not add coordinate hints when Rastermill only re-encodes the image", async () => { |
| const input = "a".repeat(4.5 * 1024 * 1024 + 1); |
| const outputBuffer = Buffer.from("re-encoded"); |
| mocks.probe.mockResolvedValue({ |
| bytes: Buffer.byteLength(input, "base64"), |
| format: "png", |
| hasAlpha: false, |
| height: 20, |
| orientation: null, |
| width: 10, |
| }); |
| mocks.encode.mockResolvedValue({ |
| base64Bytes: Buffer.byteLength(outputBuffer.toString("base64"), "utf8"), |
| bytes: outputBuffer.byteLength, |
| chosen: { format: "jpeg", quality: 80 }, |
| data: outputBuffer, |
| format: "jpeg", |
| height: 20, |
| metadata: "stripped", |
| mimeType: "image/jpeg", |
| resized: false, |
| width: 10, |
| withinBudget: true, |
| }); |
|
|
| await expect( |
| processImage( |
| { type: "image", data: input, mimeType: "image/png" }, |
| { autoResizeImages: true }, |
| ), |
| ).resolves.toStrictEqual({ |
| ok: true, |
| image: { |
| type: "image", |
| data: outputBuffer.toString("base64"), |
| mimeType: "image/jpeg", |
| }, |
| hints: [], |
| }); |
| }); |
| }); |
|
|
