import { describe, expect, it } from "vite-plus/test";
import {
filePreviewKind,
decodeFilePreviewText,
FILE_TEXT_PREVIEW_MAX_BYTES,
hostPreviewMimeTypeFromExtension,
isWorkspaceFontPreviewPath,
isWorkspaceImagePreviewPath,
isWorkspacePreviewEntryPath,
mediaKindFromPath,
officePreviewKind,
} from "./filePreview.ts";
describe("workspace file previews", () => {
it.each([
["zip", "archive", "application/zip"],
["jar", "archive", "application/java-archive"],
["tar", "archive", "application/x-tar"],
["gz", "archive", "application/gzip"],
["tgz", "archive", "application/gzip"],
["sqlite", "sqlite", "application/vnd.sqlite3"],
["sqlite3", "sqlite", "application/vnd.sqlite3"],
["db", "sqlite", "application/vnd.sqlite3"],
])("recognizes binary preview %s", (extension, kind, mimeType) => {
const name = `files#draft/sample.${extension.toUpperCase()}`;
for (const genericMime of [
"",
"application/octet-stream",
"binary/octet-stream",
"application/unknown",
" APPLICATION/UNKNOWN ; charset=utf-8",
"text/plain",
]) {
expect(filePreviewKind({ name, mimeType: genericMime })).toBe(kind);
}
expect(filePreviewKind({ name: "download", mimeType })).toBe(kind);
expect(isWorkspacePreviewEntryPath(name)).toBe(true);
expect(isWorkspacePreviewEntryPath(`${name}?download=1`)).toBe(false);
expect(hostPreviewMimeTypeFromExtension(`.${extension}`)).toBe(mimeType);
});
it("previews a TypeScript file the OS labels as MPEG transport stream as text", () => {
expect(filePreviewKind({ name: "clamp.ts", mimeType: "video/mp2t" })).toBe("text");
});
it("recognizes compound archives and MIME aliases", () => {
expect(filePreviewKind({ name: "archive.tar.gz" })).toBe("archive");
expect(filePreviewKind({ name: "download", mimeType: "application/x-gzip" })).toBe("archive");
expect(filePreviewKind({ name: "download", mimeType: "application/x-sqlite3" })).toBe("sqlite");
expect(filePreviewKind({ name: "misleading.zip", mimeType: "application/pdf" })).toBe("pdf");
});
it.each(["ttf", "otf", "woff", "woff2"])(
"previews %s fonts through signed host assets",
(extension) => {
expect(
filePreviewKind({ name: `sample.${extension}`, mimeType: "application/octet-stream" }),
).toBe("font");
expect(filePreviewKind({ name: "download", mimeType: `font/${extension}` })).toBe("font");
expect(isWorkspaceFontPreviewPath(`/tmp/sample.${extension.toUpperCase()}`)).toBe(true);
expect(isWorkspacePreviewEntryPath(`sample.${extension}`)).toBe(true);
expect(hostPreviewMimeTypeFromExtension(`.${extension}`)).toBe(`font/${extension}`);
expect(isWorkspaceFontPreviewPath(`sample.${extension}?download=1`)).toBe(false);
expect(filePreviewKind({ name: `sample.${extension}`, mimeType: "application/zip" })).toBe(
"archive",
);
},
);
it.each([
[
"quarterly-report.DOCX",
"docx",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
],
[
"finance#q4/operating-plan.xlsx",
"xlsx",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
],
[
"slides?review/quarterly-review.pptx",
"pptx",
"application/vnd.openxmlformats-officedocument.presentationml.presentation",
],
["notes.odt", "odt", "application/vnd.oasis.opendocument.text"],
["budget.ods", "ods", "application/vnd.oasis.opendocument.spreadsheet"],
["deck.odp", "odp", "application/vnd.oasis.opendocument.presentation"],
["notes.rtf", "rtf", "application/rtf"],
["guide.epub", "epub", "application/epub+zip"],
["analysis.ipynb", "ipynb", "application/x-ipynb+json"],
])("recognizes Office assets at literal path %s", (name, kind, mimeType) => {
expect(officePreviewKind({ name })).toBe(kind);
for (const genericMime of [
"",
"application/octet-stream",
"binary/octet-stream",
"application/unknown",
" APPLICATION/UNKNOWN ; charset=utf-8",
"text/plain",
]) {
expect(filePreviewKind({ name, mimeType: genericMime })).toBe(kind);
}
expect(isWorkspacePreviewEntryPath(name)).toBe(true);
expect(hostPreviewMimeTypeFromExtension(`.${kind}`)).toBe(mimeType);
expect(filePreviewKind({ name: "download", mimeType })).toBe(kind);
expect(filePreviewKind({ name, mimeType: "application/zip" })).toBe("archive");
});
// regression: #10311 previews classify by the literal filename, not URL-like suffixes
it.each([
"image.png.ts",
"image.png#notes.txt",
"image%2Epng",
"report.docx#notes.txt",
"report.xlsx?download=1",
"slides%2Epptx",
"report.docm",
"guide.epub?download=1",
"analysis.ipynb#notes.txt",
"report.odt.ts",
"slides.ppt",
])("rejects non-preview path %s", (path) => {
expect(isWorkspacePreviewEntryPath(path)).toBe(false);
});
it.each(["picture.bmp", "photo.heic", "photo.heif", "scan.tif", "scan.TIFF"])(
"recognizes image preview path %s",
(path) => {
expect(isWorkspaceImagePreviewPath(path)).toBe(true);
expect(isWorkspacePreviewEntryPath(path)).toBe(true);
},
);
it("serves audio in place from the host like video and browser documents", () => {
expect(hostPreviewMimeTypeFromExtension(".m4a")).toBe("audio/mp4");
expect(hostPreviewMimeTypeFromExtension(".weba")).toBe("audio/webm");
expect(hostPreviewMimeTypeFromExtension(".mp4")).toBe("video/mp4");
expect(hostPreviewMimeTypeFromExtension(".txt")).toBeNull();
expect(hostPreviewMimeTypeFromExtension(".constructor")).toBeNull();
expect(hostPreviewMimeTypeFromExtension(".toString")).toBeNull();
expect(hostPreviewMimeTypeFromExtension(".__proto__")).toBeNull();
expect(hostPreviewMimeTypeFromExtension(".webm-audio")).toBe("audio/webm");
});
});
describe("media path parsing", () => {
// regression: #9023 media kind comes from the decoded pathname, ignoring query and hash
it.each([
["https://cdn.example/clip.webm?download=1#t=2", "video"],
["https://example.com/download?name=recording.mp4", null],
["images%2Fresult%2Epng", "image"],
["images/result.png%23secret.txt", null],
["/tmp/tone.MP3", "audio"],
["./tone.wav", "audio"],
["tone.ogg", "audio"],
["tone.m4a", "audio"],
["tone.flac", "audio"],
["tone.aac", "audio"],
["tone.opus", "audio"],
["tone.webm-audio", "audio"],
["tone.webm", "video"],
["https://example.com/tone%2Emp3?download=1", "audio"],
["data.csv", null],
["report.pdf", null],
["report.docx", null],
["archive.zip", null],
])("classifies the decoded pathname of %s", (source, kind) => {
expect(mediaKindFromPath(source)).toBe(kind);
});
});
describe("attachment preview classification", () => {
it.each([
["example.json", "application/octet-stream", "text"],
["report.pdf", "application/pdf", "pdf"],
["page.HTML", "", "html"],
["diagram.mmd", "", "mermaid"],
["diagram.MERMAID", "text/plain", "mermaid"],
["download", "text/vnd.mermaid", "mermaid"],
["source-code.otf", "application/vnd.oasis.opendocument.formula-template", "font"],
["notes.rtf", "application/rtf", "rtf"],
["notes.rtf", "", "rtf"],
["download", "text/rtf", "rtf"],
["analysis.IPYNB", "application/json", "ipynb"],
["clip.weba", "", "audio"],
["image.bmp", "application/octet-stream", "image"],
["photo.heic", "application/octet-stream", "image"],
["scan.tiff", "application/octet-stream", "image"],
["recording.mp3", "", "audio"],
["recording.webm-audio", "", "audio"],
["recording.webm", "audio/webm", "audio"],
["payload", "application/problem+json", "text"],
["archive.zip", "application/zip", "archive"],
["misleading.json", "application/pdf", "pdf"],
["misleading.pdf", "application/zip", "archive"],
])("classifies %s (%s) as %s", (name, mimeType, expected) => {
expect(filePreviewKind({ name, mimeType })).toBe(expected);
});
it("rejects binary and invalid UTF-8 data", () => {
expect(() => decodeFilePreviewText(new Uint8Array([65, 0, 66]))).toThrow("binary");
expect(() => decodeFilePreviewText(new Uint8Array([255]))).toThrow("UTF-8");
});
it.each(["doc", "xls", "ppt", "7z", "rar"])(
"retains the binary fallback for %s, which opencode does not render",
(extension) => {
expect(filePreviewKind({ name: `sample.${extension}` })).toBe("unsupported");
},
);
it("does not corrupt a multi-byte character at the preview boundary", () => {
const bytes = new Uint8Array(FILE_TEXT_PREVIEW_MAX_BYTES + 1).fill(97);
bytes[FILE_TEXT_PREVIEW_MAX_BYTES - 1] = 0xe2;
bytes[FILE_TEXT_PREVIEW_MAX_BYTES] = 0x82;
const preview = decodeFilePreviewText(bytes);
expect(preview.truncated).toBe(true);
expect(preview.text.endsWith("�")).toBe(false);
expect(preview.text.length).toBe(FILE_TEXT_PREVIEW_MAX_BYTES - 1);
});
});