sailfork / t3code-github / apps/ web/ src/ components/ media/ AttachmentImage.browser.test.tsx

import { act, render, type Screen } from "../../../test/render";
import { expect, it, vi } from "vite-plus/test";
import { AttachmentImage } from "./AttachmentImage";
import { decodeImagePreview } from "../files/decodeImagePreview";

vi.mock("../files/decodeImagePreview", () => ({
  decodeImagePreview: vi.fn(),
}));

const revokeUrl = vi.fn();
const bitmap = new Blob(["png"], { type: "image/png" });

function setup() {
  revokeUrl.mockReset();
  vi.mocked(decodeImagePreview).mockReset().mockResolvedValue(bitmap);
}

function image(screen: Screen) {
  const img = screen.container.querySelector("img");
  expect(img).not.toBeNull();
  return img!;
}

// Stands in for the browser failing to decode the current source.
async function failDecode(screen: Screen) {
  const img = image(screen);
  await act(() => {
    img.dispatchEvent(new Event("error"));
  });
  await act(() => vi.dynamicImportSettled());
  return img;
}

function expectDecodeErrorFor(onError: ReturnType<typeof vi.fn>, img: HTMLImageElement) {
  expect(onError).toHaveBeenCalledWith(expect.objectContaining({ type: "error", target: img }));
}

it.each([
  { name: "photo.HEIC", mimeType: undefined, heif: true },
  { name: "photo.heif", mimeType: undefined, heif: true },
  { name: "photo", mimeType: "image/heif", heif: true },
  { name: "scan.TIFF", mimeType: undefined, heif: false },
  { name: "scan", mimeType: "image/tiff", heif: false },
])(
  "converts $name after native decoding fails and releases its preview",
  async ({ name, mimeType, heif }) => {
    setup();
    using _createUrl = vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:jpeg");
    using _revokeUrl = vi.spyOn(URL, "revokeObjectURL").mockImplementation(revokeUrl);
    await using screen = await render(
      <AttachmentImage src="https://environment.test/photo" name={name} mimeType={mimeType} />,
    );
    expect(decodeImagePreview).not.toHaveBeenCalled();
    await failDecode(screen);
    expect(image(screen).getAttribute("src")).toBe("blob:jpeg");
    expect(decodeImagePreview).toHaveBeenCalledWith(
      "https://environment.test/photo",
      heif,
      expect.any(AbortSignal),
    );
    await screen.unmount();
    expect(revokeUrl).toHaveBeenCalledWith("blob:jpeg");
  },
);

it("leaves PNG errors to the caller without fetching or converting", async () => {
  setup();
  using _createUrl = vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:jpeg");
  using _revokeUrl = vi.spyOn(URL, "revokeObjectURL").mockImplementation(revokeUrl);
  const onError = vi.fn();
  await using screen = await render(
    <AttachmentImage src="blob:png" name="photo.png" onError={onError} />,
  );
  expectDecodeErrorFor(onError, await failDecode(screen));
  expect(decodeImagePreview).not.toHaveBeenCalled();
});

it("reports failed HEIC conversion through the existing error handler", async () => {
  setup();
  using _createUrl = vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:jpeg");
  using _revokeUrl = vi.spyOn(URL, "revokeObjectURL").mockImplementation(revokeUrl);
  const onError = vi.fn();
  vi.mocked(decodeImagePreview).mockRejectedValue(new Error("unreadable"));
  await using screen = await render(
    <AttachmentImage src="blob:heic" name="photo.heif" onError={onError} />,
  );
  expectDecodeErrorFor(onError, await failDecode(screen));
  expect(URL.createObjectURL).not.toHaveBeenCalled();
});

it("discards an old decode when navigating to a different source", async () => {
  setup();
  using _createUrl = vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:jpeg");
  using _revokeUrl = vi.spyOn(URL, "revokeObjectURL").mockImplementation(revokeUrl);
  let finishDecode!: (result: Blob) => void;
  vi.mocked(decodeImagePreview).mockReturnValue(
    new Promise((resolve) => {
      finishDecode = resolve;
    }),
  );
  await using screen = await render(<AttachmentImage src="blob:first" name="photo.heic" />);
  await failDecode(screen);
  const secondSource = "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'/>";
  await screen.rerender(<AttachmentImage src={secondSource} name="photo.heic" />);
  await act(() => finishDecode(bitmap));
  expect(image(screen).getAttribute("src")).toBe(secondSource);
  expect(URL.createObjectURL).not.toHaveBeenCalled();
  expect(vi.mocked(decodeImagePreview).mock.calls[0]?.[2].aborted).toBe(true);
});