@jterrazz/test 16.1.1 → 18.0.0

package/dist/shared-testcontainers.adapter.js

@@ -0,0 +1,306 @@
+import { t as isRecord } from "./shared-json-shape.js";
+import { n as refusal, t as invariant } from "./shared-refusal.js";
+import { t as listenedPort } from "./shared-listened-port.js";
+import { t as loadPeer } from "./shared-peer.js";
+import { execSync } from "node:child_process";
+import { once } from "node:events";
+import { createServer } from "node:http";
+import { text } from "node:stream/consumers";
+import { hostname } from "node:os";
+//#region src/services/containers/docker-cli.ts
+const DEFAULT_TIMEOUT = 1e4;
+/** How every refusal of a run that asked for Docker names a daemon that did not answer. */
+const DOCKER_ABSENT = "no Docker daemon answered";
+/** Docker-aware mode reads what the daemon answers: a run where none answers is refused, never passed. */
+function requireDockerDaemon() {
+	try {
+		execSync("docker version --format \"{{.Server.Version}}\"", {
+			stdio: "ignore",
+			timeout: DEFAULT_TIMEOUT
+		});
+	} catch (error) {
+		throw new Error(refusal({
+			fix: "start Docker (Docker Desktop, OrbStack, colima or another) and run again",
+			found: `specification.cli({ docker }) asked for Docker, and ${DOCKER_ABSENT}`,
+			read: "docs/guides/cli-specs.md#docker-aware-mode",
+			why: "Docker-aware mode reads the containers a run spawned, so it needs a Docker daemon."
+		}), { cause: error });
+	}
+}
+function findContainersByLabel(key, value) {
+	try {
+		return execSync(`docker ps -aq -f label=${key}=${value}`, {
+			encoding: "utf8",
+			timeout: DEFAULT_TIMEOUT
+		}).split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+	} catch {
+		return [];
+	}
+}
+/** A field of a value read off docker's JSON or a failed process: absent wherever the value does not hold it. */
+function fieldOf(value, ...keys) {
+	if (typeof value !== "object" || value === null) return;
+	const key = keys.find((candidate) => candidate in value);
+	return key === void 0 ? void 0 : Reflect.get(value, key);
+}
+const streamOf = (error, key) => {
+	const stream = fieldOf(error, key);
+	return typeof stream === "string" ? stream : void 0;
+};
+function inspectContainer(id) {
+	const raw = execSync(`docker inspect ${id}`, {
+		encoding: "utf8",
+		timeout: DEFAULT_TIMEOUT
+	});
+	const parsed = JSON.parse(raw);
+	if (!Array.isArray(parsed)) return parsed;
+	return parsed[0];
+}
+function removeContainers(ids) {
+	if (ids.length === 0) return;
+	try {
+		execSync(`docker rm -f ${ids.join(" ")}`, {
+			encoding: "utf8",
+			stdio: "pipe",
+			timeout: DEFAULT_TIMEOUT
+		});
+	} catch {}
+}
+function containerLogs(id) {
+	try {
+		return execSync(`docker logs ${id}`, {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			timeout: DEFAULT_TIMEOUT
+		});
+	} catch (error) {
+		return streamOf(error, "stdout") ?? streamOf(error, "stderr") ?? "";
+	}
+}
+function readContainerFile(id, path) {
+	return execSync(`docker exec ${id} cat ${JSON.stringify(path)}`, {
+		encoding: "utf8",
+		timeout: DEFAULT_TIMEOUT
+	});
+}
+function execInContainer(id, argv) {
+	try {
+		const quoted = argv.map((a) => JSON.stringify(a)).join(" ");
+		return {
+			exitCode: 0,
+			stderr: "",
+			stdout: execSync(`docker exec ${id} ${quoted}`, {
+				encoding: "utf8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				timeout: DEFAULT_TIMEOUT
+			})
+		};
+	} catch (error) {
+		const status = fieldOf(error, "status");
+		return {
+			exitCode: typeof status === "number" ? status : 1,
+			stderr: streamOf(error, "stderr") ?? (error instanceof Error ? error.message : ""),
+			stdout: streamOf(error, "stdout") ?? ""
+		};
+	}
+}
+//#endregion
+//#region src/services/containers/run-containers.ts
+function canonical(value) {
+	return isRecord(value) ? Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, canonical(entry)])) : value;
+}
+function keyOf(request) {
+	return JSON.stringify(canonical(request));
+}
+var RunContainers = class {
+	started = /* @__PURE__ */ new Map();
+	create;
+	ready;
+	/** `ready`'s rejection is the one answer every request gets, and no container is created. */
+	constructor(create, ready = async () => {}) {
+		this.create = create;
+		this.ready = ready;
+	}
+	async acquire(request) {
+		const key = keyOf(request);
+		let pending = this.started.get(key);
+		if (pending === void 0) {
+			pending = this.start(key, request);
+			this.started.set(key, pending);
+		}
+		const container = await pending;
+		return {
+			host: container.getHost(),
+			key,
+			port: container.getMappedPort(request.port)
+		};
+	}
+	async logs(key, since) {
+		const pending = this.started.get(key);
+		if (pending === void 0) return "";
+		return await (await pending).getLogs(since);
+	}
+	async stop() {
+		const pending = [...this.started.values()];
+		this.started.clear();
+		await Promise.allSettled(pending.map(async (starting) => {
+			await (await starting).stop();
+		}));
+	}
+	async start(key, request) {
+		try {
+			await this.ready();
+			const container = this.create(request);
+			await container.start();
+			return container;
+		} catch (error) {
+			this.started.delete(key);
+			throw error;
+		}
+	}
+};
+function field(value, name) {
+	if (typeof value !== "object" || value === null) return;
+	return Reflect.get(value, name);
+}
+function isContainerRequest(value) {
+	return typeof field(value, "image") === "string" && typeof field(value, "port") === "number";
+}
+async function respond(containers, request, response) {
+	const url = new URL(request.url ?? "/", "http://run");
+	try {
+		if (request.method === "POST" && url.pathname === "/containers") {
+			const asked = JSON.parse(await text(request));
+			if (!isContainerRequest(asked)) throw invariant(`a worker asked for ${JSON.stringify(asked)}, no container request`);
+			const address = await containers.acquire(asked);
+			response.writeHead(200, { "content-type": "application/json" });
+			response.end(JSON.stringify(address));
+			return;
+		}
+		if (request.method === "GET" && url.pathname === "/logs") {
+			response.writeHead(200, { "content-type": "text/plain" });
+			const key = url.searchParams.get("key") ?? "";
+			const since = url.searchParams.get("since");
+			const moment = since === null ? void 0 : new Date(Number(since));
+			response.end(await containers.logs(key, moment));
+			return;
+		}
+		response.writeHead(404).end();
+	} catch (error) {
+		response.writeHead(500, { "content-type": "application/json" });
+		response.end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+	}
+}
+async function serveContainers(containers) {
+	const server = createServer((request, response) => {
+		respond(containers, request, response);
+	});
+	return {
+		close: async () => {
+			server.close();
+			await once(server, "close");
+		},
+		url: `http://127.0.0.1:${await listenedPort(server, { host: "127.0.0.1" })}`
+	};
+}
+//#endregion
+//#region src/services/containers/testcontainers.adapter.ts
+const CONTAINER_LABEL = "com.jterrazz.test";
+const REUSED_LABEL = "com.jterrazz.test.reuse";
+/** `<host>:<pid>`: a sweep removes the container once that process is dead, whatever reaper session holds it. */
+const OWNER_LABEL = "com.jterrazz.test.owner";
+function processOwner() {
+	return `${hostname()}:${process.pid}`;
+}
+/** Never on CI, where a run starts from nothing and leaves nothing. */
+function reuseEnabled(env) {
+	const onCi = env.CI !== void 0 && env.CI !== "" && env.CI !== "false";
+	return env.TESTCONTAINERS_REUSE_ENABLE === "true" && !onCi;
+}
+/** A reused container names no owner: its definition hash must not change with the process asking. */
+function containerLabels(reuse, owner) {
+	return reuse ? {
+		[CONTAINER_LABEL]: "true",
+		[REUSED_LABEL]: "true"
+	} : {
+		[CONTAINER_LABEL]: "true",
+		[OWNER_LABEL]: owner
+	};
+}
+async function loadTestcontainers() {
+	return await loadPeer("testcontainers", "a declared service", async () => await import("testcontainers"));
+}
+var TestcontainersAdapter = class {
+	image;
+	containerPort;
+	env;
+	command;
+	tmpfs;
+	reuse;
+	container = null;
+	peer;
+	constructor(options, peer = loadTestcontainers) {
+		this.peer = peer;
+		this.image = options.image;
+		this.containerPort = options.port;
+		this.env = options.env ?? {};
+		this.command = options.command;
+		this.tmpfs = options.tmpfs;
+		this.reuse = options.reuse ?? reuseEnabled(process.env);
+	}
+	async start() {
+		const { GenericContainer, Wait } = await this.peer();
+		let builder = new GenericContainer(this.image).withExposedPorts(this.containerPort).withLabels(containerLabels(this.reuse, processOwner()));
+		for (const [key, value] of Object.entries(this.env)) builder = builder.withEnvironment({ [key]: value });
+		if (this.command !== void 0) builder = builder.withCommand(this.command);
+		if (this.tmpfs !== void 0) builder = builder.withTmpFs(this.tmpfs);
+		if (this.image.startsWith("postgres")) builder = builder.withWaitStrategy(Wait.forLogMessage(/database system is ready to accept connections/u, 2));
+		if (this.reuse) builder = builder.withReuse();
+		this.container = await builder.start();
+	}
+	async stop() {
+		if (this.container && !this.reuse) {
+			await this.container.stop();
+			this.container = null;
+		}
+	}
+	getMappedPort(containerPort) {
+		if (!this.container) throw invariant("a container was read before it started");
+		return this.container.getMappedPort(containerPort);
+	}
+	getHost() {
+		if (!this.container) throw invariant("a container was read before it started");
+		return this.container.getHost();
+	}
+	getConnectionString() {
+		return `${this.getHost()}:${this.getMappedPort(this.containerPort)}`;
+	}
+	async getLogs(since) {
+		if (!this.container) return "";
+		const stream = await this.container.logs(since === void 0 ? void 0 : { since: since.getTime() / 1e3 });
+		return await new Promise((resolve) => {
+			let output = "";
+			stream.on("data", (chunk) => {
+				output += Buffer.isBuffer(chunk) ? chunk.toString() : String(chunk);
+			});
+			stream.on("end", () => {
+				resolve(output);
+			});
+			setTimeout(() => {
+				resolve(output);
+			}, 1e3);
+		});
+	}
+};
+//#endregion
+export { field as a, containerLogs as c, findContainersByLabel as d, inspectContainer as f, requireDockerDaemon as h, RunContainers as i, execInContainer as l, removeContainers as m, REUSED_LABEL as n, serveContainers as o, readContainerFile as p, TestcontainersAdapter as r, DOCKER_ABSENT as s, OWNER_LABEL as t, fieldOf as u };
+
+//# sourceMappingURL=shared-testcontainers.adapter.js.map

