@fedify/testing 2.0.0-pr.490.2 → 2.0.0-pr.559.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright 2024–2025 Hong Minhee
+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

package/README.md

@@ -40,7 +40,7 @@ interface for unit testing:
 
 ~~~~ typescript
 import { MockFederation } from "@fedify/testing";
-import { Create } from "@fedify/fedify/vocab";
+import { Create } from "@fedify/vocab";
 
 // Create a mock federation
 const federation = new MockFederation<{ userId: string }>();
@@ -95,10 +95,12 @@ The package also exports helper functions for creating various context types:
  -  `createRequestContext()`: Creates a request context
  -  `createInboxContext()`: Creates an inbox context
 
-## Features
 
-- Track sent activities with metadata
-- Simulate activity reception
-- Configure custom URI templates
-- Test queue-based activity processing
-- Mock document loaders and context loaders
+Features
+--------
+
+ -  Track sent activities with metadata
+ -  Simulate activity reception
+ -  Configure custom URI templates
+ -  Test queue-based activity processing
+ -  Mock document loaders and context loaders

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;
@@ -21,8 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+const __fedify_vocab = __toESM(require("@fedify/vocab"));
 const __fedify_fedify_federation = __toESM(require("@fedify/fedify/federation"));
-const __fedify_fedify_vocab = __toESM(require("@fedify/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) => ({
@@ -39,7 +44,7 @@ const noopTracerProvider$1 = { getTracer: () => ({
 }) };
 function createContext(values) {
 	const { federation, url = new URL("http://example.com/"), canonicalOrigin, data, documentLoader, contextLoader, tracerProvider, clone, getNodeInfoUri, getActorUri, getObjectUri, getCollectionUri, getOutboxUri, getInboxUri, getFollowingUri, getFollowersUri, getLikedUri, getFeaturedUri, getFeaturedTagsUri, parseUri, getActorKeyPairs, getDocumentLoader, lookupObject, traverseCollection, lookupNodeInfo, lookupWebFinger, sendActivity, routeActivity } = values;
-	function throwRouteError() {
+	function throwRouterError() {
 		throw new __fedify_fedify_federation.RouterError("Not implemented");
 	}
 	return {
@@ -56,17 +61,17 @@ function createContext(values) {
 			...values,
 			data: data$1
 		})),
-		getNodeInfoUri: getNodeInfoUri ?? throwRouteError,
-		getActorUri: getActorUri ?? throwRouteError,
-		getObjectUri: getObjectUri ?? throwRouteError,
-		getCollectionUri: getCollectionUri ?? throwRouteError,
-		getOutboxUri: getOutboxUri ?? throwRouteError,
-		getInboxUri: getInboxUri ?? throwRouteError,
-		getFollowingUri: getFollowingUri ?? throwRouteError,
-		getFollowersUri: getFollowersUri ?? throwRouteError,
-		getLikedUri: getLikedUri ?? throwRouteError,
-		getFeaturedUri: getFeaturedUri ?? throwRouteError,
-		getFeaturedTagsUri: getFeaturedTagsUri ?? throwRouteError,
+		getNodeInfoUri: getNodeInfoUri ?? throwRouterError,
+		getActorUri: getActorUri ?? throwRouterError,
+		getObjectUri: getObjectUri ?? throwRouterError,
+		getCollectionUri: getCollectionUri ?? throwRouterError,
+		getOutboxUri: getOutboxUri ?? throwRouterError,
+		getInboxUri: getInboxUri ?? throwRouterError,
+		getFollowingUri: getFollowingUri ?? throwRouterError,
+		getFollowersUri: getFollowersUri ?? throwRouterError,
+		getLikedUri: getLikedUri ?? throwRouterError,
+		getFeaturedUri: getFeaturedUri ?? throwRouterError,
+		getFeaturedTagsUri: getFeaturedTagsUri ?? throwRouterError,
 		parseUri: parseUri ?? ((_uri) => {
 			throw new Error("Not implemented");
 		}),
@@ -75,13 +80,13 @@ function createContext(values) {
 		}),
 		getActorKeyPairs: getActorKeyPairs ?? ((_handle) => Promise.resolve([])),
 		lookupObject: lookupObject ?? ((uri, options = {}) => {
-			return (0, __fedify_fedify_vocab.lookupObject)(uri, {
+			return (0, __fedify_vocab.lookupObject)(uri, {
 				documentLoader: options.documentLoader ?? documentLoader ?? mockDocumentLoader,
 				contextLoader: options.contextLoader ?? contextLoader ?? mockDocumentLoader
 			});
 		}),
 		traverseCollection: traverseCollection ?? ((collection, options = {}) => {
-			return (0, __fedify_fedify_vocab.traverseCollection)(collection, {
+			return (0, __fedify_vocab.traverseCollection)(collection, {
 				documentLoader: options.documentLoader ?? documentLoader ?? mockDocumentLoader,
 				contextLoader: options.contextLoader ?? contextLoader ?? mockDocumentLoader
 			});
@@ -171,7 +176,7 @@ function expandUriTemplate(template, values) {
 *
 * @example
 * ```typescript
-* import { Create } from "@fedify/fedify/vocab";
+* import { Create } from "@fedify/vocab";
 * import { createFederation } from "@fedify/testing";
 *
 * // Create a mock federation with contextData
@@ -205,6 +210,7 @@ var MockFederation = class {
 	nodeInfoDispatcher;
 	webFingerDispatcher;
 	actorDispatchers = /* @__PURE__ */ new Map();
+	actorKeyPairsDispatcher;
 	actorPath;
 	inboxPath;
 	outboxPath;
@@ -242,7 +248,10 @@ var MockFederation = class {
 		this.actorDispatchers.set(path, dispatcher);
 		this.actorPath = path;
 		return {
-			setKeyPairsDispatcher: () => this,
+			setKeyPairsDispatcher: (keyPairsDispatcher) => {
+				this.actorKeyPairsDispatcher = keyPairsDispatcher;
+				return this;
+			},
 			mapHandle: () => this,
 			mapAlias: () => this,
 			authorize: () => this
@@ -344,6 +353,7 @@ var MockFederation = class {
 			}
 		};
 	}
+	setOutboxPermanentFailureHandler(_handler) {}
 	async startQueue(contextData, options) {
 		this.contextData = contextData;
 		this.queueStarted = true;
@@ -428,7 +438,7 @@ var MockFederation = class {
 *
 * @example
 * ```typescript
-* import { Create } from "@fedify/fedify/vocab";
+* import { Create } from "@fedify/vocab";
 * import { createFederation } from "@fedify/testing";
 *
 * // Create a mock federation with contextData
@@ -470,7 +480,7 @@ function createFederation(options = {}) {
 *
 * @example
 * ```typescript
-* import { Person, Create } from "@fedify/fedify/vocab";
+* import { Person, Create } from "@fedify/vocab";
 * import { createFederation } from "@fedify/testing";
 *
 * // Create a mock federation and context
@@ -531,11 +541,22 @@ var MockContext = class MockContext {
 		this.contextLoader = options.contextLoader ?? this.documentLoader;
 		this.tracerProvider = options.tracerProvider ?? noopTracerProvider;
 	}
-	getActor(_handle) {
-		return Promise.resolve(null);
+	async getActor(handle) {
+		if (this.federation instanceof MockFederation && this.federation.actorPath) {
+			const dispatcher = this.federation.actorDispatchers.get(this.federation.actorPath);
+			if (dispatcher) return await dispatcher(this, handle);
+		}
+		return null;
 	}
-	getObject(_cls, _values) {
-		return Promise.resolve(null);
+	async getObject(cls, values) {
+		if (this.federation instanceof MockFederation) {
+			const path = this.federation.objectPaths.get(cls.typeId.href);
+			if (path) {
+				const dispatcher = this.federation.objectDispatchers.get(path);
+				if (dispatcher) return await dispatcher(this, values);
+			}
+		}
+		return null;
 	}
 	getSignedKey() {
 		return Promise.resolve(null);
@@ -667,8 +688,25 @@ var MockContext = class MockContext {
 		}
 		return null;
 	}
-	getActorKeyPairs(_identifier) {
-		return Promise.resolve([]);
+	async getActorKeyPairs(identifier) {
+		if (this.federation instanceof MockFederation && this.federation.actorKeyPairsDispatcher) {
+			const keyPairs = await this.federation.actorKeyPairsDispatcher(this, identifier);
+			const owner = this.getActorUri(identifier);
+			return keyPairs.map((kp) => ({
+				...kp,
+				cryptographicKey: new __fedify_vocab.CryptographicKey({
+					id: kp.keyId,
+					owner,
+					publicKey: kp.publicKey
+				}),
+				multikey: new __fedify_vocab.Multikey({
+					id: kp.keyId,
+					controller: owner,
+					publicKey: kp.publicKey
+				})
+			}));
+		}
+		return [];
 	}
 	getDocumentLoader(params) {
 		if ("keyId" in params) return this.documentLoader;
@@ -726,8 +764,190 @@ 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
+* - Ordering key support (optional): Ensures messages with the same ordering
+*   key are processed in order
+*
+* @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();
+*     },
+*     { testOrderingKey: true },  // Enable ordering key tests
+*   )
+* );
+* ```
+*
+* @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.
+* @param options Optional configuration for the test suite.
+* @returns A promise that resolves when all tests pass.
+*/
+async function testMessageQueue(getMessageQueue, onFinally, options = {}) {
+	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);
+		if (options.testOrderingKey) {
+			while (messages.length > 0) messages.pop();
+			const orderTracker = {
+				keyA: [],
+				keyB: [],
+				noKey: []
+			};
+			controller.abort();
+			await listening1;
+			await listening2;
+			const orderController = new AbortController();
+			const orderMessages = [];
+			const orderListening1 = mq1.listen((message) => {
+				orderMessages.push(message);
+				const trackKey = message.key ?? "noKey";
+				if (trackKey in orderTracker) orderTracker[trackKey].push(message.value);
+			}, { signal: orderController.signal });
+			const orderListening2 = mq2.listen((message) => {
+				orderMessages.push(message);
+				const trackKey = message.key ?? "noKey";
+				if (trackKey in orderTracker) orderTracker[trackKey].push(message.value);
+			}, { signal: orderController.signal });
+			await mq1.enqueue({
+				key: "keyA",
+				value: 1
+			}, { orderingKey: "keyA" });
+			await mq1.enqueue({
+				key: "keyB",
+				value: 1
+			}, { orderingKey: "keyB" });
+			await mq1.enqueue({
+				key: "keyA",
+				value: 2
+			}, { orderingKey: "keyA" });
+			await mq1.enqueue({
+				key: "keyB",
+				value: 2
+			}, { orderingKey: "keyB" });
+			await mq1.enqueue({
+				key: "keyA",
+				value: 3
+			}, { orderingKey: "keyA" });
+			await mq1.enqueue({
+				key: "keyB",
+				value: 3
+			}, { orderingKey: "keyB" });
+			await mq1.enqueue({
+				key: null,
+				value: 1
+			});
+			await mq1.enqueue({
+				key: null,
+				value: 2
+			});
+			await waitFor(() => orderMessages.length >= 8, 3e4);
+			(0, node_assert_strict.deepStrictEqual)(orderTracker.keyA, [
+				1,
+				2,
+				3
+			], "Messages with orderingKey 'keyA' should be processed in order");
+			(0, node_assert_strict.deepStrictEqual)(orderTracker.keyB, [
+				1,
+				2,
+				3
+			], "Messages with orderingKey 'keyB' should be processed in order");
+			(0, node_assert_strict.strictEqual)(orderTracker.noKey.length, 2, "Messages without ordering key should all be received");
+			(0, node_assert_strict.ok)(orderTracker.noKey.includes(1) && orderTracker.noKey.includes(2), "Messages without ordering key should contain values 1 and 2");
+			orderController.abort();
+			await orderListening1;
+			await orderListening2;
+		} else {
+			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/fedify/vocab";
+import { Activity } from "@fedify/vocab";
+import { MessageQueue } from "@fedify/fedify";
 
 //#region src/context.d.ts
 declare function createContext<TContextData>(values: Partial<Context<TContextData>> & {
@@ -91,7 +92,7 @@ interface TestFederation<TContextData> extends Omit<Federation<TContextData>, "c
  *
  * @example
  * ```typescript
- * import { Create } from "@fedify/fedify/vocab";
+ * import { Create } from "@fedify/vocab";
  * import { createFederation } from "@fedify/testing";
  *
  * // Create a mock federation with contextData
@@ -123,4 +124,74 @@ declare function createFederation<TContextData>(options?: {
   tracerProvider?: any;
 }): TestFederation<TContextData>;
 //#endregion
-export { createContext, createFederation, createInboxContext, createRequestContext };
+//#region src/mq-tester.d.ts
+/**
+ * Options for {@link testMessageQueue}.
+ */
+interface TestMessageQueueOptions {
+  /**
+   * Whether to test ordering key support.  If `true`, tests will verify that
+   * messages with the same ordering key are processed in order, while messages
+   * with different ordering keys can be processed in parallel.
+   *
+   * Set this to `true` only if your message queue implementation supports
+   * the `orderingKey` option.
+   *
+   * @default false
+   */
+  readonly testOrderingKey?: boolean;
+}
+/**
+ * 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
+ * - Ordering key support (optional): Ensures messages with the same ordering
+ *   key are processed in order
+ *
+ * @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();
+ *     },
+ *     { testOrderingKey: true },  // Enable ordering key tests
+ *   )
+ * );
+ * ```
+ *
+ * @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.
+ * @param options Optional configuration for the test suite.
+ * @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, options?: TestMessageQueueOptions): Promise<void>;
+declare function waitFor(predicate: () => boolean, timeoutMs: number): Promise<void>;
+declare const getRandomKey: (prefix: string) => string;
+//#endregion
+export { TestMessageQueueOptions, createContext, createFederation, createInboxContext, createRequestContext, getRandomKey, testMessageQueue, waitFor };

package/dist/mod.d.ts

@@ -1,5 +1,7 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { Activity } from "@fedify/vocab";
 import { Context, Federation, InboxContext, RequestContext } from "@fedify/fedify/federation";
-import { Activity } from "@fedify/fedify/vocab";
+import { MessageQueue } from "@fedify/fedify";
 
 //#region src/context.d.ts
 declare function createContext<TContextData>(values: Partial<Context<TContextData>> & {
@@ -91,7 +93,7 @@ interface TestFederation<TContextData> extends Omit<Federation<TContextData>, "c
  *
  * @example
  * ```typescript
- * import { Create } from "@fedify/fedify/vocab";
+ * import { Create } from "@fedify/vocab";
  * import { createFederation } from "@fedify/testing";
  *
  * // Create a mock federation with contextData
@@ -123,4 +125,74 @@ declare function createFederation<TContextData>(options?: {
   tracerProvider?: any;
 }): TestFederation<TContextData>;
 //#endregion
-export { createContext, createFederation, createInboxContext, createRequestContext };
+//#region src/mq-tester.d.ts
+/**
+ * Options for {@link testMessageQueue}.
+ */
+interface TestMessageQueueOptions {
+  /**
+   * Whether to test ordering key support.  If `true`, tests will verify that
+   * messages with the same ordering key are processed in order, while messages
+   * with different ordering keys can be processed in parallel.
+   *
+   * Set this to `true` only if your message queue implementation supports
+   * the `orderingKey` option.
+   *
+   * @default false
+   */
+  readonly testOrderingKey?: boolean;
+}
+/**
+ * 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
+ * - Ordering key support (optional): Ensures messages with the same ordering
+ *   key are processed in order
+ *
+ * @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();
+ *     },
+ *     { testOrderingKey: true },  // Enable ordering key tests
+ *   )
+ * );
+ * ```
+ *
+ * @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.
+ * @param options Optional configuration for the test suite.
+ * @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, options?: TestMessageQueueOptions): Promise<void>;
+declare function waitFor(predicate: () => boolean, timeoutMs: number): Promise<void>;
+declare const getRandomKey: (prefix: string) => string;
+//#endregion
+export { TestMessageQueueOptions, createContext, createFederation, createInboxContext, createRequestContext, getRandomKey, testMessageQueue, waitFor };

package/dist/mod.js

@@ -1,5 +1,10 @@
+
+        import { Temporal } from "@js-temporal/polyfill";
+      
+import { CryptographicKey, Multikey, lookupObject, traverseCollection } from "@fedify/vocab";
 import { RouterError } from "@fedify/fedify/federation";
-import { lookupObject, traverseCollection } from "@fedify/fedify/vocab";
+import { delay } from "es-toolkit";
+import { deepStrictEqual, ok, strictEqual } from "node:assert/strict";
 
 //#region src/docloader.ts
 const mockDocumentLoader = async (url) => ({
@@ -16,7 +21,7 @@ const noopTracerProvider$1 = { getTracer: () => ({
 }) };
 function createContext(values) {
 	const { federation, url = new URL("http://example.com/"), canonicalOrigin, data, documentLoader, contextLoader, tracerProvider, clone, getNodeInfoUri, getActorUri, getObjectUri, getCollectionUri, getOutboxUri, getInboxUri, getFollowingUri, getFollowersUri, getLikedUri, getFeaturedUri, getFeaturedTagsUri, parseUri, getActorKeyPairs, getDocumentLoader, lookupObject: lookupObject$1, traverseCollection: traverseCollection$1, lookupNodeInfo, lookupWebFinger, sendActivity, routeActivity } = values;
-	function throwRouteError() {
+	function throwRouterError() {
 		throw new RouterError("Not implemented");
 	}
 	return {
@@ -33,17 +38,17 @@ function createContext(values) {
 			...values,
 			data: data$1
 		})),
-		getNodeInfoUri: getNodeInfoUri ?? throwRouteError,
-		getActorUri: getActorUri ?? throwRouteError,
-		getObjectUri: getObjectUri ?? throwRouteError,
-		getCollectionUri: getCollectionUri ?? throwRouteError,
-		getOutboxUri: getOutboxUri ?? throwRouteError,
-		getInboxUri: getInboxUri ?? throwRouteError,
-		getFollowingUri: getFollowingUri ?? throwRouteError,
-		getFollowersUri: getFollowersUri ?? throwRouteError,
-		getLikedUri: getLikedUri ?? throwRouteError,
-		getFeaturedUri: getFeaturedUri ?? throwRouteError,
-		getFeaturedTagsUri: getFeaturedTagsUri ?? throwRouteError,
+		getNodeInfoUri: getNodeInfoUri ?? throwRouterError,
+		getActorUri: getActorUri ?? throwRouterError,
+		getObjectUri: getObjectUri ?? throwRouterError,
+		getCollectionUri: getCollectionUri ?? throwRouterError,
+		getOutboxUri: getOutboxUri ?? throwRouterError,
+		getInboxUri: getInboxUri ?? throwRouterError,
+		getFollowingUri: getFollowingUri ?? throwRouterError,
+		getFollowersUri: getFollowersUri ?? throwRouterError,
+		getLikedUri: getLikedUri ?? throwRouterError,
+		getFeaturedUri: getFeaturedUri ?? throwRouterError,
+		getFeaturedTagsUri: getFeaturedTagsUri ?? throwRouterError,
 		parseUri: parseUri ?? ((_uri) => {
 			throw new Error("Not implemented");
 		}),
@@ -148,7 +153,7 @@ function expandUriTemplate(template, values) {
 *
 * @example
 * ```typescript
-* import { Create } from "@fedify/fedify/vocab";
+* import { Create } from "@fedify/vocab";
 * import { createFederation } from "@fedify/testing";
 *
 * // Create a mock federation with contextData
@@ -182,6 +187,7 @@ var MockFederation = class {
 	nodeInfoDispatcher;
 	webFingerDispatcher;
 	actorDispatchers = /* @__PURE__ */ new Map();
+	actorKeyPairsDispatcher;
 	actorPath;
 	inboxPath;
 	outboxPath;
@@ -219,7 +225,10 @@ var MockFederation = class {
 		this.actorDispatchers.set(path, dispatcher);
 		this.actorPath = path;
 		return {
-			setKeyPairsDispatcher: () => this,
+			setKeyPairsDispatcher: (keyPairsDispatcher) => {
+				this.actorKeyPairsDispatcher = keyPairsDispatcher;
+				return this;
+			},
 			mapHandle: () => this,
 			mapAlias: () => this,
 			authorize: () => this
@@ -321,6 +330,7 @@ var MockFederation = class {
 			}
 		};
 	}
+	setOutboxPermanentFailureHandler(_handler) {}
 	async startQueue(contextData, options) {
 		this.contextData = contextData;
 		this.queueStarted = true;
@@ -405,7 +415,7 @@ var MockFederation = class {
 *
 * @example
 * ```typescript
-* import { Create } from "@fedify/fedify/vocab";
+* import { Create } from "@fedify/vocab";
 * import { createFederation } from "@fedify/testing";
 *
 * // Create a mock federation with contextData
@@ -447,7 +457,7 @@ function createFederation(options = {}) {
 *
 * @example
 * ```typescript
-* import { Person, Create } from "@fedify/fedify/vocab";
+* import { Person, Create } from "@fedify/vocab";
 * import { createFederation } from "@fedify/testing";
 *
 * // Create a mock federation and context
@@ -508,11 +518,22 @@ var MockContext = class MockContext {
 		this.contextLoader = options.contextLoader ?? this.documentLoader;
 		this.tracerProvider = options.tracerProvider ?? noopTracerProvider;
 	}
-	getActor(_handle) {
-		return Promise.resolve(null);
+	async getActor(handle) {
+		if (this.federation instanceof MockFederation && this.federation.actorPath) {
+			const dispatcher = this.federation.actorDispatchers.get(this.federation.actorPath);
+			if (dispatcher) return await dispatcher(this, handle);
+		}
+		return null;
 	}
-	getObject(_cls, _values) {
-		return Promise.resolve(null);
+	async getObject(cls, values) {
+		if (this.federation instanceof MockFederation) {
+			const path = this.federation.objectPaths.get(cls.typeId.href);
+			if (path) {
+				const dispatcher = this.federation.objectDispatchers.get(path);
+				if (dispatcher) return await dispatcher(this, values);
+			}
+		}
+		return null;
 	}
 	getSignedKey() {
 		return Promise.resolve(null);
@@ -644,8 +665,25 @@ var MockContext = class MockContext {
 		}
 		return null;
 	}
-	getActorKeyPairs(_identifier) {
-		return Promise.resolve([]);
+	async getActorKeyPairs(identifier) {
+		if (this.federation instanceof MockFederation && this.federation.actorKeyPairsDispatcher) {
+			const keyPairs = await this.federation.actorKeyPairsDispatcher(this, identifier);
+			const owner = this.getActorUri(identifier);
+			return keyPairs.map((kp) => ({
+				...kp,
+				cryptographicKey: new CryptographicKey({
+					id: kp.keyId,
+					owner,
+					publicKey: kp.publicKey
+				}),
+				multikey: new Multikey({
+					id: kp.keyId,
+					controller: owner,
+					publicKey: kp.publicKey
+				})
+			}));
+		}
+		return [];
 	}
 	getDocumentLoader(params) {
 		if ("keyId" in params) return this.documentLoader;
@@ -704,4 +742,183 @@ 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
+* - Ordering key support (optional): Ensures messages with the same ordering
+*   key are processed in order
+*
+* @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();
+*     },
+*     { testOrderingKey: true },  // Enable ordering key tests
+*   )
+* );
+* ```
+*
+* @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.
+* @param options Optional configuration for the test suite.
+* @returns A promise that resolves when all tests pass.
+*/
+async function testMessageQueue(getMessageQueue, onFinally, options = {}) {
+	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);
+		if (options.testOrderingKey) {
+			while (messages.length > 0) messages.pop();
+			const orderTracker = {
+				keyA: [],
+				keyB: [],
+				noKey: []
+			};
+			controller.abort();
+			await listening1;
+			await listening2;
+			const orderController = new AbortController();
+			const orderMessages = [];
+			const orderListening1 = mq1.listen((message) => {
+				orderMessages.push(message);
+				const trackKey = message.key ?? "noKey";
+				if (trackKey in orderTracker) orderTracker[trackKey].push(message.value);
+			}, { signal: orderController.signal });
+			const orderListening2 = mq2.listen((message) => {
+				orderMessages.push(message);
+				const trackKey = message.key ?? "noKey";
+				if (trackKey in orderTracker) orderTracker[trackKey].push(message.value);
+			}, { signal: orderController.signal });
+			await mq1.enqueue({
+				key: "keyA",
+				value: 1
+			}, { orderingKey: "keyA" });
+			await mq1.enqueue({
+				key: "keyB",
+				value: 1
+			}, { orderingKey: "keyB" });
+			await mq1.enqueue({
+				key: "keyA",
+				value: 2
+			}, { orderingKey: "keyA" });
+			await mq1.enqueue({
+				key: "keyB",
+				value: 2
+			}, { orderingKey: "keyB" });
+			await mq1.enqueue({
+				key: "keyA",
+				value: 3
+			}, { orderingKey: "keyA" });
+			await mq1.enqueue({
+				key: "keyB",
+				value: 3
+			}, { orderingKey: "keyB" });
+			await mq1.enqueue({
+				key: null,
+				value: 1
+			});
+			await mq1.enqueue({
+				key: null,
+				value: 2
+			});
+			await waitFor(() => orderMessages.length >= 8, 3e4);
+			deepStrictEqual(orderTracker.keyA, [
+				1,
+				2,
+				3
+			], "Messages with orderingKey 'keyA' should be processed in order");
+			deepStrictEqual(orderTracker.keyB, [
+				1,
+				2,
+				3
+			], "Messages with orderingKey 'keyB' should be processed in order");
+			strictEqual(orderTracker.noKey.length, 2, "Messages without ordering key should all be received");
+			ok(orderTracker.noKey.includes(1) && orderTracker.noKey.includes(2), "Messages without ordering key should contain values 1 and 2");
+			orderController.abort();
+			await orderListening1;
+			await orderListening2;
+		} else {
+			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-pr.490.2+99a396d5",
+  "version": "2.0.0-pr.559.4+6357309b",
   "description": "Testing utilities for Fedify applications",
   "keywords": [
     "fedify",
@@ -50,21 +50,28 @@
     "package.json"
   ],
   "peerDependencies": {
-    "@fedify/fedify": "^2.0.0-pr.490.2+99a396d5"
+    "@fedify/fedify": "^2.0.0-pr.559.4+6357309b"
+  },
+  "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",
-    "prepublish": "tsdown",
-    "test": "tsdown && node --experimental-transform-types --test",
-    "test:bun": "tsdown && bun test --timeout 15000",
+    "build:self": "tsdown",
+    "build": "pnpm --filter @fedify/testing... run build:self",
+    "prepublish": "pnpm build",
+    "pretest": "pnpm build",
+    "test": "node --experimental-transform-types --test",
+    "pretest:bun": "pnpm build",
+    "test:bun": "bun test --timeout 15000",
     "test:deno": "deno task test",
-    "test-all": "tsdown && node --experimental-transform-types --test && bun test --timeout 15000 && deno task test"
+    "test-all": "pnpm build && node --experimental-transform-types --test && bun test --timeout 15000 && deno task test"
   }
 }