| |
| import fs from "node:fs/promises"; |
| import path from "node:path"; |
| import JSZip from "jszip"; |
| import { afterEach, describe, expect, expectTypeOf, it, vi } from "vitest"; |
| import { withTestDir } from "../test-helpers/temp-dir.js"; |
| import { MediaAttachmentCache } from "./attachments.js"; |
|
|
| const { buildRandomTempFilePathMock, readRemoteMediaBufferMock } = vi.hoisted(() => ({ |
| buildRandomTempFilePathMock: vi.fn(), |
| readRemoteMediaBufferMock: vi.fn(), |
| })); |
|
|
| vi.mock("../media/fetch.js", async () => { |
| const actual = await vi.importActual<typeof import("../media/fetch.js")>("../media/fetch.js"); |
| return { |
| ...actual, |
| readRemoteMediaBuffer: readRemoteMediaBufferMock, |
| }; |
| }); |
|
|
| vi.mock("../plugin-sdk/temp-path.js", async () => { |
| const actual = await vi.importActual<typeof import("../plugin-sdk/temp-path.js")>( |
| "../plugin-sdk/temp-path.js", |
| ); |
| return { |
| ...actual, |
| buildRandomTempFilePath: buildRandomTempFilePathMock, |
| }; |
| }); |
|
|
| const PNG_1X1 = Buffer.from( |
| "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR4nGNgYAAAAAMAASsJTYQAAAAASUVORK5CYII=", |
| "base64", |
| ); |
| const AMBIGUOUS_WEBM = Buffer.from("1a45dfa3874282847765626d", "hex"); |
|
|
| describe("media understanding attachment cache", () => { |
| afterEach(() => { |
| vi.restoreAllMocks(); |
| buildRandomTempFilePathMock.mockReset(); |
| readRemoteMediaBufferMock.mockReset(); |
| }); |
|
|
| it.each([ |
| { |
| name: "prefers local attachment bytes over conflicting declared MIME", |
| fileName: "photo.jpg", |
| buffer: PNG_1X1, |
| declaredMime: "application/pdf", |
| expected: { mime: "image/png", class: "image" }, |
| }, |
| { |
| name: "infers long UTF-8 text from a generically typed local attachment", |
| fileName: "notes", |
| buffer: Buffer.from("验证".repeat(700), "utf8"), |
| declaredMime: "application/octet-stream", |
| expected: { mime: "text/plain", class: "text" }, |
| }, |
| ])("$name", async (testCase) => { |
| await withTestDir({ prefix: "openclaw-media-cache-mime-local-" }, async (base) => { |
| const attachmentPath = path.join(base, testCase.fileName); |
| await fs.writeFile(attachmentPath, testCase.buffer); |
| const cache = new MediaAttachmentCache( |
| [{ index: 0, path: attachmentPath, mime: testCase.declaredMime }], |
| { localPathRoots: [base] }, |
| ); |
|
|
| const result = await cache.getBuffer({ |
| attachmentIndex: 0, |
| maxBytes: testCase.buffer.byteLength, |
| timeoutMs: 1000, |
| }); |
|
|
| expect(result.mime).toBe(testCase.expected.mime); |
| expect(result.classification).toEqual(testCase.expected); |
| expect(result.buffer).toEqual(testCase.buffer); |
| }); |
| }); |
|
|
| it("prefers remote attachment bytes over conflicting MIME metadata", async () => { |
| const url = "https://example.com/photo.jpg"; |
| readRemoteMediaBufferMock.mockResolvedValue({ |
| buffer: PNG_1X1, |
| contentType: "image/jpeg", |
| fileName: "photo.jpg", |
| }); |
| const cache = new MediaAttachmentCache([{ index: 0, url, mime: "application/pdf" }]); |
|
|
| const result = await cache.getBuffer({ |
| attachmentIndex: 0, |
| maxBytes: 1024, |
| timeoutMs: 1000, |
| }); |
|
|
| expect(result.mime).toBe("image/png"); |
| }); |
|
|
| it.each(["unchanged", "growing", "read-failure"] as const)( |
| "closes one bounded local read when the file is %s", |
| async (behavior) => { |
| await withTestDir({ prefix: "openclaw-media-cache-growth-" }, async (base) => { |
| const attachmentPath = path.join(base, "growing.png"); |
| await fs.writeFile(attachmentPath, PNG_1X1); |
| const maxBytes = PNG_1X1.length; |
| const open = fs.open.bind(fs); |
| let consumed = 0; |
| let opens = 0; |
| let closes = 0; |
| let grew = false; |
| const readError = new Error("synthetic read failure"); |
| const growBeforeRead = async () => { |
| if (behavior === "read-failure") { |
| throw readError; |
| } |
| if (behavior === "growing" && !grew) { |
| grew = true; |
| await fs.appendFile(attachmentPath, Buffer.alloc(4096)); |
| } |
| }; |
| vi.spyOn(fs, "open").mockImplementation(async (...args) => { |
| const handle = await open(...args); |
| opens += 1; |
| const close = handle.close.bind(handle); |
| vi.spyOn(handle, "close").mockImplementation(async () => { |
| closes += 1; |
| await close(); |
| }); |
| const read = handle.read.bind(handle); |
| vi.spyOn(handle, "read").mockImplementation(async (...readArgs) => { |
| await growBeforeRead(); |
| const result = await read(...readArgs); |
| consumed += result.bytesRead; |
| return result; |
| }); |
| const readFile = handle.readFile.bind(handle); |
| vi.spyOn(handle, "readFile").mockImplementation(async (...readArgs) => { |
| await growBeforeRead(); |
| const result = await readFile(...readArgs); |
| consumed += result.length; |
| return result; |
| }); |
| return handle; |
| }); |
| const cache = new MediaAttachmentCache([{ index: 0, path: attachmentPath }], { |
| localPathRoots: [base], |
| includeDefaultLocalPathRoots: false, |
| }); |
|
|
| const result = cache.getBuffer({ attachmentIndex: 0, maxBytes, timeoutMs: 1000 }); |
| if (behavior === "unchanged") { |
| await expect(result).resolves.toMatchObject({ buffer: PNG_1X1 }); |
| } else if (behavior === "growing") { |
| await expect(result).rejects.toMatchObject({ reason: "maxBytes" }); |
| } else { |
| await expect(result).rejects.toBe(readError); |
| } |
| expect(opens).toBe(1); |
| expect(closes).toBe(opens); |
| expect(consumed).toBe(behavior === "read-failure" ? 0 : maxBytes + Number(grew)); |
| }); |
| }, |
| ); |
|
|
| it.each(["local", "staged"] as const)( |
| "enforces a zero-byte path limit for %s files", |
| async (source) => { |
| expectTypeOf<Parameters<MediaAttachmentCache["getPath"]>[0]>().toEqualTypeOf<{ |
| attachmentIndex: number; |
| maxBytes: number; |
| timeoutMs: number; |
| }>(); |
| await withTestDir({ prefix: "openclaw-media-cache-path-limit-" }, async (base) => { |
| const attachmentPath = path.join(base, "photo.png"); |
| await fs.writeFile(attachmentPath, PNG_1X1); |
| buildRandomTempFilePathMock.mockReturnValue(path.join(base, "staged.png")); |
| readRemoteMediaBufferMock.mockResolvedValue({ buffer: PNG_1X1, fileName: "photo.png" }); |
| const attachment = |
| source === "local" |
| ? { index: 0, path: attachmentPath } |
| : { index: 0, url: "https://example.com/photo.png" }; |
| const cache = new MediaAttachmentCache([attachment], { localPathRoots: [base] }); |
| const request = { attachmentIndex: 0, maxBytes: PNG_1X1.length, timeoutMs: 1000 }; |
| try { |
| await expect(cache.getPath(request)).resolves.toHaveProperty("path"); |
| await expect(cache.getPath({ ...request, maxBytes: 0 })).rejects.toMatchObject({ |
| reason: "maxBytes", |
| }); |
| } finally { |
| await cache.cleanup(); |
| } |
| }); |
| }, |
| ); |
|
|
| it.each(["cache", "returned"] as const)( |
| "restages files after %s cleanup", |
| async (cleanupOwner) => { |
| await withTestDir({ prefix: "openclaw-media-cache-restage-" }, async (base) => { |
| buildRandomTempFilePathMock |
| .mockReturnValueOnce(path.join(base, "first.png")) |
| .mockReturnValueOnce(path.join(base, "second.png")); |
| readRemoteMediaBufferMock.mockResolvedValue({ buffer: PNG_1X1, fileName: "photo.png" }); |
| const cache = new MediaAttachmentCache([ |
| { index: 0, url: "https://example.com/photo.png" }, |
| ]); |
| const request = { attachmentIndex: 0, maxBytes: PNG_1X1.length, timeoutMs: 1000 }; |
| try { |
| const first = await cache.getPath(request); |
| await (cleanupOwner === "cache" ? cache.cleanup() : first.cleanup?.()); |
| await expect(fs.stat(first.path)).rejects.toMatchObject({ code: "ENOENT" }); |
| const second = await cache.getPath(request); |
| await expect(fs.readFile(second.path)).resolves.toEqual(PNG_1X1); |
| await first.cleanup?.(); |
| expect((await cache.getPath(request)).path).toBe(second.path); |
| expect(readRemoteMediaBufferMock).toHaveBeenCalledTimes(1); |
| } finally { |
| await cache.cleanup(); |
| } |
| expect(await fs.readdir(base)).toEqual([]); |
| }); |
| }, |
| ); |
|
|
| it("uses fetched audio metadata when declared MIME is stale for ambiguous WebM", async () => { |
| const url = "https://example.com/voice.webm"; |
| readRemoteMediaBufferMock.mockResolvedValue({ |
| buffer: AMBIGUOUS_WEBM, |
| contentType: "audio/webm", |
| fileName: "voice.webm", |
| }); |
| const cache = new MediaAttachmentCache([{ index: 0, url, mime: "application/pdf" }]); |
|
|
| const result = await cache.getBuffer({ |
| attachmentIndex: 0, |
| maxBytes: 1024, |
| timeoutMs: 1000, |
| }); |
|
|
| expect(result.mime).toBe("audio/webm"); |
| }); |
|
|
| it("uses fetched OOXML metadata to refine extensionless generic ZIP bytes", async () => { |
| const url = "https://example.com/download"; |
| const zip = new JSZip(); |
| zip.file("hello.txt", "hi"); |
| const buffer = await zip.generateAsync({ type: "nodebuffer" }); |
| const docxMime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"; |
| readRemoteMediaBufferMock.mockResolvedValue({ |
| buffer, |
| contentType: docxMime, |
| fileName: "download", |
| }); |
| const cache = new MediaAttachmentCache([{ index: 0, url, mime: "application/pdf" }]); |
|
|
| const result = await cache.getBuffer({ |
| attachmentIndex: 0, |
| maxBytes: 1024, |
| timeoutMs: 1000, |
| }); |
|
|
| expect(result.mime).toBe(docxMime); |
| }); |
|
|
| it("removes a partially staged attachment and preserves its write failure", async () => { |
| await withTestDir({ prefix: "openclaw-media-cache-write-failure-" }, async (base) => { |
| const stagedPath = path.join(base, "failed.png"); |
| const writeError = Object.assign(new Error("disk full"), { code: "ENOSPC" }); |
| const writeFile = fs.writeFile.bind(fs); |
| buildRandomTempFilePathMock.mockReturnValueOnce(stagedPath); |
| readRemoteMediaBufferMock.mockResolvedValue({ buffer: PNG_1X1, fileName: "photo.png" }); |
| vi.spyOn(fs, "writeFile").mockImplementationOnce(async (file) => { |
| await writeFile(file, PNG_1X1.subarray(0, 4)); |
| throw writeError; |
| }); |
| const cache = new MediaAttachmentCache([{ index: 0, url: "https://example.com/photo.png" }]); |
|
|
| await expect( |
| cache.getPath({ attachmentIndex: 0, maxBytes: 1024, timeoutMs: 1_000 }), |
| ).rejects.toBe(writeError); |
| await cache.cleanup(); |
|
|
| expect(await fs.readdir(base)).toEqual([]); |
| }); |
| }); |
|
|
| it("retries failed cleanup without losing earlier staging when a later attempt succeeds", async () => { |
| await withTestDir({ prefix: "openclaw-media-cache-cleanup-retry-" }, async (base) => { |
| const firstPath = path.join(base, "failed.png"); |
| const secondPath = path.join(base, "success.png"); |
| const writeError = Object.assign(new Error("disk full"), { code: "ENOSPC" }); |
| const cleanupError = Object.assign(new Error("permission denied"), { code: "EACCES" }); |
| const writeFile = fs.writeFile.bind(fs); |
| buildRandomTempFilePathMock.mockReturnValueOnce(firstPath).mockReturnValueOnce(secondPath); |
| readRemoteMediaBufferMock.mockResolvedValue({ buffer: PNG_1X1, fileName: "photo.png" }); |
| const writeFileSpy = vi.spyOn(fs, "writeFile").mockImplementationOnce(async (file) => { |
| await writeFile(file, PNG_1X1.subarray(0, 4)); |
| throw writeError; |
| }); |
| vi.spyOn(fs, "unlink").mockRejectedValueOnce(cleanupError); |
| const cache = new MediaAttachmentCache([{ index: 0, url: "https://example.com/photo.png" }]); |
| const request = { attachmentIndex: 0, maxBytes: 1024, timeoutMs: 1_000 }; |
|
|
| await expect(cache.getPath(request)).rejects.toBe(writeError); |
| expect(await fs.readdir(base)).toEqual(["failed.png"]); |
|
|
| const staged = await cache.getPath(request); |
| expect(staged.path).toBe(secondPath); |
| expect((await cache.getPath(request)).path).toBe(secondPath); |
| expect(writeFileSpy).toHaveBeenCalledTimes(2); |
| expect((await fs.readdir(base)).toSorted()).toEqual(["failed.png", "success.png"]); |
|
|
| await cache.cleanup(); |
|
|
| expect(await fs.readdir(base)).toEqual([]); |
| }); |
| }); |
| }); |
|
|
