291 lines
9.6 KiB
TypeScript
291 lines
9.6 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("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(), "toolctrl-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(), "toolctrl-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",
|
|
},
|
|
});
|
|
});
|
|
});
|