@fedify/testing 2.0.0-dev.215 → 2.0.0-dev.226

package/dist/mod.cjs

@@ -1,3 +1,6 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
 //#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -23,6 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 const __fedify_fedify_federation = __toESM(require("@fedify/fedify/federation"));
 const __fedify_vocab = __toESM(require("@fedify/vocab"));
+const es_toolkit = __toESM(require("es-toolkit"));
+const node_assert_strict = __toESM(require("node:assert/strict"));
 
 //#region src/docloader.ts
 const mockDocumentLoader = async (url) => ({
@@ -737,8 +742,114 @@ var MockContext = class MockContext {
 	}
 };
 
+//#endregion
+//#region src/mq-tester.ts
+/**
+* Tests a {@link MessageQueue} implementation with a standard set of tests.
+*
+* This function runs tests for:
+* - `enqueue()`: Basic message enqueueing
+* - `enqueue()` with delay: Delayed message enqueueing
+* - `enqueueMany()`: Bulk message enqueueing
+* - `enqueueMany()` with delay: Delayed bulk message enqueueing
+* - Multiple listeners: Ensures messages are processed by only one listener
+*
+* @example
+* ```typescript ignore
+* import { test } from "@fedify/fixture";
+* import { testMessageQueue } from "@fedify/testing";
+* import { MyMessageQueue } from "./my-mq.ts";
+*
+* test("MyMessageQueue", () =>
+*   testMessageQueue(
+*     () => new MyMessageQueue(),
+*     async ({ mq1, mq2, controller }) => {
+*       controller.abort();
+*       await mq1.close();
+*       await mq2.close();
+*     },
+*   )
+* );
+* ```
+*
+* @param getMessageQueue A factory function that creates a new message queue
+*                        instance.  It should return a new instance each time
+*                        to ensure test isolation, but both instances should
+*                        share the same underlying storage/channel.
+* @param onFinally A cleanup function called after all tests complete.
+*                  It receives both message queue instances and the abort
+*                  controller used for the listeners.
+* @returns A promise that resolves when all tests pass.
+*/
+async function testMessageQueue(getMessageQueue, onFinally) {
+	const mq1 = await getMessageQueue();
+	const mq2 = await getMessageQueue();
+	const controller = new AbortController();
+	try {
+		const messages = [];
+		const listening1 = mq1.listen((message) => {
+			messages.push(message);
+		}, { signal: controller.signal });
+		const listening2 = mq2.listen((message) => {
+			messages.push(message);
+		}, { signal: controller.signal });
+		await mq1.enqueue("Hello, world!");
+		await waitFor(() => messages.length > 0, 15e3);
+		(0, node_assert_strict.deepStrictEqual)(messages, ["Hello, world!"]);
+		let started = Date.now();
+		await mq1.enqueue("Delayed message", { delay: Temporal.Duration.from({ seconds: 3 }) });
+		await waitFor(() => messages.length > 1, 15e3);
+		(0, node_assert_strict.deepStrictEqual)(messages, ["Hello, world!", "Delayed message"]);
+		(0, node_assert_strict.ok)(Date.now() - started >= 3e3, "Delayed message should be delivered after at least 3 seconds");
+		if (mq1.enqueueMany != null) {
+			while (messages.length > 0) messages.pop();
+			const batchMessages = [
+				"First batch message",
+				"Second batch message",
+				"Third batch message"
+			];
+			await mq1.enqueueMany(batchMessages);
+			await waitFor(() => messages.length >= batchMessages.length, 15e3);
+			(0, node_assert_strict.deepStrictEqual)(new Set(messages), new Set(batchMessages));
+			while (messages.length > 0) messages.pop();
+			started = Date.now();
+			const delayedBatchMessages = ["Delayed batch 1", "Delayed batch 2"];
+			await mq1.enqueueMany(delayedBatchMessages, { delay: Temporal.Duration.from({ seconds: 2 }) });
+			await waitFor(() => messages.length >= delayedBatchMessages.length, 15e3);
+			(0, node_assert_strict.deepStrictEqual)(new Set(messages), new Set(delayedBatchMessages));
+			(0, node_assert_strict.ok)(Date.now() - started >= 2e3, "Delayed batch messages should be delivered after at least 2 seconds");
+		}
+		while (messages.length > 0) messages.pop();
+		const bulkCount = 100;
+		for (let i = 0; i < bulkCount; i++) await mq1.enqueue(`message-${i}`);
+		await waitFor(() => messages.length >= bulkCount, 3e4);
+		const expectedMessages = new Set(Array.from({ length: bulkCount }, (_, i) => `message-${i}`));
+		(0, node_assert_strict.deepStrictEqual)(new Set(messages), expectedMessages);
+		controller.abort();
+		await listening1;
+		await listening2;
+	} finally {
+		await onFinally({
+			mq1,
+			mq2,
+			controller
+		});
+	}
+}
+async function waitFor(predicate, timeoutMs) {
+	const started = Date.now();
+	while (!predicate()) {
+		await (0, es_toolkit.delay)(500);
+		if (Date.now() - started > timeoutMs) throw new Error("Timeout");
+	}
+}
+const getRandomKey = (prefix) => `fedify_test_${prefix}_${crypto.randomUUID()}`;
+
 //#endregion
 exports.createContext = createContext;
 exports.createFederation = createFederation;
 exports.createInboxContext = createInboxContext;
-exports.createRequestContext = createRequestContext;
+exports.createRequestContext = createRequestContext;
+exports.getRandomKey = getRandomKey;
+exports.testMessageQueue = testMessageQueue;
+exports.waitFor = waitFor;

package/dist/mod.d.cts

@@ -1,5 +1,6 @@
 import { Context, Federation, InboxContext, RequestContext } from "@fedify/fedify/federation";
 import { Activity } from "@fedify/vocab";
+import { MessageQueue } from "@fedify/fedify";
 
 //#region src/context.d.ts
 declare function createContext<TContextData>(values: Partial<Context<TContextData>> & {
@@ -123,4 +124,54 @@ declare function createFederation<TContextData>(options?: {
   tracerProvider?: any;
 }): TestFederation<TContextData>;
 //#endregion
-export { createContext, createFederation, createInboxContext, createRequestContext };
+//#region src/mq-tester.d.ts
+/**
+ * Tests a {@link MessageQueue} implementation with a standard set of tests.
+ *
+ * This function runs tests for:
+ * - `enqueue()`: Basic message enqueueing
+ * - `enqueue()` with delay: Delayed message enqueueing
+ * - `enqueueMany()`: Bulk message enqueueing
+ * - `enqueueMany()` with delay: Delayed bulk message enqueueing
+ * - Multiple listeners: Ensures messages are processed by only one listener
+ *
+ * @example
+ * ```typescript ignore
+ * import { test } from "@fedify/fixture";
+ * import { testMessageQueue } from "@fedify/testing";
+ * import { MyMessageQueue } from "./my-mq.ts";
+ *
+ * test("MyMessageQueue", () =>
+ *   testMessageQueue(
+ *     () => new MyMessageQueue(),
+ *     async ({ mq1, mq2, controller }) => {
+ *       controller.abort();
+ *       await mq1.close();
+ *       await mq2.close();
+ *     },
+ *   )
+ * );
+ * ```
+ *
+ * @param getMessageQueue A factory function that creates a new message queue
+ *                        instance.  It should return a new instance each time
+ *                        to ensure test isolation, but both instances should
+ *                        share the same underlying storage/channel.
+ * @param onFinally A cleanup function called after all tests complete.
+ *                  It receives both message queue instances and the abort
+ *                  controller used for the listeners.
+ * @returns A promise that resolves when all tests pass.
+ */
+declare function testMessageQueue<MQ extends MessageQueue>(getMessageQueue: () => MQ | Promise<MQ>, onFinally: ({
+  mq1,
+  mq2,
+  controller
+}: {
+  mq1: MQ;
+  mq2: MQ;
+  controller: AbortController;
+}) => Promise<void> | void): Promise<void>;
+declare function waitFor(predicate: () => boolean, timeoutMs: number): Promise<void>;
+declare const getRandomKey: (prefix: string) => string;
+//#endregion
+export { createContext, createFederation, createInboxContext, createRequestContext, getRandomKey, testMessageQueue, waitFor };

package/dist/mod.d.ts

@@ -1,5 +1,7 @@
+import { Temporal } from "@js-temporal/polyfill";
 import { Context, Federation, InboxContext, RequestContext } from "@fedify/fedify/federation";
 import { Activity } from "@fedify/vocab";
+import { MessageQueue } from "@fedify/fedify";
 
 //#region src/context.d.ts
 declare function createContext<TContextData>(values: Partial<Context<TContextData>> & {
@@ -123,4 +125,54 @@ declare function createFederation<TContextData>(options?: {
   tracerProvider?: any;
 }): TestFederation<TContextData>;
 //#endregion
-export { createContext, createFederation, createInboxContext, createRequestContext };
+//#region src/mq-tester.d.ts
+/**
+ * Tests a {@link MessageQueue} implementation with a standard set of tests.
+ *
+ * This function runs tests for:
+ * - `enqueue()`: Basic message enqueueing
+ * - `enqueue()` with delay: Delayed message enqueueing
+ * - `enqueueMany()`: Bulk message enqueueing
+ * - `enqueueMany()` with delay: Delayed bulk message enqueueing
+ * - Multiple listeners: Ensures messages are processed by only one listener
+ *
+ * @example
+ * ```typescript ignore
+ * import { test } from "@fedify/fixture";
+ * import { testMessageQueue } from "@fedify/testing";
+ * import { MyMessageQueue } from "./my-mq.ts";
+ *
+ * test("MyMessageQueue", () =>
+ *   testMessageQueue(
+ *     () => new MyMessageQueue(),
+ *     async ({ mq1, mq2, controller }) => {
+ *       controller.abort();
+ *       await mq1.close();
+ *       await mq2.close();
+ *     },
+ *   )
+ * );
+ * ```
+ *
+ * @param getMessageQueue A factory function that creates a new message queue
+ *                        instance.  It should return a new instance each time
+ *                        to ensure test isolation, but both instances should
+ *                        share the same underlying storage/channel.
+ * @param onFinally A cleanup function called after all tests complete.
+ *                  It receives both message queue instances and the abort
+ *                  controller used for the listeners.
+ * @returns A promise that resolves when all tests pass.
+ */
+declare function testMessageQueue<MQ extends MessageQueue>(getMessageQueue: () => MQ | Promise<MQ>, onFinally: ({
+  mq1,
+  mq2,
+  controller
+}: {
+  mq1: MQ;
+  mq2: MQ;
+  controller: AbortController;
+}) => Promise<void> | void): Promise<void>;
+declare function waitFor(predicate: () => boolean, timeoutMs: number): Promise<void>;
+declare const getRandomKey: (prefix: string) => string;
+//#endregion
+export { createContext, createFederation, createInboxContext, createRequestContext, getRandomKey, testMessageQueue, waitFor };

package/dist/mod.js

@@ -1,5 +1,10 @@
+
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { RouterError } from "@fedify/fedify/federation";
 import { lookupObject, traverseCollection } from "@fedify/vocab";
+import { delay } from "es-toolkit";
+import { deepStrictEqual, ok } from "node:assert/strict";
 
 //#region src/docloader.ts
 const mockDocumentLoader = async (url) => ({
@@ -715,4 +720,107 @@ var MockContext = class MockContext {
 };
 
 //#endregion
-export { createContext, createFederation, createInboxContext, createRequestContext };
+//#region src/mq-tester.ts
+/**
+* Tests a {@link MessageQueue} implementation with a standard set of tests.
+*
+* This function runs tests for:
+* - `enqueue()`: Basic message enqueueing
+* - `enqueue()` with delay: Delayed message enqueueing
+* - `enqueueMany()`: Bulk message enqueueing
+* - `enqueueMany()` with delay: Delayed bulk message enqueueing
+* - Multiple listeners: Ensures messages are processed by only one listener
+*
+* @example
+* ```typescript ignore
+* import { test } from "@fedify/fixture";
+* import { testMessageQueue } from "@fedify/testing";
+* import { MyMessageQueue } from "./my-mq.ts";
+*
+* test("MyMessageQueue", () =>
+*   testMessageQueue(
+*     () => new MyMessageQueue(),
+*     async ({ mq1, mq2, controller }) => {
+*       controller.abort();
+*       await mq1.close();
+*       await mq2.close();
+*     },
+*   )
+* );
+* ```
+*
+* @param getMessageQueue A factory function that creates a new message queue
+*                        instance.  It should return a new instance each time
+*                        to ensure test isolation, but both instances should
+*                        share the same underlying storage/channel.
+* @param onFinally A cleanup function called after all tests complete.
+*                  It receives both message queue instances and the abort
+*                  controller used for the listeners.
+* @returns A promise that resolves when all tests pass.
+*/
+async function testMessageQueue(getMessageQueue, onFinally) {
+	const mq1 = await getMessageQueue();
+	const mq2 = await getMessageQueue();
+	const controller = new AbortController();
+	try {
+		const messages = [];
+		const listening1 = mq1.listen((message) => {
+			messages.push(message);
+		}, { signal: controller.signal });
+		const listening2 = mq2.listen((message) => {
+			messages.push(message);
+		}, { signal: controller.signal });
+		await mq1.enqueue("Hello, world!");
+		await waitFor(() => messages.length > 0, 15e3);
+		deepStrictEqual(messages, ["Hello, world!"]);
+		let started = Date.now();
+		await mq1.enqueue("Delayed message", { delay: Temporal.Duration.from({ seconds: 3 }) });
+		await waitFor(() => messages.length > 1, 15e3);
+		deepStrictEqual(messages, ["Hello, world!", "Delayed message"]);
+		ok(Date.now() - started >= 3e3, "Delayed message should be delivered after at least 3 seconds");
+		if (mq1.enqueueMany != null) {
+			while (messages.length > 0) messages.pop();
+			const batchMessages = [
+				"First batch message",
+				"Second batch message",
+				"Third batch message"
+			];
+			await mq1.enqueueMany(batchMessages);
+			await waitFor(() => messages.length >= batchMessages.length, 15e3);
+			deepStrictEqual(new Set(messages), new Set(batchMessages));
+			while (messages.length > 0) messages.pop();
+			started = Date.now();
+			const delayedBatchMessages = ["Delayed batch 1", "Delayed batch 2"];
+			await mq1.enqueueMany(delayedBatchMessages, { delay: Temporal.Duration.from({ seconds: 2 }) });
+			await waitFor(() => messages.length >= delayedBatchMessages.length, 15e3);
+			deepStrictEqual(new Set(messages), new Set(delayedBatchMessages));
+			ok(Date.now() - started >= 2e3, "Delayed batch messages should be delivered after at least 2 seconds");
+		}
+		while (messages.length > 0) messages.pop();
+		const bulkCount = 100;
+		for (let i = 0; i < bulkCount; i++) await mq1.enqueue(`message-${i}`);
+		await waitFor(() => messages.length >= bulkCount, 3e4);
+		const expectedMessages = new Set(Array.from({ length: bulkCount }, (_, i) => `message-${i}`));
+		deepStrictEqual(new Set(messages), expectedMessages);
+		controller.abort();
+		await listening1;
+		await listening2;
+	} finally {
+		await onFinally({
+			mq1,
+			mq2,
+			controller
+		});
+	}
+}
+async function waitFor(predicate, timeoutMs) {
+	const started = Date.now();
+	while (!predicate()) {
+		await delay(500);
+		if (Date.now() - started > timeoutMs) throw new Error("Timeout");
+	}
+}
+const getRandomKey = (prefix) => `fedify_test_${prefix}_${crypto.randomUUID()}`;
+
+//#endregion
+export { createContext, createFederation, createInboxContext, createRequestContext, getRandomKey, testMessageQueue, waitFor };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/testing",
-  "version": "2.0.0-dev.215+84aa16bb",
+  "version": "2.0.0-dev.226+c28b813d",
   "description": "Testing utilities for Fedify applications",
   "keywords": [
     "fedify",
@@ -50,14 +50,18 @@
     "package.json"
   ],
   "peerDependencies": {
-    "@fedify/fedify": "^2.0.0-dev.215+84aa16bb"
+    "@fedify/fedify": "^2.0.0-dev.226+c28b813d"
+  },
+  "dependencies": {
+    "es-toolkit": "1.43.0"
   },
   "devDependencies": {
     "@js-temporal/polyfill": "^0.5.1",
     "@std/assert": "npm:@jsr/std__assert@^1.0.13",
     "@std/async": "npm:@jsr/std__async@^1.0.13",
     "tsdown": "^0.12.9",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "@fedify/fixture": "^2.0.0"
   },
   "scripts": {
     "build": "tsdown",