672 lines
21 KiB
TypeScript
672 lines
21 KiB
TypeScript
import { afterEach, describe, expect, test } from "bun:test";
|
|
import { mkdtemp, rm } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import type { ApiRequestInit, ApiRequestOptions } from "../../lib/api";
|
|
import {
|
|
buildServices,
|
|
resolveBuildImages,
|
|
uploadWorkspaceSnapshot,
|
|
type ApiRequester,
|
|
TaskScheduler,
|
|
MAX_CONCURRENT_REQUESTS,
|
|
MAX_REQUESTS_PER_SECOND,
|
|
} from "../../lib/build";
|
|
import {
|
|
workspaceManifestDigest,
|
|
type WorkspaceSnapshot,
|
|
} from "../../lib/workspace";
|
|
import type { BuildRequest } from "../../shared/build-protocol";
|
|
|
|
const directories: string[] = [];
|
|
|
|
function emptySnapshot(): WorkspaceSnapshot {
|
|
const manifest = { version: 1 as const, files: [] };
|
|
return { manifest, digest: workspaceManifestDigest(manifest), blobs: [] };
|
|
}
|
|
|
|
function createSnapshotWithBlobs(
|
|
count: number,
|
|
blobSize: number,
|
|
): WorkspaceSnapshot {
|
|
const blobs = Array.from({ length: count }, (_, i) => {
|
|
const data = new Uint8Array(blobSize);
|
|
data.fill(i + 1);
|
|
const digest = `sha256:${"0".repeat(62)}${String(i + 1).padStart(2, "0")}`;
|
|
return {
|
|
digest: digest as import("../../shared/build-protocol").Sha256Digest,
|
|
data,
|
|
};
|
|
});
|
|
|
|
const manifest = {
|
|
version: 1 as const,
|
|
files: blobs
|
|
.map((blob, i) => ({
|
|
path: `file${i}.txt`,
|
|
type: "file" as const,
|
|
digest: blob.digest,
|
|
size: blob.data.byteLength,
|
|
mode: 0o644 as const,
|
|
}))
|
|
.sort((left, right) =>
|
|
Buffer.from(left.path).compare(Buffer.from(right.path)),
|
|
),
|
|
};
|
|
|
|
return {
|
|
manifest,
|
|
digest: workspaceManifestDigest(manifest),
|
|
blobs,
|
|
};
|
|
}
|
|
|
|
afterEach(async () => {
|
|
await Promise.all(
|
|
directories
|
|
.splice(0)
|
|
.map((path) => rm(path, { recursive: true, force: true })),
|
|
);
|
|
});
|
|
|
|
describe("authenticated build API pipeline", () => {
|
|
test("negotiates and uploads the manifest through resumable blob routes", async () => {
|
|
const snapshot = emptySnapshot();
|
|
const calls: Array<{
|
|
path: string;
|
|
init?: ApiRequestInit;
|
|
options?: ApiRequestOptions;
|
|
}> = [];
|
|
let negotiations = 0;
|
|
const request: ApiRequester = async <T>(
|
|
path: string,
|
|
init?: ApiRequestInit,
|
|
options?: ApiRequestOptions,
|
|
) => {
|
|
calls.push({ path, init, options });
|
|
if (path === "/snapshots/negotiate") {
|
|
negotiations += 1;
|
|
return (
|
|
negotiations === 1
|
|
? {
|
|
workspace: snapshot.digest,
|
|
missing: [snapshot.digest],
|
|
ready: false,
|
|
}
|
|
: { workspace: snapshot.digest, missing: [], ready: true }
|
|
) as T;
|
|
}
|
|
if (init?.method === "POST" && !path.endsWith("/complete"))
|
|
return { offset: 0, complete: false } as T;
|
|
if (init?.method === "PATCH")
|
|
return { offset: (init.body as Uint8Array).byteLength } as T;
|
|
return { complete: true } as T;
|
|
};
|
|
|
|
await uploadWorkspaceSnapshot(snapshot, request);
|
|
|
|
expect(
|
|
calls.map(({ path, init }) => [init?.method ?? "GET", path]),
|
|
).toEqual([
|
|
["POST", "/snapshots/negotiate"],
|
|
["POST", `/blobs/${encodeURIComponent(snapshot.digest)}/uploads`],
|
|
["PATCH", `/blobs/${encodeURIComponent(snapshot.digest)}/uploads`],
|
|
[
|
|
"POST",
|
|
`/blobs/${encodeURIComponent(snapshot.digest)}/uploads/complete`,
|
|
],
|
|
["POST", "/snapshots/negotiate"],
|
|
]);
|
|
expect(new Headers(calls[2]!.init?.headers).get("upload-offset")).toBe("0");
|
|
});
|
|
|
|
test("uses project-scoped URLs for every resumable blob upload endpoint", async () => {
|
|
const snapshot = emptySnapshot();
|
|
const project = "shop & staging";
|
|
const uploadPath = `/blobs/${encodeURIComponent(snapshot.digest)}/uploads`;
|
|
const calls: Array<{ method: string; path: string }> = [];
|
|
let negotiations = 0;
|
|
const request: ApiRequester = async <T>(
|
|
path: string,
|
|
init?: ApiRequestInit,
|
|
) => {
|
|
const url = new URL(path, "https://kuber.test");
|
|
const method = init?.method ?? "GET";
|
|
calls.push({ method, path });
|
|
|
|
if (url.pathname === "/snapshots/negotiate") {
|
|
negotiations += 1;
|
|
return (
|
|
negotiations === 1
|
|
? {
|
|
workspace: snapshot.digest,
|
|
missing: [snapshot.digest],
|
|
ready: false,
|
|
}
|
|
: { workspace: snapshot.digest, missing: [], ready: true }
|
|
) as T;
|
|
}
|
|
if (url.pathname === uploadPath && method === "POST")
|
|
return { offset: 0, complete: false } as T;
|
|
if (url.pathname === uploadPath && method === "PATCH")
|
|
return { offset: (init!.body as Uint8Array).byteLength } as T;
|
|
if (url.pathname === `${uploadPath}/complete` && method === "POST")
|
|
return { complete: true } as T;
|
|
throw new Error(`Unexpected request ${method} ${path}`);
|
|
};
|
|
|
|
await uploadWorkspaceSnapshot(
|
|
snapshot,
|
|
request,
|
|
undefined,
|
|
undefined,
|
|
project,
|
|
);
|
|
|
|
const projectQuery = `?project=${encodeURIComponent(project)}`;
|
|
expect(calls).toEqual([
|
|
{ method: "POST", path: "/snapshots/negotiate" },
|
|
{ method: "POST", path: `${uploadPath}${projectQuery}` },
|
|
{ method: "PATCH", path: `${uploadPath}${projectQuery}` },
|
|
{ method: "POST", path: `${uploadPath}/complete${projectQuery}` },
|
|
{ method: "POST", path: "/snapshots/negotiate" },
|
|
]);
|
|
});
|
|
|
|
describe("TaskScheduler", () => {
|
|
test("uses the production request limits", () => {
|
|
expect(MAX_CONCURRENT_REQUESTS).toBe(20);
|
|
expect(MAX_REQUESTS_PER_SECOND).toBe(40);
|
|
});
|
|
|
|
test("limits concurrent in-flight operations", async () => {
|
|
let maxInflight = 0;
|
|
let currentInflight = 0;
|
|
const scheduler = new TaskScheduler({
|
|
maxInflight: 5,
|
|
maxPerSecond: 100,
|
|
});
|
|
|
|
const tasks = Array.from({ length: 10 }, () =>
|
|
scheduler.run(async () => {
|
|
currentInflight++;
|
|
maxInflight = Math.max(maxInflight, currentInflight);
|
|
await Bun.sleep(10);
|
|
currentInflight--;
|
|
}),
|
|
);
|
|
|
|
await Promise.all(tasks);
|
|
expect(maxInflight).toBeLessThanOrEqual(5);
|
|
});
|
|
|
|
test("rate limits request starts to maxPerSecond", async () => {
|
|
const requestStarts: number[] = [];
|
|
let currentTime = 0;
|
|
const clock = { now: () => currentTime };
|
|
const sleep = async (ms: number) => {
|
|
currentTime += ms;
|
|
};
|
|
const scheduler = new TaskScheduler({
|
|
maxInflight: 100,
|
|
maxPerSecond: 4,
|
|
clock,
|
|
sleep,
|
|
});
|
|
|
|
const tasks = Array.from({ length: 8 }, () =>
|
|
scheduler.run(async () => {
|
|
requestStarts.push(currentTime);
|
|
}),
|
|
);
|
|
|
|
await Promise.all(tasks);
|
|
|
|
for (const start of requestStarts) {
|
|
expect(
|
|
requestStarts.filter(
|
|
(candidate) => candidate >= start && candidate < start + 1000,
|
|
).length,
|
|
).toBeLessThanOrEqual(4);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("concurrent blob uploads", () => {
|
|
test("uploads multiple blobs concurrently", async () => {
|
|
const snapshot = createSnapshotWithBlobs(5, 1024);
|
|
let negotiations = 0;
|
|
let inflight = 0;
|
|
let maxInflight = 0;
|
|
|
|
const request: ApiRequester = async <T>(
|
|
path: string,
|
|
init?: ApiRequestInit,
|
|
) => {
|
|
if (path === "/snapshots/negotiate") {
|
|
negotiations += 1;
|
|
return (
|
|
negotiations === 1
|
|
? {
|
|
workspace: snapshot.digest,
|
|
missing: snapshot.blobs.map((blob) => blob.digest),
|
|
ready: false,
|
|
}
|
|
: { workspace: snapshot.digest, missing: [], ready: true }
|
|
) as T;
|
|
}
|
|
inflight += 1;
|
|
maxInflight = Math.max(maxInflight, inflight);
|
|
await Bun.sleep(5);
|
|
inflight -= 1;
|
|
if (init?.method === "POST" && !path.endsWith("/complete"))
|
|
return { offset: 0, complete: false } as T;
|
|
if (init?.method === "PATCH") {
|
|
return { offset: (init.body as Uint8Array).byteLength } as T;
|
|
}
|
|
return { complete: true } as T;
|
|
};
|
|
|
|
await uploadWorkspaceSnapshot(
|
|
snapshot,
|
|
request,
|
|
undefined,
|
|
new TaskScheduler({ maxInflight: 5, maxPerSecond: 100 }),
|
|
);
|
|
|
|
expect(maxInflight).toBeGreaterThan(1);
|
|
expect(negotiations).toBe(2);
|
|
});
|
|
|
|
test("completes active blobs before initializing the full backlog", async () => {
|
|
const snapshot = createSnapshotWithBlobs(12, 1024);
|
|
const methods: string[] = [];
|
|
let negotiations = 0;
|
|
const request: ApiRequester = async <T>(
|
|
path: string,
|
|
init?: ApiRequestInit,
|
|
) => {
|
|
if (path === "/snapshots/negotiate") {
|
|
negotiations += 1;
|
|
return (
|
|
negotiations === 1
|
|
? {
|
|
workspace: snapshot.digest,
|
|
missing: snapshot.blobs.map((blob) => blob.digest),
|
|
ready: false,
|
|
}
|
|
: { workspace: snapshot.digest, missing: [], ready: true }
|
|
) as T;
|
|
}
|
|
methods.push(
|
|
path.endsWith("/complete") ? "complete" : (init?.method ?? "GET"),
|
|
);
|
|
if (init?.method === "POST" && !path.endsWith("/complete"))
|
|
return { offset: 0, complete: false } as T;
|
|
if (init?.method === "PATCH")
|
|
return { offset: (init.body as Uint8Array).byteLength } as T;
|
|
return { complete: true } as T;
|
|
};
|
|
|
|
await uploadWorkspaceSnapshot(
|
|
snapshot,
|
|
request,
|
|
undefined,
|
|
new TaskScheduler({ maxInflight: 4, maxPerSecond: 100 }),
|
|
);
|
|
|
|
expect(methods.indexOf("complete")).toBeLessThan(
|
|
methods.lastIndexOf("POST"),
|
|
);
|
|
});
|
|
|
|
test("inflight never exceeds configured maximum", async () => {
|
|
const snapshot = createSnapshotWithBlobs(30, 1024);
|
|
let currentInflight = 0;
|
|
let maxObservedInflight = 0;
|
|
const maxInflight = 10;
|
|
let negotiations = 0;
|
|
|
|
const request: ApiRequester = async <T>(
|
|
path: string,
|
|
init?: ApiRequestInit,
|
|
) => {
|
|
if (path === "/snapshots/negotiate") {
|
|
negotiations += 1;
|
|
return (
|
|
negotiations === 1
|
|
? {
|
|
workspace: snapshot.digest,
|
|
missing: snapshot.blobs.map((blob) => blob.digest),
|
|
ready: false,
|
|
}
|
|
: { workspace: snapshot.digest, missing: [], ready: true }
|
|
) as T;
|
|
}
|
|
currentInflight += 1;
|
|
maxObservedInflight = Math.max(maxObservedInflight, currentInflight);
|
|
await Bun.sleep(2);
|
|
currentInflight -= 1;
|
|
if (init?.method === "POST" && !path.endsWith("/complete"))
|
|
return { offset: 0, complete: false } as T;
|
|
if (init?.method === "PATCH") {
|
|
return { offset: (init.body as Uint8Array).byteLength } as T;
|
|
}
|
|
return { complete: true } as T;
|
|
};
|
|
|
|
await uploadWorkspaceSnapshot(
|
|
snapshot,
|
|
request,
|
|
undefined,
|
|
new TaskScheduler({ maxInflight, maxPerSecond: 1000 }),
|
|
);
|
|
|
|
expect(maxObservedInflight).toBeLessThanOrEqual(maxInflight);
|
|
});
|
|
|
|
test("request starts are rate-limited to maxPerSecond", async () => {
|
|
const snapshot = createSnapshotWithBlobs(8, 1024);
|
|
const requestStarts: Array<{ path: string; time: number }> = [];
|
|
let currentTime = 0;
|
|
const clock = { now: () => currentTime };
|
|
const sleep = async (ms: number) => {
|
|
currentTime += ms;
|
|
};
|
|
let negotiations = 0;
|
|
|
|
const request: ApiRequester = async <T>(
|
|
path: string,
|
|
init?: ApiRequestInit,
|
|
) => {
|
|
requestStarts.push({ path, time: currentTime });
|
|
if (path === "/snapshots/negotiate") {
|
|
negotiations += 1;
|
|
return (
|
|
negotiations === 1
|
|
? {
|
|
workspace: snapshot.digest,
|
|
missing: snapshot.blobs.map((blob) => blob.digest),
|
|
ready: false,
|
|
}
|
|
: { workspace: snapshot.digest, missing: [], ready: true }
|
|
) as T;
|
|
}
|
|
if (init?.method === "POST" && !path.endsWith("/complete")) {
|
|
return { offset: 0, complete: false } as T;
|
|
}
|
|
if (init?.method === "PATCH") {
|
|
return { offset: (init.body as Uint8Array).byteLength } as T;
|
|
}
|
|
if (path.endsWith("/complete")) {
|
|
return { complete: true } as T;
|
|
}
|
|
return { complete: true } as T;
|
|
};
|
|
|
|
const maxPerSecond = 4;
|
|
await uploadWorkspaceSnapshot(
|
|
snapshot,
|
|
request,
|
|
undefined,
|
|
new TaskScheduler({
|
|
maxInflight: 100,
|
|
maxPerSecond,
|
|
clock,
|
|
sleep,
|
|
}),
|
|
);
|
|
|
|
for (const { time } of requestStarts) {
|
|
expect(
|
|
requestStarts.filter(
|
|
({ time: candidate }) =>
|
|
candidate >= time && candidate < time + 1000,
|
|
).length,
|
|
).toBeLessThanOrEqual(maxPerSecond);
|
|
}
|
|
});
|
|
|
|
test("chunks of one blob remain ordered during concurrent uploads", async () => {
|
|
const blobSize = 25 * 1024 * 1024;
|
|
const snapshot = createSnapshotWithBlobs(3, blobSize);
|
|
const chunkOrders = new Map<string, number[]>();
|
|
let negotiations = 0;
|
|
|
|
const request: ApiRequester = async <T>(
|
|
path: string,
|
|
init?: ApiRequestInit,
|
|
) => {
|
|
if (path === "/snapshots/negotiate") {
|
|
negotiations += 1;
|
|
return (
|
|
negotiations === 1
|
|
? {
|
|
workspace: snapshot.digest,
|
|
missing: snapshot.blobs.map((blob) => blob.digest),
|
|
ready: false,
|
|
}
|
|
: { workspace: snapshot.digest, missing: [], ready: true }
|
|
) as T;
|
|
}
|
|
if (init?.method === "POST" && !path.endsWith("/complete")) {
|
|
return { offset: 0, complete: false } as T;
|
|
}
|
|
if (init?.method === "PATCH") {
|
|
const digest = decodeURIComponent(path.split("/")[2]!);
|
|
const offset = Number(
|
|
new Headers(init.headers).get("upload-offset") ?? "0",
|
|
);
|
|
const chunkIndex = Math.floor(offset / (8 * 1024 * 1024));
|
|
if (!chunkOrders.has(digest)) chunkOrders.set(digest, []);
|
|
chunkOrders.get(digest)!.push(chunkIndex);
|
|
return { offset: offset + (init.body as Uint8Array).byteLength } as T;
|
|
}
|
|
return { complete: true } as T;
|
|
};
|
|
|
|
await uploadWorkspaceSnapshot(
|
|
snapshot,
|
|
request,
|
|
undefined,
|
|
new TaskScheduler({ maxInflight: 3, maxPerSecond: 100 }),
|
|
);
|
|
|
|
for (const [, chunks] of chunkOrders) {
|
|
for (let i = 1; i < chunks.length; i++) {
|
|
expect(chunks[i]!).toBeGreaterThan(chunks[i - 1]!);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
test("submits, reconciles, reports logs, and returns the server image reference", async () => {
|
|
const root = await mkdtemp(join(tmpdir(), "kuber-build-api-"));
|
|
directories.push(root);
|
|
const git = Bun.spawn(["git", "init", "-q", root]);
|
|
expect(await git.exited).toBe(0);
|
|
const snapshot = emptySnapshot();
|
|
const calls: Array<{
|
|
path: string;
|
|
init?: ApiRequestInit;
|
|
options?: ApiRequestOptions;
|
|
}> = [];
|
|
let submitted: BuildRequest | undefined;
|
|
const output: string[] = [];
|
|
const request: ApiRequester = async <T>(
|
|
path: string,
|
|
init?: ApiRequestInit,
|
|
options?: ApiRequestOptions,
|
|
) => {
|
|
calls.push({ path, init, options });
|
|
if (path === "/snapshots/negotiate")
|
|
return { workspace: snapshot.digest, missing: [], ready: true } as T;
|
|
if (path === "/builds") {
|
|
submitted = init?.json as BuildRequest;
|
|
return {
|
|
version: 1,
|
|
id: submitted.id,
|
|
state: "queued",
|
|
createdAt: "2026-01-01T00:00:00Z",
|
|
} as T;
|
|
}
|
|
if (path.includes("/events"))
|
|
return [
|
|
{
|
|
type: "log",
|
|
id: submitted!.id,
|
|
sequence: 1,
|
|
message: "build log\n",
|
|
},
|
|
] as T;
|
|
if (path.endsWith("/reconcile"))
|
|
return {
|
|
version: 1,
|
|
id: submitted!.id,
|
|
state: "succeeded",
|
|
createdAt: "2026-01-01T00:00:00Z",
|
|
digest: `sha256:${"a".repeat(64)}`,
|
|
} as T;
|
|
if (path.endsWith("/result"))
|
|
return {
|
|
image: "registry.server/kuber/shop-web",
|
|
digest: `sha256:${"a".repeat(64)}`,
|
|
reference: `registry.server/kuber/shop-web@sha256:${"a".repeat(64)}`,
|
|
} as T;
|
|
throw new Error(`Unexpected request ${path}`);
|
|
};
|
|
|
|
const result = await buildServices(
|
|
"shop",
|
|
{
|
|
services: { web: { build: { context: ".", args: { MODE: "prod" } } } },
|
|
},
|
|
root,
|
|
{
|
|
progress: (message) => {
|
|
output.push(message);
|
|
},
|
|
},
|
|
{ request, snapshot, sleep: async () => {}, pollIntervalMs: 0 },
|
|
);
|
|
|
|
expect(submitted?.spec).toMatchObject({
|
|
architecture: "arm64",
|
|
context: ".",
|
|
buildArgs: ["MODE=prod"],
|
|
workspace: snapshot.digest,
|
|
});
|
|
expect(result).toEqual({
|
|
built: ["web"],
|
|
changed: ["web"],
|
|
images: {
|
|
web: `registry.server/kuber/shop-web@sha256:${"a".repeat(64)}`,
|
|
},
|
|
});
|
|
expect(output).toContain("build log");
|
|
expect(calls.find(({ path }) => path === "/builds")?.options).toEqual({
|
|
timeoutMs: 300_000,
|
|
});
|
|
expect(
|
|
calls
|
|
.filter(
|
|
({ path }) => path.includes("/events") || path.endsWith("/reconcile"),
|
|
)
|
|
.map(({ options }) => options),
|
|
).toEqual([
|
|
{ timeoutMs: 300_000 },
|
|
{ timeoutMs: 300_000 },
|
|
{ timeoutMs: 300_000 },
|
|
]);
|
|
expect(calls.some(({ path }) => path.endsWith("/result"))).toBe(true);
|
|
});
|
|
|
|
test("retries a timed out poll request with the build request timeout", async () => {
|
|
const root = await mkdtemp(join(tmpdir(), "kuber-build-api-"));
|
|
directories.push(root);
|
|
const git = Bun.spawn(["git", "init", "-q", root]);
|
|
expect(await git.exited).toBe(0);
|
|
const snapshot = emptySnapshot();
|
|
const pollCalls: Array<{ path: string; options?: ApiRequestOptions }> = [];
|
|
let buildId = "";
|
|
let eventRequests = 0;
|
|
const request: ApiRequester = async <T>(
|
|
path: string,
|
|
init?: ApiRequestInit,
|
|
options?: ApiRequestOptions,
|
|
) => {
|
|
if (path === "/snapshots/negotiate")
|
|
return { workspace: snapshot.digest, missing: [], ready: true } as T;
|
|
if (path === "/builds") {
|
|
const buildRequest = init?.json as BuildRequest | undefined;
|
|
if (!buildRequest) throw new Error("Expected build request");
|
|
buildId = buildRequest.id;
|
|
return {
|
|
version: 1,
|
|
id: buildId,
|
|
state: "queued",
|
|
createdAt: "2026-01-01T00:00:00Z",
|
|
} as T;
|
|
}
|
|
if (path.includes("/events")) {
|
|
pollCalls.push({ path, options });
|
|
eventRequests += 1;
|
|
if (eventRequests === 1)
|
|
throw new DOMException("request timed out", "TimeoutError");
|
|
return [] as T;
|
|
}
|
|
if (path.endsWith("/reconcile")) {
|
|
pollCalls.push({ path, options });
|
|
return {
|
|
version: 1,
|
|
id: buildId,
|
|
state: "succeeded",
|
|
createdAt: "2026-01-01T00:00:00Z",
|
|
digest: `sha256:${"a".repeat(64)}`,
|
|
} as T;
|
|
}
|
|
if (path.endsWith("/result"))
|
|
return {
|
|
image: "registry.server/kuber/shop-web",
|
|
digest: `sha256:${"a".repeat(64)}`,
|
|
reference: `registry.server/kuber/shop-web@sha256:${"a".repeat(64)}`,
|
|
} as T;
|
|
throw new Error(`Unexpected request ${path}`);
|
|
};
|
|
|
|
await buildServices(
|
|
"shop",
|
|
{ services: { web: { build: "." } } },
|
|
root,
|
|
undefined,
|
|
{ request, snapshot, sleep: async () => {}, pollIntervalMs: 0 },
|
|
);
|
|
|
|
expect(eventRequests).toBe(3);
|
|
expect(pollCalls).toEqual([
|
|
expect.objectContaining({ options: { timeoutMs: 300_000 } }),
|
|
expect.objectContaining({ options: { timeoutMs: 300_000 } }),
|
|
expect.objectContaining({ options: { timeoutMs: 300_000 } }),
|
|
expect.objectContaining({ options: { timeoutMs: 300_000 } }),
|
|
]);
|
|
});
|
|
|
|
test("no-build image resolution uses only the resolve route", async () => {
|
|
const calls: string[] = [];
|
|
const images = await resolveBuildImages(
|
|
"shop",
|
|
{ services: { web: { build: "." }, cache: { image: "redis" } } },
|
|
{
|
|
request: async <T>(path: string, init?: ApiRequestInit) => {
|
|
calls.push(`${init?.method}:${path}:${JSON.stringify(init?.json)}`);
|
|
return { reference: "registry/web@sha256:immutable" } as T;
|
|
},
|
|
},
|
|
);
|
|
expect(images).toEqual({ web: "registry/web@sha256:immutable" });
|
|
expect(calls).toEqual([
|
|
'POST:/images/resolve:{"project":"shop","service":"web"}',
|
|
]);
|
|
});
|
|
});
|