Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/storage/src/scan/index.test.ts
T

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");
});
});