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

301 lines
10 KiB
TypeScript

import { describe, expect, it, vi } from "vitest";
import { mkdtemp, readFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import {
DeleteObjectCommand,
PutObjectCommand,
StorageAdapterError,
createLocalStorageAdapter,
createS3StorageAdapter,
type S3StorageAdapterConfig,
} from "./index.js";
const baseConfig: S3StorageAdapterConfig = {
endpoint: "https://s3.example.test",
region: "us-east-1",
bucket: "uploads",
accessKeyId: "access-key",
secretAccessKey: "secret-key",
};
describe("createS3StorageAdapter", () => {
it("sends PutObjectCommand input and returns object identity", async () => {
const send = vi.fn().mockResolvedValue({});
const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } });
await expect(
adapter.putObject({
key: "avatars/user.png",
body: "file contents",
contentType: "image/png",
cacheControl: "public, max-age=3600",
metadata: { tenant: "acme" },
}),
).resolves.toEqual({
bucket: "uploads",
key: "avatars/user.png",
publicUrl: null,
});
expect(send).toHaveBeenCalledOnce();
const command = send.mock.calls[0]?.[0];
expect(command).toBeInstanceOf(PutObjectCommand);
expect(command.input).toEqual({
Bucket: "uploads",
Key: "avatars/user.png",
Body: "file contents",
ContentType: "image/png",
CacheControl: "public, max-age=3600",
Metadata: { tenant: "acme" },
});
});
it("constructs public URLs by encoding key segments", async () => {
const adapter = createS3StorageAdapter({
...baseConfig,
publicBaseUrl: "https://cdn.example.test/assets/",
client: { send: vi.fn().mockResolvedValue({}) },
});
await expect(
adapter.putObject({
key: "tenant one/folder/avatar #1.png",
body: new Uint8Array([1, 2, 3]),
}),
).resolves.toMatchObject({
publicUrl:
"https://cdn.example.test/assets/tenant%20one/folder/avatar%20%231.png",
});
});
it("throws redacted diagnostics for missing required config", () => {
const config = {
endpoint: "",
region: "us-east-1",
bucket: "",
accessKeyId: "provided-access-key",
secretAccessKey: "provided-secret-key",
} satisfies S3StorageAdapterConfig;
expect(() => createS3StorageAdapter(config)).toThrow(StorageAdapterError);
try {
createS3StorageAdapter(config);
} catch (error) {
expect(error).toBeInstanceOf(StorageAdapterError);
const adapterError = error as StorageAdapterError;
expect(adapterError.code).toBe("config_missing");
expect(adapterError.details).toEqual({
operation: "createS3StorageAdapter",
missingFields: ["endpoint", "bucket"],
});
expect(JSON.stringify(adapterError)).not.toContain("provided-access-key");
expect(JSON.stringify(adapterError)).not.toContain("provided-secret-key");
}
});
it("wraps upstream send failures with redacted request metadata", async () => {
const upstreamError = Object.assign(
new Error("signature mismatch for credential secret-key"),
{
name: "SignatureDoesNotMatch",
$metadata: { httpStatusCode: 403, requestId: "req-123" },
responseBody: "full upstream response should not be copied",
},
);
const adapter = createS3StorageAdapter({
...baseConfig,
client: { send: vi.fn().mockRejectedValue(upstreamError) },
});
await expect(
adapter.putObject({ key: "private/report.pdf", body: "body-secret" }),
).rejects.toMatchObject({
name: "StorageAdapterError",
code: "put_failed",
details: {
operation: "putObject",
bucket: "uploads",
key: "private/report.pdf",
upstream: {
name: "SignatureDoesNotMatch",
message: "signature mismatch for credential [redacted]",
status: 403,
requestId: "req-123",
},
},
});
});
it("does not copy credentials, session tokens, or request bodies into structured diagnostics", async () => {
const upstreamError = Object.assign(new Error("upstream failed"), {
accessKeyId: "access-key",
secretAccessKey: "secret-key",
sessionToken: "session-token",
body: "request-body",
$metadata: { httpStatusCode: 500, requestId: "req-500" },
});
const adapter = createS3StorageAdapter({
...baseConfig,
sessionToken: "session-token",
client: { send: vi.fn().mockRejectedValue(upstreamError) },
});
try {
await adapter.putObject({ key: "upload.txt", body: "request-body" });
throw new Error("expected putObject to fail");
} catch (error) {
expect(error).toBeInstanceOf(StorageAdapterError);
const serializedDetails = JSON.stringify((error as StorageAdapterError).details);
expect(serializedDetails).not.toContain("access-key");
expect(serializedDetails).not.toContain("secret-key");
expect(serializedDetails).not.toContain("session-token");
expect(serializedDetails).not.toContain("request-body");
expect(serializedDetails).not.toContain("responseBody");
}
});
it("sends DeleteObjectCommand input and defaults to the configured bucket", async () => {
const send = vi.fn().mockResolvedValue({});
const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } });
await expect(
adapter.deleteObject({ key: "exports/job-123.csv" }),
).resolves.toEqual({
bucket: "uploads",
key: "exports/job-123.csv",
});
expect(send).toHaveBeenCalledOnce();
const command = send.mock.calls[0]?.[0];
expect(command).toBeInstanceOf(DeleteObjectCommand);
expect(command.input).toEqual({
Bucket: "uploads",
Key: "exports/job-123.csv",
});
});
it("allows deleteObject to target an explicit bucket", async () => {
const send = vi.fn().mockResolvedValue({});
const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } });
await expect(
adapter.deleteObject({ bucket: "archive", key: "exports/job-123.csv" }),
).resolves.toEqual({
bucket: "archive",
key: "exports/job-123.csv",
});
expect(send.mock.calls[0]?.[0].input).toEqual({
Bucket: "archive",
Key: "exports/job-123.csv",
});
});
it("forwards an abort signal to bounded S3 deletions", async () => {
const send = vi.fn().mockResolvedValue({});
const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } });
const controller = new AbortController();
await adapter.deleteObject({ key: "exports/job-123.csv", signal: controller.signal });
expect(send).toHaveBeenCalledWith(expect.any(DeleteObjectCommand), { abortSignal: controller.signal });
});
it("rejects invalid delete keys and buckets before sending to S3", async () => {
const send = vi.fn().mockResolvedValue({});
const adapter = createS3StorageAdapter({ ...baseConfig, client: { send } });
await expect(adapter.deleteObject({ key: " " })).rejects.toMatchObject({
code: "invalid_key",
details: { operation: "deleteObject", bucket: "uploads", key: " " },
});
await expect(
adapter.deleteObject({ bucket: " ", key: "exports/job-123.csv" }),
).rejects.toMatchObject({
code: "invalid_bucket",
details: {
operation: "deleteObject",
bucket: " ",
key: "exports/job-123.csv",
},
});
expect(send).not.toHaveBeenCalled();
});
it("wraps deleteObject failures with redacted upstream diagnostics", async () => {
const upstreamError = Object.assign(
new Error("delete failed token abc123 credential secret-key"),
{
name: "AccessDenied",
$metadata: { httpStatusCode: 403, requestId: "req-delete" },
body: "delete-request-body",
},
);
const adapter = createS3StorageAdapter({
...baseConfig,
client: { send: vi.fn().mockRejectedValue(upstreamError) },
});
try {
await adapter.deleteObject({ key: "exports/job-123.csv" });
throw new Error("expected deleteObject to fail");
} catch (error) {
expect(error).toBeInstanceOf(StorageAdapterError);
const adapterError = error as StorageAdapterError;
expect(adapterError).toMatchObject({
code: "delete_failed",
details: {
operation: "deleteObject",
bucket: "uploads",
key: "exports/job-123.csv",
upstream: {
name: "AccessDenied",
message: "delete failed token [redacted] credential [redacted]",
status: 403,
requestId: "req-delete",
},
},
});
expect(JSON.stringify(adapterError.details)).not.toContain("abc123");
expect(JSON.stringify(adapterError.details)).not.toContain("secret-key");
expect(JSON.stringify(adapterError.details)).not.toContain("delete-request-body");
}
});
});
describe("createLocalStorageAdapter", () => {
it("stores objects under the configured bucket root and returns a public URL", async () => {
const rootDir = await mkdtemp(join(tmpdir(), "hivegrid-storage-"));
const adapter = createLocalStorageAdapter({
rootDir,
bucket: "uploads",
publicBaseUrl: "http://localhost:3000/storage",
});
await expect(adapter.putObject({ key: "tenants/acme/avatar.png", body: "image" })).resolves.toEqual({
bucket: "uploads",
key: "tenants/acme/avatar.png",
publicUrl: "http://localhost:3000/storage/uploads/tenants/acme/avatar.png",
});
await expect(readFile(join(rootDir, "uploads", "tenants", "acme", "avatar.png"), "utf8")).resolves.toBe("image");
});
it("rejects local object keys that escape the storage root", async () => {
const rootDir = await mkdtemp(join(tmpdir(), "hivegrid-storage-"));
const adapter = createLocalStorageAdapter({ rootDir, bucket: "uploads" });
await expect(adapter.putObject({ key: "../secret.txt", body: "secret" })).rejects.toMatchObject({
code: "invalid_key",
details: {
operation: "normalizeLocalObjectKey",
key: "../secret.txt",
},
});
});
});