package/dist/shared-tokens.js

@@ -0,0 +1,55 @@
+//#region lint/kit/project/tokens.ts
+const TOKEN_KINDS = [
+	"any",
+	"base64",
+	"date",
+	"duration",
+	"email",
+	"float",
+	"hex",
+	"int",
+	"ip",
+	"iso8601",
+	"number",
+	"path",
+	"port",
+	"semver",
+	"sha",
+	"string",
+	"time",
+	"ulid",
+	"url",
+	"uuid",
+	"workdir"
+];
+const VALID_TOKEN = /^[A-Za-z][A-Za-z0-9]*(?:#[\w.-]+)?$/u;
+const BRACE_BLOCK = /\{\{[^{}]*\}\}/gu;
+const LEADING_WORD = /^[A-Za-z][A-Za-z0-9]*/u;
+const KNOWN = new Set(TOKEN_KINDS);
+function verdictOf(inner) {
+	if (VALID_TOKEN.test(inner)) {
+		const [kind = ""] = inner.split("#");
+		return KNOWN.has(kind) ? "known" : "unknown";
+	}
+	const [word = ""] = LEADING_WORD.exec(inner) ?? [];
+	return KNOWN.has(word) ? "malformed" : void 0;
+}
+function tokensOf(text, verdict) {
+	return text.split("\n").flatMap((lineText, index) => [...lineText.matchAll(BRACE_BLOCK)].flatMap(([token]) => verdictOf(token.slice(2, -2)) === verdict ? [{
+		line: index + 1,
+		token
+	}] : []));
+}
+function findUnknownTokens(text) {
+	return tokensOf(text, "unknown");
+}
+function findMalformedRefs(text) {
+	return tokensOf(text, "malformed");
+}
+function findKnownTokens(text) {
+	return tokensOf(text, "known");
+}
+//#endregion
+export { findUnknownTokens as i, findKnownTokens as n, findMalformedRefs as r, TOKEN_KINDS as t };
+
+//# sourceMappingURL=shared-tokens.js.map

package/dist/shared-yaml-document.js

@@ -0,0 +1,119 @@
+import { LineCounter, Scalar, Scalar as Scalar$1, isMap, isNode, isNode as isNode$1, isPair, isScalar, isSeq, parseDocument, visit } from "yaml";
+//#region lint/kit/project/yaml-document.ts
+function nodePairs(map) {
+	return map.items.filter((pair) => isNode(pair.key) && (pair.value === null || isNode(pair.value)));
+}
+function nodeItems(seq) {
+	return seq.items.filter((item) => isNode(item));
+}
+const KEY_LINE = /^(?<indent> +)(?:(?:- )?[A-Za-z_$'"][^\n]*:|- [[{])/u;
+function detectIndent(text) {
+	let smallest = 0;
+	for (const line of text.split("\n")) {
+		const indent = KEY_LINE.exec(line)?.groups?.indent;
+		if (indent !== void 0 && (smallest === 0 || indent.length < smallest)) smallest = indent.length;
+	}
+	return smallest === 0 ? 2 : smallest;
+}
+const DEEPEST_STATABLE_STEP = 9;
+function stateIndentation(written, ctx) {
+	if (!/^[|>][1-9]/u.test(written)) return written;
+	const step = ctx.indentStep.length;
+	if (step > DEEPEST_STATABLE_STEP) throw new Error(`A block scalar indented by ${step} spaces cannot state its indentation: YAML writes that indicator as a single digit, so ${DEEPEST_STATABLE_STEP} spaces is the deepest step a document may be written with.`);
+	return `${written[0]}${step}${written.slice(2)}`;
+}
+function isScalarTag(tag) {
+	return typeof tag !== "string" && tag.collection === void 0;
+}
+function statingItsIndentation(tag) {
+	const write = tag.stringify;
+	if (write === void 0) return tag;
+	return {
+		...tag,
+		stringify: (item, ctx, onComment, onChompKeep) => stateIndentation(write(item, ctx, onComment, onChompKeep), ctx)
+	};
+}
+function parseYamlSource(text) {
+	const lineCounter = new LineCounter();
+	return {
+		document: parseDocument(text, {
+			customTags: (tags) => tags.map((tag) => isScalarTag(tag) ? statingItsIndentation(tag) : tag),
+			lineCounter
+		}),
+		indent: detectIndent(text),
+		lineAt: (offset) => lineCounter.linePos(offset).line,
+		text
+	};
+}
+function yamlSyntaxErrors(source) {
+	return source.document.errors.map((error) => ({
+		line: source.lineAt(error.pos[0]),
+		message: error.message
+	}));
+}
+function blockScalar(text) {
+	const scalar = new Scalar(text);
+	scalar.type = Scalar.BLOCK_LITERAL;
+	return scalar;
+}
+function lineStart(text, offset) {
+	return text.lastIndexOf("\n", offset - 1) + 1;
+}
+function afterOwner(text, offset) {
+	return text.slice(0, offset).trimEnd().length;
+}
+function indentOf(text, offset) {
+	const line = text.slice(lineStart(text, offset));
+	return line.length - line.trimStart().length;
+}
+function flowCollections(text) {
+	const found = [];
+	const take = (node) => {
+		if (node.flow !== true) return;
+		const { range } = node;
+		if (range === null || range === void 0) return;
+		const [start, end] = range;
+		const from = afterOwner(text, start);
+		found.push({
+			ownerIndent: indentOf(text, from),
+			range: [from, end],
+			text: text.slice(from, end),
+			value: JSON.stringify(node.toJSON())
+		});
+		return visit.SKIP;
+	};
+	visit(parseDocument(text), {
+		Map: (_key, node) => take(node),
+		Seq: (_key, node) => take(node)
+	});
+	return found;
+}
+function restoreUntouchedFlow(rendered, text) {
+	const sources = flowCollections(text);
+	const taken = /* @__PURE__ */ new Set();
+	const splices = [];
+	for (const target of flowCollections(rendered)) {
+		const at = sources.findIndex((candidate, index) => !taken.has(index) && candidate.value === target.value && candidate.ownerIndent === target.ownerIndent);
+		const source = sources[at];
+		if (source === void 0) continue;
+		taken.add(at);
+		splices.push({
+			range: target.range,
+			text: source.text
+		});
+	}
+	let out = rendered;
+	for (const splice of splices.toReversed()) out = out.slice(0, splice.range[0]) + splice.text + out.slice(splice.range[1]);
+	return out;
+}
+/** `lineWidth: 0`: a golden is compared byte for byte, so nothing folds a long line. */
+function renderYamlSource(source) {
+	return restoreUntouchedFlow(source.document.toString({
+		indent: source.indent,
+		lineWidth: 0
+	}), source.text);
+}
+//#endregion
+export { isPair as a, nodeItems as c, renderYamlSource as d, yamlSyntaxErrors as f, isNode$1 as i, nodePairs as l, blockScalar as n, isScalar as o, isMap as r, isSeq as s, Scalar$1 as t, parseYamlSource as u };
+
+//# sourceMappingURL=shared-yaml-document.js.map

package/dist/stubs.d.ts

@@ -0,0 +1,2 @@
+import { C as StubRequest, E as StubResponseValue, S as StreamBody, T as StubResponse, _ as StubInput, a as openai, b as defineStubs, c as SseEvent, d as anthropic, f as TextFilter, g as Stub, i as InterceptScope, l as http, n as Intercept, o as HttpResponseInit, r as InterceptOptions, s as HttpStreamInit, t as intercept, u as HttpStubFilter, v as Stubs, w as StubResponder, x as MatchableRequest, y as defineStub } from "./shared-index.stubs.js";
+export { type HttpResponseInit, type HttpStreamInit, type HttpStubFilter, type Intercept, type InterceptOptions, type InterceptScope, type MatchableRequest, type SseEvent, type StreamBody, type Stub, type StubInput, type StubRequest, type StubResponder, type StubResponse, type StubResponseValue, type Stubs, type TextFilter, anthropic, defineStub, defineStubs, http, intercept, openai };