@logtape/testing-bun 2.3.0-dev.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2026 Hong Minhee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+<!-- deno-fmt-ignore-file -->
+
+Bun test runner integration for LogTape
+=======================================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+*@logtape/testing-bun* provides a [Bun test runner] integration for
+[LogTape]'s failure log reporter.  Import its `test` function instead of
+`bun:test` when you want logs emitted by a test callback to be reported only
+when that callback fails.
+
+[JSR badge]: https://jsr.io/badges/@logtape/testing-bun
+[JSR]: https://jsr.io/@logtape/testing-bun
+[npm badge]: https://img.shields.io/npm/v/@logtape/testing-bun?logo=npm
+[npm]: https://www.npmjs.com/package/@logtape/testing-bun
+[Bun test runner]: https://bun.com/docs/test
+[LogTape]: https://logtape.org/
+
+
+Installation
+------------
+
+~~~~ sh
+bun add @logtape/testing-bun
+~~~~
+
+
+Usage
+-----
+
+~~~~ typescript
+import { test } from "@logtape/testing-bun/autoload";
+import { getLogger } from "@logtape/logtape";
+
+test("case", () => {
+  getLogger(["my-lib"]).debug("Fixture state: {state}.", {
+    state: "ready",
+  });
+
+  // Logs emitted here are printed only if this callback fails.
+});
+~~~~
+
+The autoload entry point is the easiest setup for large suites.  It configures
+the minimal LogTape `contextLocalStorage` needed by the failure log reporter
+when LogTape has not been configured yet.  If your suite already configures
+LogTape, that configuration must include `contextLocalStorage`; otherwise, use
+`@logtape/testing-bun` and manage setup explicitly.
+
+Use `createTest()` when a suite needs custom reporter options:
+
+~~~~ typescript
+import { createTest } from "@logtape/testing-bun";
+
+const test = createTest({
+  lowestLevel: "debug",
+  mode: "on-failure",
+});
+~~~~
+
+The package preserves Bun test options and shorthand helpers such as
+`test.skip()`, `test.todo()`, `test.only()`, `test.if()`, `test.failing()`,
+`test.concurrent()`, `test.serial()`, and `test.each()`.  It also exports a
+wrapped `it()` alias and `createIt()`.  Other `bun:test` helpers, including
+`describe()`, `beforeAll()`, `afterAll()`, `beforeEach()`, `afterEach()`,
+`expect`, `expectTypeOf`, `mock()`, `spyOn()`, `jest`, `vi`, `xdescribe()`,
+`xit()`, and `xtest()`, are re-exported unchanged.
+
+
+Docs
+----
+
+The docs of this package is available at
+<https://logtape.org/manual/testing#bun-test-runner-integration>.
+For the API references, see <https://jsr.io/@logtape/testing-bun/doc>.

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/autoload.cjs

