483 lines
17 KiB
TypeScript
483 lines
17 KiB
TypeScript
import {
|
|
afterEach,
|
|
beforeEach,
|
|
describe,
|
|
expect,
|
|
it,
|
|
} from "@suaveplan/testing/runner";
|
|
import { GarageS3Fixture } from "./garage-s3-fixture.js";
|
|
|
|
type GarageCommand = string[];
|
|
type ExecResponse = { stdout: string; exitCode: number };
|
|
|
|
function makeGarageContainerFake(
|
|
portMap: Record<number, number> = { 3900: 9900, 3902: 9902 },
|
|
execResponses?: Partial<Record<string, ExecResponse>>
|
|
) {
|
|
const callLog: GarageCommand[] = [];
|
|
const stopped: boolean[] = [];
|
|
|
|
function defaultExec(cmd: GarageCommand): ExecResponse {
|
|
const sub = cmd[1];
|
|
if (sub === "status") {
|
|
return {
|
|
stdout: "ID\tStatus\tAddr\nabc123def456 alive 127.0.0.1:3901\n",
|
|
exitCode: 0,
|
|
};
|
|
}
|
|
if (sub === "key" && cmd[2] === "info") {
|
|
return {
|
|
stdout: "Key ID: GK1234567890\nSecret key: sk_abcdefghij\n",
|
|
exitCode: 0,
|
|
};
|
|
}
|
|
return { stdout: "", exitCode: 0 };
|
|
}
|
|
|
|
const fakeStarted = {
|
|
getMappedPort: (port: number) =>
|
|
portMap[port as keyof typeof portMap] ?? port,
|
|
stop: async () => void stopped.push(true),
|
|
exec: async (cmd: GarageCommand) => {
|
|
callLog.push(cmd);
|
|
const key = cmd.join(" ");
|
|
const resp = execResponses?.[key] ?? defaultExec(cmd);
|
|
return {
|
|
output: resp.stdout,
|
|
stdout: resp.stdout,
|
|
stderr: "",
|
|
exitCode: resp.exitCode,
|
|
};
|
|
},
|
|
};
|
|
|
|
const fakeContainer = {
|
|
withExposedPorts: function () {
|
|
return this;
|
|
},
|
|
withEnvironment: function () {
|
|
return this;
|
|
},
|
|
withWaitStrategy: function () {
|
|
return this;
|
|
},
|
|
withCopyContentToContainer: function () {
|
|
return this;
|
|
},
|
|
start: async () => fakeStarted,
|
|
};
|
|
|
|
return {
|
|
fakeContainer,
|
|
fakeStarted,
|
|
callLog,
|
|
stopped,
|
|
factory: (_img: string) => fakeContainer as never,
|
|
execFn: async (cmd: GarageCommand): Promise<ExecResponse> => {
|
|
callLog.push(cmd);
|
|
return execResponses?.[cmd.join(" ")] ?? defaultExec(cmd);
|
|
},
|
|
};
|
|
}
|
|
|
|
const ENV_KEYS = [
|
|
"GARAGE_S3_ENDPOINT",
|
|
"GARAGE_S3_ADMIN_ENDPOINT",
|
|
"GARAGE_S3_ACCESS_KEY_ID",
|
|
"GARAGE_S3_SECRET_ACCESS_KEY",
|
|
];
|
|
|
|
describe("GarageS3Fixture", () => {
|
|
beforeEach(() => {
|
|
for (const key of ENV_KEYS) delete process.env[key];
|
|
});
|
|
|
|
afterEach(() => {
|
|
for (const key of ENV_KEYS) delete process.env[key];
|
|
});
|
|
|
|
it("name property returns garage-s3", { timeout: 5000 }, () => {
|
|
const fixture = new GarageS3Fixture();
|
|
expect(fixture.name).toBe("garage-s3");
|
|
});
|
|
|
|
it("passthrough mode (all 4 vars set): returns config from env", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
process.env["GARAGE_S3_ENDPOINT"] = "http://localhost:3900";
|
|
process.env["GARAGE_S3_ADMIN_ENDPOINT"] = "http://localhost:3902";
|
|
process.env["GARAGE_S3_ACCESS_KEY_ID"] = "GK_ENV_KEY";
|
|
process.env["GARAGE_S3_SECRET_ACCESS_KEY"] = "sk_env_secret";
|
|
|
|
const fixture = new GarageS3Fixture();
|
|
const config = await fixture.start();
|
|
|
|
expect(config.endpoint).toBe("http://localhost:3900");
|
|
expect(config.adminEndpoint).toBe("http://localhost:3902");
|
|
expect(config.accessKeyId).toBe("GK_ENV_KEY");
|
|
expect(config.secretAccessKey).toBe("sk_env_secret");
|
|
expect(config.region).toBe("garage");
|
|
expect(config.bucket).toBe("test-bucket");
|
|
});
|
|
|
|
it("passthrough mode: stop is a no-op", { timeout: 30000 }, async () => {
|
|
process.env["GARAGE_S3_ENDPOINT"] = "http://localhost:3900";
|
|
process.env["GARAGE_S3_ADMIN_ENDPOINT"] = "http://localhost:3902";
|
|
process.env["GARAGE_S3_ACCESS_KEY_ID"] = "GK_ENV_KEY";
|
|
process.env["GARAGE_S3_SECRET_ACCESS_KEY"] = "sk_env_secret";
|
|
|
|
const fixture = new GarageS3Fixture();
|
|
await fixture.start();
|
|
await expect(fixture.stop()).resolves.toBeUndefined();
|
|
});
|
|
|
|
it("partial passthrough (3 of 4 vars): falls through to container mode", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
process.env["GARAGE_S3_ENDPOINT"] = "http://localhost:3900";
|
|
process.env["GARAGE_S3_ADMIN_ENDPOINT"] = "http://localhost:3902";
|
|
process.env["GARAGE_S3_ACCESS_KEY_ID"] = "GK_ENV_KEY";
|
|
// SECRET_ACCESS_KEY not set
|
|
|
|
const { factory, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
const config = await fixture.start();
|
|
expect(config.accessKeyId).toBe("GK1234567890");
|
|
});
|
|
|
|
it("container mode: full init sequence happy path", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
const config = await fixture.start();
|
|
|
|
expect(config.accessKeyId).toBe("GK1234567890");
|
|
expect(config.secretAccessKey).toBe("sk_abcdefghij");
|
|
expect(config.endpoint).toBe("http://localhost:9900");
|
|
expect(config.adminEndpoint).toBe("http://localhost:9902");
|
|
expect(config.bucket).toBe("test-bucket");
|
|
expect(config.region).toBe("garage");
|
|
});
|
|
|
|
it("container mode: init sequence runs 7 commands in order", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, callLog, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
|
|
expect(callLog).toHaveLength(7);
|
|
expect(callLog[0]?.[1]).toBe("status");
|
|
expect(callLog[1]?.[1]).toBe("layout");
|
|
expect(callLog[1]?.[2]).toBe("assign");
|
|
expect(callLog[2]?.[1]).toBe("layout");
|
|
expect(callLog[2]?.[2]).toBe("apply");
|
|
expect(callLog[3]?.[1]).toBe("bucket");
|
|
expect(callLog[3]?.[2]).toBe("create");
|
|
expect(callLog[4]?.[1]).toBe("key");
|
|
expect(callLog[4]?.[2]).toBe("create");
|
|
expect(callLog[5]?.[1]).toBe("bucket");
|
|
expect(callLog[5]?.[2]).toBe("allow");
|
|
expect(callLog[6]?.[1]).toBe("key");
|
|
expect(callLog[6]?.[2]).toBe("info");
|
|
});
|
|
|
|
it("node ID passed to layout assign", { timeout: 30000 }, async () => {
|
|
const { factory, callLog, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
|
|
const assignCmd = callLog[1];
|
|
expect(assignCmd).toContain("abc123def456");
|
|
});
|
|
|
|
it("bucket name used in bucket create and bucket allow", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, callLog, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
bucket: "my-custom-bucket",
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
|
|
expect(callLog[3]).toContain("my-custom-bucket");
|
|
expect(callLog[5]).toContain("my-custom-bucket");
|
|
});
|
|
|
|
it("healthCheck returns true via injected fetchFn", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
const healthy = await fixture.healthCheck();
|
|
expect(healthy).toBe(true);
|
|
});
|
|
|
|
it("healthCheck returns false via injected fetchFn (ok: false)", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, execFn } = makeGarageContainerFake();
|
|
let callCount = 0;
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => {
|
|
callCount++;
|
|
return { ok: callCount === 1 } as Response;
|
|
},
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
const healthy = await fixture.healthCheck();
|
|
expect(healthy).toBe(false);
|
|
});
|
|
|
|
it("healthCheck returns false when fetch throws", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, execFn } = makeGarageContainerFake();
|
|
let callCount = 0;
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => {
|
|
callCount++;
|
|
if (callCount > 1) throw new Error("ECONNREFUSED");
|
|
return { ok: true } as Response;
|
|
},
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
const healthy = await fixture.healthCheck();
|
|
expect(healthy).toBe(false);
|
|
});
|
|
|
|
it("healthCheck returns false when no container", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const fixture = new GarageS3Fixture();
|
|
const healthy = await fixture.healthCheck();
|
|
expect(healthy).toBe(false);
|
|
});
|
|
|
|
it("stop calls container.stop()", { timeout: 30000 }, async () => {
|
|
const { factory, stopped, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
await fixture.stop();
|
|
expect(stopped).toHaveLength(1);
|
|
});
|
|
|
|
it("stop when passthrough mode is a no-op", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
process.env["GARAGE_S3_ENDPOINT"] = "http://localhost:3900";
|
|
process.env["GARAGE_S3_ADMIN_ENDPOINT"] = "http://localhost:3902";
|
|
process.env["GARAGE_S3_ACCESS_KEY_ID"] = "GK_ENV_KEY";
|
|
process.env["GARAGE_S3_SECRET_ACCESS_KEY"] = "sk_env_secret";
|
|
|
|
const fixture = new GarageS3Fixture();
|
|
await fixture.start();
|
|
await expect(fixture.stop()).resolves.toBeUndefined();
|
|
});
|
|
|
|
it("stop when no container is a no-op", { timeout: 30000 }, async () => {
|
|
const fixture = new GarageS3Fixture();
|
|
await expect(fixture.stop()).resolves.toBeUndefined();
|
|
});
|
|
|
|
it("waitForHealth: throws on timeout when health never passes", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => ({ ok: false }) as Response,
|
|
healthTimeoutMs: 10,
|
|
healthPollIntervalMs: 5,
|
|
});
|
|
await expect(fixture.start()).rejects.toThrow(
|
|
/Health check timed out for fixture "garage-s3"/
|
|
);
|
|
});
|
|
|
|
it("image override: factory called with custom image", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const calledWith: string[] = [];
|
|
const { fakeContainer, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
image: "ghcr.io/deuxfleurs/garage:custom",
|
|
containerFactory: (img) => {
|
|
calledWith.push(img);
|
|
return fakeContainer as never;
|
|
},
|
|
execFn,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
expect(calledWith[0]).toBe("ghcr.io/deuxfleurs/garage:custom");
|
|
});
|
|
|
|
it("bucket override: reflected in init commands and returned config", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, callLog, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
bucket: "custom-bucket",
|
|
containerFactory: factory,
|
|
execFn,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
const config = await fixture.start();
|
|
|
|
expect(config.bucket).toBe("custom-bucket");
|
|
expect(callLog[3]).toContain("custom-bucket");
|
|
});
|
|
|
|
it("getExecFn: uses injected execFn when provided", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const called: string[][] = [];
|
|
const { factory } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn: async (cmd) => {
|
|
called.push(cmd);
|
|
if (cmd[1] === "status") {
|
|
return {
|
|
stdout: "ID\tStatus\tAddr\nabc123test alive 127.0.0.1\n",
|
|
exitCode: 0,
|
|
};
|
|
}
|
|
if (cmd[1] === "key" && cmd[2] === "info") {
|
|
return {
|
|
stdout: "Key ID: GK_TEST\nSecret key: sk_TEST\n",
|
|
exitCode: 0,
|
|
};
|
|
}
|
|
return { stdout: "", exitCode: 0 };
|
|
},
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
expect(called.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("getExecFn: falls back to container.exec when no execFn provided", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, callLog } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
healthTimeoutMs: 1000,
|
|
healthPollIntervalMs: 10,
|
|
});
|
|
await fixture.start();
|
|
expect(callLog.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("resolveContainerFactory: falls back to GenericContainer import", {
|
|
timeout: 60000,
|
|
}, async () => {
|
|
class Exposed extends GarageS3Fixture {
|
|
resolveFactory() {
|
|
return this.resolveContainerFactory();
|
|
}
|
|
}
|
|
const exposed = new Exposed();
|
|
const factory = await exposed.resolveFactory();
|
|
expect(typeof factory).toBe("function");
|
|
const container = factory("ghcr.io/deuxfleurs/garage:v2.0.0");
|
|
expect(container).toBeDefined();
|
|
});
|
|
|
|
it("start(): stops container and clears reference when waitForHealth throws", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
const { factory, stopped } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
fetchFn: async () => ({ ok: false }) as Response,
|
|
healthTimeoutMs: 10,
|
|
healthPollIntervalMs: 5,
|
|
});
|
|
|
|
await expect(fixture.start()).rejects.toThrow(
|
|
/Health check timed out for fixture "garage-s3"/
|
|
);
|
|
// Container must have been stopped and cleared to prevent leaks
|
|
expect(stopped).toHaveLength(1);
|
|
});
|
|
|
|
it("waitForHealth: uses GARAGE_S3_HEALTH_TIMEOUT_MS and GARAGE_S3_HEALTH_POLL_INTERVAL_MS constants when no options provided", {
|
|
timeout: 30000,
|
|
}, async () => {
|
|
// Create fixture without healthTimeoutMs / healthPollIntervalMs so the
|
|
// default-constant branches in waitForHealth() are taken.
|
|
const { factory, execFn } = makeGarageContainerFake();
|
|
const fixture = new GarageS3Fixture({
|
|
containerFactory: factory,
|
|
execFn,
|
|
// fetchFn returns ok:true on first call so health passes immediately
|
|
fetchFn: async () => ({ ok: true }) as Response,
|
|
// Intentionally omit healthTimeoutMs and healthPollIntervalMs
|
|
});
|
|
const config = await fixture.start();
|
|
expect(config.accessKeyId).toBe("GK1234567890");
|
|
});
|
|
});
|