195 lines
6.2 KiB
TypeScript
195 lines
6.2 KiB
TypeScript
import { describe, expect, it, vi } from "vitest";
|
|
|
|
import {
|
|
createStorageScanService,
|
|
type StorageQuarantineAdapter,
|
|
type StorageScanner,
|
|
} from "./index.js";
|
|
|
|
const fixedNow = new Date("2026-02-03T04:05:06.000Z");
|
|
|
|
function createService(overrides: {
|
|
scanner?: StorageScanner;
|
|
quarantine?: StorageQuarantineAdapter;
|
|
} = {}) {
|
|
return createStorageScanService({
|
|
scanner: overrides.scanner ?? {
|
|
scanObject: vi.fn().mockResolvedValue({ verdict: "clean", engine: "clamav-1.4" }),
|
|
},
|
|
quarantine: overrides.quarantine,
|
|
now: () => fixedNow,
|
|
});
|
|
}
|
|
|
|
describe("createStorageScanService", () => {
|
|
it("returns clean scan verdicts with scannedAt and invokes the scanner once", async () => {
|
|
const scanObject = vi.fn().mockResolvedValue({ verdict: "clean", engine: "clamav-1.4" });
|
|
const service = createService({ scanner: { scanObject } });
|
|
|
|
await expect(
|
|
service.scanObject({ bucket: "uploads", key: "avatars/user.png" }),
|
|
).resolves.toEqual({
|
|
verdict: "clean",
|
|
bucket: "uploads",
|
|
key: "avatars/user.png",
|
|
scannedAt: fixedNow,
|
|
engine: "clamav-1.4",
|
|
});
|
|
|
|
expect(scanObject).toHaveBeenCalledOnce();
|
|
expect(scanObject).toHaveBeenCalledWith({ bucket: "uploads", key: "avatars/user.png" });
|
|
});
|
|
|
|
it("normalizes infected scanner verdicts with signature and quarantine metadata", async () => {
|
|
const scanObject = vi.fn().mockResolvedValue({
|
|
verdict: "infected",
|
|
engine: "clamav-1.4",
|
|
signature: "Eicar-Test-Signature",
|
|
quarantineKey: "quarantine/uploads/avatar.png",
|
|
});
|
|
const quarantineObject = vi.fn().mockResolvedValue({
|
|
bucket: "quarantine",
|
|
key: "uploads/avatar.png",
|
|
quarantineKey: "quarantine/uploads/avatar.png",
|
|
action: "moved",
|
|
});
|
|
const service = createService({
|
|
scanner: { scanObject },
|
|
quarantine: { quarantineObject },
|
|
});
|
|
|
|
await expect(
|
|
service.scanObject({ bucket: "uploads", key: "avatar.png" }),
|
|
).resolves.toEqual({
|
|
verdict: "infected",
|
|
bucket: "uploads",
|
|
key: "avatar.png",
|
|
scannedAt: fixedNow,
|
|
engine: "clamav-1.4",
|
|
signature: "Eicar-Test-Signature",
|
|
quarantineKey: "quarantine/uploads/avatar.png",
|
|
quarantine: {
|
|
bucket: "quarantine",
|
|
key: "uploads/avatar.png",
|
|
quarantineKey: "quarantine/uploads/avatar.png",
|
|
action: "moved",
|
|
},
|
|
});
|
|
|
|
expect(scanObject).toHaveBeenCalledOnce();
|
|
expect(quarantineObject).toHaveBeenCalledWith({
|
|
bucket: "uploads",
|
|
key: "avatar.png",
|
|
quarantineKey: "quarantine/uploads/avatar.png",
|
|
signature: "Eicar-Test-Signature",
|
|
});
|
|
});
|
|
|
|
it("returns redacted scanner error verdicts without copying arbitrary thrown fields", async () => {
|
|
const scannerError = Object.assign(
|
|
new Error("scanner failed credential=secret-token body=malware password=hunter2"),
|
|
{
|
|
name: "ClamAvUnavailable",
|
|
accessKeyId: "access-key",
|
|
secretAccessKey: "secret-key",
|
|
body: "file-body-secret",
|
|
$metadata: { httpStatusCode: 503, requestId: "scan-req-1" },
|
|
},
|
|
);
|
|
const service = createService({
|
|
scanner: { scanObject: vi.fn().mockRejectedValue(scannerError) },
|
|
});
|
|
|
|
const result = await service.scanObject({ bucket: "uploads", key: "avatar.png" });
|
|
|
|
expect(result).toEqual({
|
|
verdict: "error",
|
|
bucket: "uploads",
|
|
key: "avatar.png",
|
|
scannedAt: fixedNow,
|
|
error: {
|
|
code: "scanner_failed",
|
|
message: "Storage scanner failed while scanning object.",
|
|
upstream: {
|
|
name: "ClamAvUnavailable",
|
|
message: "scanner failed credential=[redacted] body=[redacted] password=[redacted]",
|
|
status: 503,
|
|
requestId: "scan-req-1",
|
|
},
|
|
},
|
|
});
|
|
const serialized = JSON.stringify(result);
|
|
expect(serialized).not.toContain("secret-token");
|
|
expect(serialized).not.toContain("file-body-secret");
|
|
expect(serialized).not.toContain("secret-key");
|
|
expect(serialized).not.toContain("hunter2");
|
|
});
|
|
|
|
it("rejects invalid empty bucket or key before invoking the scanner", async () => {
|
|
const scanObject = vi.fn();
|
|
const service = createService({ scanner: { scanObject } });
|
|
|
|
await expect(service.scanObject({ bucket: "", key: "avatar.png" })).resolves.toMatchObject({
|
|
verdict: "error",
|
|
key: "avatar.png",
|
|
error: {
|
|
code: "invalid_target",
|
|
message: "Storage scan target bucket and key must be non-empty strings.",
|
|
},
|
|
});
|
|
|
|
await expect(service.scanObject({ bucket: "uploads", key: " " })).resolves.toMatchObject({
|
|
verdict: "error",
|
|
bucket: "uploads",
|
|
error: { code: "invalid_target" },
|
|
});
|
|
|
|
expect(scanObject).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("returns redacted quarantine failure diagnostics for infected objects", async () => {
|
|
const quarantineError = Object.assign(
|
|
new Error("copy failed authorization=BearerSecret body=infected-bytes"),
|
|
{
|
|
name: "QuarantineWriteFailed",
|
|
token: "BearerSecret",
|
|
responseBody: "infected-bytes",
|
|
$metadata: { httpStatusCode: 500, requestId: "quarantine-req-1" },
|
|
},
|
|
);
|
|
const service = createService({
|
|
scanner: {
|
|
scanObject: vi.fn().mockResolvedValue({
|
|
verdict: "infected",
|
|
signature: "Eicar-Test-Signature",
|
|
quarantineKey: "quarantine/avatar.png",
|
|
}),
|
|
},
|
|
quarantine: { quarantineObject: vi.fn().mockRejectedValue(quarantineError) },
|
|
});
|
|
|
|
const result = await service.scanObject({ bucket: "uploads", key: "avatar.png" });
|
|
|
|
expect(result).toEqual({
|
|
verdict: "error",
|
|
bucket: "uploads",
|
|
key: "avatar.png",
|
|
scannedAt: fixedNow,
|
|
error: {
|
|
code: "quarantine_failed",
|
|
message: "Storage quarantine failed for infected object.",
|
|
upstream: {
|
|
name: "QuarantineWriteFailed",
|
|
message: "copy failed authorization=[redacted] body=[redacted]",
|
|
status: 500,
|
|
requestId: "quarantine-req-1",
|
|
},
|
|
},
|
|
});
|
|
const serialized = JSON.stringify(result);
|
|
expect(serialized).not.toContain("BearerSecret");
|
|
expect(serialized).not.toContain("infected-bytes");
|
|
expect(serialized).not.toContain("responseBody");
|
|
});
|
|
});
|