@@ -0,0 +1,274 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const node_async_hooks = __toESM(require("node:async_hooks"));
+const __logtape_logtape = __toESM(require("@logtape/logtape"));
+const bun_test = __toESM(require("bun:test"));
+const __logtape_testing_reporter = __toESM(require("@logtape/testing/reporter"));
+
+//#region src/mod.ts
+const helperNames = [
+	"skip",
+	"todo",
+	"only",
+	"failing",
+	"concurrent",
+	"serial"
+];
+const conditionalHelperNames = [
+	"if",
+	"skipIf",
+	"todoIf"
+];
+const expectTypeOf = bun_test.expectTypeOf;
+const onTestFinished = bun_test.onTestFinished;
+const vi = bun_test.vi;
+const xdescribe = bun_test.xdescribe;
+const xit = bun_test.xit;
+const xtest = bun_test.xtest;
+/**
+* Creates a `bun:test` test function that reports LogTape records from failed
+* test callbacks.
+*
+* The returned function preserves Bun test options and shorthand helpers such
+* as `test.skip()`, `test.todo()`, `test.only()`, `test.if()`,
+* `test.failing()`, `test.concurrent()`, `test.serial()`, and `test.each()`.
+* Only callback arguments are adapted; options are passed through to
+* `bun:test`.
+*
+* @param options Failure log reporter options.
+* @returns A configured `bun:test`-compatible test function.
+* @since 2.3.0
+*/
+function createTest(options = {}) {
+	return createBunTestFunction(bun_test.test, options);
+}
+/**
+* Creates an `it()` alias that reports LogTape records from failed test
+* callbacks.
+*
+* @param options Failure log reporter options.
+* @returns A configured `bun:test`-compatible `it()` function.
+* @since 2.3.0
+*/
+function createIt(options = {}) {
+	return createBunTestFunction(bun_test.it, options);
+}
+/**
+* A `bun:test` test function that reports LogTape records from failed test
+* callbacks using the default reporter options.
+*
+* @since 2.3.0
+*/
+const test = createTest();
+/**
+* A `bun:test` `it()` alias that reports LogTape records from failed test
+* callbacks using the default reporter options.
+*
+* @since 2.3.0
+*/
+const it = createIt();
+/**
+* Shorthand for skipping a test.
+*
+* @since 2.3.0
+*/
+const skip = test.skip;
+/**
+* Shorthand for marking a test as TODO.
+*
+* @since 2.3.0
+*/
+const todo = test.todo;
+/**
+* Shorthand for marking a test as `only`.
+*
+* @since 2.3.0
+*/
+const only = test.only;
+/**
+* Shorthand for marking a test as expected to fail.
+*
+* @since 2.3.0
+*/
+const failing = test.failing;
+/**
+* Shorthand for running a test concurrently.
+*
+* @since 2.3.0
+*/
+const concurrent = test.concurrent;
+/**
+* Shorthand for running a test serially.
+*
+* @since 2.3.0
+*/
+const serial = test.serial;
+/**
+* Shorthand for Bun's parameterized tests.
+*
+* @since 2.3.0
+*/
+const each = test.each;
+var src_default = test;
+function createBunTestFunction(baseTest, options) {
+	const register = (...args) => Reflect.apply(baseTest, void 0, wrapBunTestArguments(args, options));
+	for (const helperName of helperNames) {
+		const helper = getFunctionProperty(baseTest, helperName);
+		if (helper == null) continue;
+		Object.defineProperty(register, helperName, {
+			configurable: true,
+			enumerable: true,
+			value: createBunTestFunction(helper, options),
+			writable: true
+		});
+	}
+	for (const helperName of conditionalHelperNames) {
+		const helper = getFunctionProperty(baseTest, helperName);
+		if (helper == null) continue;
+		Object.defineProperty(register, helperName, {
+			configurable: true,
+			enumerable: true,
+			value: (condition) => {
+				const conditionalTest = Reflect.apply(helper, baseTest, [condition]);
+				return createBunTestFunction(conditionalTest, options);
+			},
+			writable: true
+		});
+	}
+	const each$1 = getFunctionProperty(baseTest, "each");
+	if (each$1 != null) Object.defineProperty(register, "each", {
+		configurable: true,
+		enumerable: true,
+		value: createWrappedEach(baseTest, each$1, options),
+		writable: true
+	});
+	return register;
+}
+function createWrappedEach(baseTest, baseEach, options) {
+	return (...cases) => {
+		const registerEach = Reflect.apply(baseEach, baseTest, cases);
+		return (...args) => Reflect.apply(registerEach, void 0, wrapBunEachArguments(args, options));
+	};
+}
+function wrapBunTestArguments(args, options) {
+	const callbackIndex = args.findIndex((arg) => typeof arg === "function");
+	if (callbackIndex < 0) return [...args];
+	return [
+		...args.slice(0, callbackIndex),
+		wrapBunTestCallback(args[callbackIndex], options),
+		...args.slice(callbackIndex + 1)
+	];
+}
+function wrapBunEachArguments(args, options) {
+	const callbackIndex = args.findIndex((arg, index) => index > 0 && typeof arg === "function");
+	if (callbackIndex < 0) return [...args];
+	return [
+		...args.slice(0, callbackIndex),
+		wrapBunEachCallback(args[callbackIndex], options),
+		...args.slice(callbackIndex + 1)
+	];
+}
+function wrapBunTestCallback(callback, options) {
+	const reporter = (0, __logtape_testing_reporter.createFailureLogReporter)(options);
+	if (callback.length >= 1) return function(done) {
+		const wrapped = reporter.wrap(() => new Promise((resolve, reject) => {
+			let settled = false;
+			const wrappedDone = (error) => {
+				if (settled) return;
+				settled = true;
+				if (error == null) resolve();
+				else reject(error);
+			};
+			try {
+				Reflect.apply(callback, this, [wrappedDone]);
+			} catch (error) {
+				reject(error);
+			}
+		}));
+		wrapped().then(() => done(), (error) => done(error));
+	};
+	return function() {
+		return reporter.run(() => Reflect.apply(callback, this, []));
+	};
+}
+function wrapBunEachCallback(callback, options) {
+	const reporter = (0, __logtape_testing_reporter.createFailureLogReporter)(options);
+	return function(...args) {
+		return reporter.run(() => Reflect.apply(callback, this, args));
+	};
+}
+function getFunctionProperty(value, property) {
+	try {
+		const propertyValue = Reflect.get(value, property);
+		return typeof propertyValue === "function" ? propertyValue : void 0;
+	} catch {
+		return void 0;
+	}
+}
+
+//#endregion
+//#region src/autoload.ts
+const config = (0, __logtape_logtape.getConfig)();
+if (config == null) (0, __logtape_logtape.configureSync)({
+	contextLocalStorage: new node_async_hooks.AsyncLocalStorage(),
+	sinks: {},
+	loggers: [{
+		category: ["logtape", "meta"],
+		sinks: []
+	}]
+});
+else if (config.contextLocalStorage == null) throw new __logtape_logtape.ConfigError("@logtape/testing-bun/autoload requires the existing LogTape configuration to provide contextLocalStorage.");
+var autoload_default = src_default;
+
+//#endregion
+exports.afterAll = bun_test.afterAll;
+exports.afterEach = bun_test.afterEach;
+exports.beforeAll = bun_test.beforeAll;
+exports.beforeEach = bun_test.beforeEach;
+exports.concurrent = concurrent;
+exports.createIt = createIt;
+exports.createTest = createTest;
+exports.default = autoload_default;
+exports.describe = bun_test.describe;
+exports.each = each;
+exports.expect = bun_test.expect;
+exports.expectTypeOf = expectTypeOf;
+exports.failing = failing;
+exports.it = it;
+exports.jest = bun_test.jest;
+exports.mock = bun_test.mock;
+exports.onTestFinished = onTestFinished;
+exports.only = only;
+exports.serial = serial;
+exports.setDefaultTimeout = bun_test.setDefaultTimeout;
+exports.setSystemTime = bun_test.setSystemTime;
+exports.skip = skip;
+exports.spyOn = bun_test.spyOn;
+exports.test = src_default;
+exports.todo = todo;
+exports.vi = vi;
+exports.xdescribe = xdescribe;
+exports.xit = xit;
+exports.xtest = xtest;

