@fedify/fedify/dist/testing-BZ0dJ4qn.js

An ActivityPub server framework

      import { Temporal } from "@js-temporal/polyfill";
      import { URLPattern } from "urlpattern-polyfill";
      globalThis.addEventListener = () => {};
    
import { __require } from "./chunk-HsBuZ-b2.js";
import { configure, getConsoleSink, reset } from "@logtape/logtape";

//#region testing/mod.ts
const testDefinitions = [];
function test(name, options, fn) {
	const def = typeof name === "string" ? typeof options === "function" ? {
		name,
		fn: options
	} : {
		name,
		...options,
		fn
	} : name;
	testDefinitions.push(def);
	if ("Deno" in globalThis) {
		const func = def.fn;
		Deno.test({
			...def,
			async fn(t) {
				const records = [];
				await configure({
					sinks: {
						buffer(record) {
							if (record.category.length > 1 && record.category[0] === "logtape" && record.category[1] === "meta") return;
							records.push(record);
						},
						console: getConsoleSink()
					},
					filters: {},
					loggers: [{
						category: [],
						sinks: [Deno.env.get("LOG") === "always" ? "console" : "buffer"]
					}]
				});
				try {
					await func(t);
				} catch (e) {
					const consoleSink = getConsoleSink();
					for (const record of records) consoleSink(record);
					throw e;
				} finally {
					await reset();
				}
			}
		});
	} else if ("Bun" in globalThis) {
		let failed = void 0;
		async function step(defOrNameOrFn, fn$2) {
			let def$1;
			if (typeof defOrNameOrFn === "string") def$1 = {
				name: defOrNameOrFn,
				fn: fn$2
			};
			else if (typeof defOrNameOrFn === "function") def$1 = {
				name: defOrNameOrFn.name,
				fn: defOrNameOrFn
			};
			else def$1 = defOrNameOrFn;
			if (def$1.ignore) return true;
			try {
				await def$1.fn({
					name: def$1.name,
					origin: "",
					step
				});
			} catch (e) {
				failed ??= e;
				return false;
			}
			return true;
		}
		const ctx = {
			name: def.name,
			origin: "",
			step
		};
		async function fn$1() {
			await def.fn(ctx);
			if (failed) throw failed;
		}
		const bunTest = Bun.jest(caller()).test;
		if (def.ignore) bunTest.skip(def.name, fn$1);
		else if (def.only) bunTest.only(def.name, fn$1);
		else bunTest(def.name, fn$1);
	} else try {
		const { test: nodeTest } = __require("node:test");
		nodeTest(def.name, {
			only: def.only,
			skip: def.ignore
		}, async (t) => {
			await def.fn(intoDenoTestContext(def.name, t));
		});
	} catch {}
}
function intoDenoTestContext(name, ctx) {
	async function step(defOrNameOrFn, fn) {
		let def;
		if (typeof defOrNameOrFn === "string") def = {
			name: defOrNameOrFn,
			fn
		};
		else if (typeof defOrNameOrFn === "function") def = {
			name: defOrNameOrFn.name,
			fn: defOrNameOrFn
		};
		else def = defOrNameOrFn;
		let failed = false;
		await ctx.test(def.name, async (ctx2) => {
			try {
				await def.fn(intoDenoTestContext(def.name, ctx2));
			} catch (e) {
				failed = true;
				throw e;
			}
		});
		return failed;
	}
	const denoCtx = {
		name,
		origin: ctx.filePath ?? "",
		step
	};
	return denoCtx;
}
/** Retrieve caller test file. */
function caller() {
	const Trace = Error;
	const _ = Trace.prepareStackTrace;
	Trace.prepareStackTrace = (_$1, stack$1) => stack$1;
	const { stack } = /* @__PURE__ */ new Error();
	Trace.prepareStackTrace = _;
	const caller$1 = stack[2];
	return caller$1.getFileName().replaceAll("\\", "/");
}

//#endregion
export { test, testDefinitions };