package/dist/autoload.d.cts

@@ -0,0 +1,151 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, jest, mock, setDefaultTimeout, setSystemTime, spyOn } from "bun:test";
+import { FailureLogReportMode, FailureLogReporterOptions, FailureLogReporterOptions as FailureLogReporterOptions$1 } from "@logtape/testing/reporter";
+
+//#region src/mod.d.ts
+
+/**
+ * Options accepted by Bun's `test()` and `it()` functions.
+ *
+ * The shape mirrors Bun's documented option bag while allowing newer Bun
+ * options to pass through even when bundled TypeScript declarations lag behind
+ * the current runtime.
+ *
+ * @since 2.3.0
+ */
+interface BunTestOptions {
+  readonly retry?: number;
+  readonly repeats?: number;
+  readonly timeout?: number;
+  readonly [option: string]: unknown;
+}
+/**
+ * A callback passed to Bun's `test()` or `it()`.
+ *
+ * @since 2.3.0
+ */
+type BunTestCallback = (() => unknown) | ((done: BunDoneCallback) => unknown);
+/**
+ * A Bun `test()`-compatible function.
+ *
+ * @since 2.3.0
+ */
+interface BunTestFunction {
+  (name: string, fn?: BunTestCallback, options?: number | BunTestOptions): void;
+  (name: string, options: number | BunTestOptions, fn?: BunTestCallback): void;
+  readonly skip: BunTestFunction & BunParameterizedTestFactory;
+  readonly todo: BunTestFunction & BunParameterizedTestFactory;
+  readonly only: BunTestFunction & BunParameterizedTestFactory;
+  readonly failing: BunTestFunction & BunParameterizedTestFactory;
+  readonly concurrent: BunTestFunction & BunParameterizedTestFactory;
+  readonly serial: BunTestFunction & BunParameterizedTestFactory;
+  readonly each: BunEachFunction;
+  readonly if: BunConditionalTestFactory;
+  readonly skipIf: BunConditionalTestFactory;
+  readonly todoIf: BunConditionalTestFactory;
+}
+interface BunParameterizedTestFactory {
+  readonly each: BunEachFunction;
+}
+interface BunConditionalTestFactory {
+  (condition: unknown): BunTestFunction & BunParameterizedTestFactory;
+}
+interface BunEachFunction {
+  (...cases: readonly unknown[]): BunEachRegisterFunction;
+}
+interface BunEachRegisterFunction {
+  (name: string, fn: (...args: never[]) => unknown, options?: number | BunTestOptions): void;
+  (name: string, options: number | BunTestOptions, fn: (...args: never[]) => unknown): void;
+}
+type BunDoneCallback = (error?: unknown) => void;
+type BunFunction = (...args: unknown[]) => unknown;
+type ExpectTypeOfFunction = (...args: unknown[]) => unknown;
+type OnTestFinishedFunction = (callback: () => unknown) => void;
+declare const expectTypeOf: ExpectTypeOfFunction;
+declare const onTestFinished: OnTestFinishedFunction;
+declare const vi: typeof jest;
+declare const xdescribe: BunFunction;
+declare const xit: BunFunction;
+declare const xtest: BunFunction;
+/**
+ * Creates a `bun:test` test function that reports LogTape records from failed
+ * test callbacks.
+ *
+ * The returned function preserves Bun test options and shorthand helpers such
+ * as `test.skip()`, `test.todo()`, `test.only()`, `test.if()`,
+ * `test.failing()`, `test.concurrent()`, `test.serial()`, and `test.each()`.
+ * Only callback arguments are adapted; options are passed through to
+ * `bun:test`.
+ *
+ * @param options Failure log reporter options.
+ * @returns A configured `bun:test`-compatible test function.
+ * @since 2.3.0
+ */
+declare function createTest(options?: FailureLogReporterOptions$1): BunTestFunction;
+/**
+ * Creates an `it()` alias that reports LogTape records from failed test
+ * callbacks.
+ *
+ * @param options Failure log reporter options.
+ * @returns A configured `bun:test`-compatible `it()` function.
+ * @since 2.3.0
+ */
+declare function createIt(options?: FailureLogReporterOptions$1): BunTestFunction;
+/**
+ * A `bun:test` test function that reports LogTape records from failed test
+ * callbacks using the default reporter options.
+ *
+ * @since 2.3.0
+ */
+declare const test: BunTestFunction;
+/**
+ * A `bun:test` `it()` alias that reports LogTape records from failed test
+ * callbacks using the default reporter options.
+ *
+ * @since 2.3.0
+ */
+declare const it: BunTestFunction;
+/**
+ * Shorthand for skipping a test.
+ *
+ * @since 2.3.0
+ */
+declare const skip: BunTestFunction;
+/**
+ * Shorthand for marking a test as TODO.
+ *
+ * @since 2.3.0
+ */
+declare const todo: BunTestFunction;
+/**
+ * Shorthand for marking a test as `only`.
+ *
+ * @since 2.3.0
+ */
+declare const only: BunTestFunction;
+/**
+ * Shorthand for marking a test as expected to fail.
+ *
+ * @since 2.3.0
+ */
+declare const failing: BunTestFunction;
+/**
+ * Shorthand for running a test concurrently.
+ *
+ * @since 2.3.0
+ */
+declare const concurrent: BunTestFunction;
+/**
+ * Shorthand for running a test serially.
+ *
+ * @since 2.3.0
+ */
+declare const serial: BunTestFunction;
+/**
+ * Shorthand for Bun's parameterized tests.
+ *
+ * @since 2.3.0
+ */
+declare const each: BunEachFunction;
+//#endregion
+export { BunTestCallback, BunTestFunction, BunTestOptions, FailureLogReportMode, FailureLogReporterOptions, afterAll, afterEach, beforeAll, beforeEach, concurrent, createIt, createTest, test as default, test, describe, each, expect, expectTypeOf, failing, it, jest, mock, onTestFinished, only, serial, setDefaultTimeout, setSystemTime, skip, spyOn, todo, vi, xdescribe, xit, xtest };
+//# sourceMappingURL=autoload.d.cts.map

package/dist/autoload.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoload.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":"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"}