@fedify/testing 2.0.0-dev.1604 → 2.0.0-dev.1690

package/dist/mod.cjs

@@ -0,0 +1,667 @@
+//#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 __opentelemetry_api = __toESM(require("@opentelemetry/api"));
+const __fedify_fedify_federation = __toESM(require("@fedify/fedify/federation"));
+const __fedify_fedify_vocab = __toESM(require("@fedify/fedify/vocab"));
+const __fedify_fedify_webfinger = __toESM(require("@fedify/fedify/webfinger"));
+
+//#region src/docloader.ts
+const mockDocumentLoader = async (url) => ({
+	contextUrl: null,
+	document: {},
+	documentUrl: url
+});
+
+//#endregion
+//#region src/context.ts
+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() {
+		throw new __fedify_fedify_federation.RouterError("Not implemented");
+	}
+	return {
+		federation,
+		data,
+		origin: url.origin,
+		canonicalOrigin: canonicalOrigin ?? url.origin,
+		host: url.host,
+		hostname: url.hostname,
+		documentLoader: documentLoader ?? mockDocumentLoader,
+		contextLoader: contextLoader ?? mockDocumentLoader,
+		tracerProvider: tracerProvider ?? __opentelemetry_api.trace.getTracerProvider(),
+		clone: clone ?? ((data$1) => createContext({
+			...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,
+		parseUri: parseUri ?? ((_uri) => {
+			throw new Error("Not implemented");
+		}),
+		getDocumentLoader: getDocumentLoader ?? ((_params) => {
+			throw new Error("Not implemented");
+		}),
+		getActorKeyPairs: getActorKeyPairs ?? ((_handle) => Promise.resolve([])),
+		lookupObject: lookupObject ?? ((uri, options = {}) => {
+			return (0, __fedify_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, {
+				documentLoader: options.documentLoader ?? documentLoader ?? mockDocumentLoader,
+				contextLoader: options.contextLoader ?? contextLoader ?? mockDocumentLoader
+			});
+		}),
+		lookupNodeInfo: lookupNodeInfo ?? ((_params) => {
+			throw new Error("Not implemented");
+		}),
+		lookupWebFinger: lookupWebFinger ?? ((resource, options = {}) => {
+			return (0, __fedify_fedify_webfinger.lookupWebFinger)(resource, options);
+		}),
+		sendActivity: sendActivity ?? ((_params) => {
+			throw new Error("Not implemented");
+		}),
+		routeActivity: routeActivity ?? ((_params) => {
+			throw new Error("Not implemented");
+		})
+	};
+}
+function createRequestContext(args) {
+	return {
+		...createContext(args),
+		clone: args.clone ?? ((data) => createRequestContext({
+			...args,
+			data
+		})),
+		request: args.request ?? new Request(args.url),
+		url: args.url,
+		getActor: args.getActor ?? (() => Promise.resolve(null)),
+		getObject: args.getObject ?? (() => Promise.resolve(null)),
+		getSignedKey: args.getSignedKey ?? (() => Promise.resolve(null)),
+		getSignedKeyOwner: args.getSignedKeyOwner ?? (() => Promise.resolve(null)),
+		sendActivity: args.sendActivity ?? ((_params) => {
+			throw new Error("Not implemented");
+		})
+	};
+}
+function createInboxContext(args) {
+	return {
+		...createContext(args),
+		clone: args.clone ?? ((data) => createInboxContext({
+			...args,
+			data
+		})),
+		recipient: args.recipient ?? null,
+		forwardActivity: args.forwardActivity ?? ((_params) => {
+			throw new Error("Not implemented");
+		})
+	};
+}
+
+//#endregion
+//#region src/mock.ts
+/**
+* Helper function to expand URI templates with values.
+* Supports simple placeholders like {identifier}, {handle}, etc.
+* @param template The URI template pattern
+* @param values The values to substitute
+* @returns The expanded URI path
+*/
+function expandUriTemplate(template, values) {
+	return template.replace(/{([^}]+)}/g, (match, key) => {
+		return values[key] || match;
+	});
+}
+/**
+* A mock implementation of the {@link Federation} interface for unit testing.
+* This class provides a way to test Fedify applications without needing
+* a real federation setup.
+*
+* @example
+* ```typescript
+* import { Create } from "@fedify/fedify/vocab";
+* import { MockFederation } from "@fedify/testing";
+*
+* // Create a mock federation with contextData
+* const federation = new MockFederation<{ userId: string }>({
+*   contextData: { userId: "test-user" }
+* });
+*
+* // Set up inbox listeners
+* federation
+*   .setInboxListeners("/users/{identifier}/inbox")
+*   .on(Create, async (ctx, activity) => {
+*     console.log("Received:", activity);
+*   });
+*
+* // Simulate receiving an activity
+* const createActivity = new Create({
+*   id: new URL("https://example.com/create/1"),
+*   actor: new URL("https://example.com/users/alice")
+* });
+* await federation.receiveActivity(createActivity);
+* ```
+*
+* @template TContextData The context data to pass to the {@link Context}.
+* @since 1.8.0
+*/
+var MockFederation = class {
+	sentActivities = [];
+	queueStarted = false;
+	activeQueues = /* @__PURE__ */ new Set();
+	sentCounter = 0;
+	nodeInfoDispatcher;
+	webFingerDispatcher;
+	actorDispatchers = /* @__PURE__ */ new Map();
+	actorPath;
+	inboxPath;
+	outboxPath;
+	followingPath;
+	followersPath;
+	likedPath;
+	featuredPath;
+	featuredTagsPath;
+	nodeInfoPath;
+	sharedInboxPath;
+	objectPaths = /* @__PURE__ */ new Map();
+	objectDispatchers = /* @__PURE__ */ new Map();
+	inboxDispatcher;
+	outboxDispatcher;
+	followingDispatcher;
+	followersDispatcher;
+	likedDispatcher;
+	featuredDispatcher;
+	featuredTagsDispatcher;
+	inboxListeners = /* @__PURE__ */ new Map();
+	contextData;
+	receivedActivities = [];
+	constructor(options = {}) {
+		this.options = options;
+		this.contextData = options.contextData;
+	}
+	setNodeInfoDispatcher(path, dispatcher) {
+		this.nodeInfoDispatcher = dispatcher;
+		this.nodeInfoPath = path;
+	}
+	setWebFingerLinksDispatcher(dispatcher) {
+		this.webFingerDispatcher = dispatcher;
+	}
+	setActorDispatcher(path, dispatcher) {
+		this.actorDispatchers.set(path, dispatcher);
+		this.actorPath = path;
+		return {
+			setKeyPairsDispatcher: () => this,
+			mapHandle: () => this,
+			mapAlias: () => this,
+			authorize: () => this
+		};
+	}
+	setObjectDispatcher(cls, path, dispatcher) {
+		this.objectDispatchers.set(path, dispatcher);
+		this.objectPaths.set(cls.typeId.href, path);
+		return { authorize: () => this };
+	}
+	setInboxDispatcher(_path, dispatcher) {
+		this.inboxDispatcher = dispatcher;
+		return {
+			setCounter: () => this,
+			setFirstCursor: () => this,
+			setLastCursor: () => this,
+			authorize: () => this
+		};
+	}
+	setOutboxDispatcher(path, dispatcher) {
+		this.outboxDispatcher = dispatcher;
+		this.outboxPath = path;
+		return {
+			setCounter: () => this,
+			setFirstCursor: () => this,
+			setLastCursor: () => this,
+			authorize: () => this
+		};
+	}
+	setFollowingDispatcher(path, dispatcher) {
+		this.followingDispatcher = dispatcher;
+		this.followingPath = path;
+		return {
+			setCounter: () => this,
+			setFirstCursor: () => this,
+			setLastCursor: () => this,
+			authorize: () => this
+		};
+	}
+	setFollowersDispatcher(path, dispatcher) {
+		this.followersDispatcher = dispatcher;
+		this.followersPath = path;
+		return {
+			setCounter: () => this,
+			setFirstCursor: () => this,
+			setLastCursor: () => this,
+			authorize: () => this
+		};
+	}
+	setLikedDispatcher(path, dispatcher) {
+		this.likedDispatcher = dispatcher;
+		this.likedPath = path;
+		return {
+			setCounter: () => this,
+			setFirstCursor: () => this,
+			setLastCursor: () => this,
+			authorize: () => this
+		};
+	}
+	setFeaturedDispatcher(path, dispatcher) {
+		this.featuredDispatcher = dispatcher;
+		this.featuredPath = path;
+		return {
+			setCounter: () => this,
+			setFirstCursor: () => this,
+			setLastCursor: () => this,
+			authorize: () => this
+		};
+	}
+	setFeaturedTagsDispatcher(path, dispatcher) {
+		this.featuredTagsDispatcher = dispatcher;
+		this.featuredTagsPath = path;
+		return {
+			setCounter: () => this,
+			setFirstCursor: () => this,
+			setLastCursor: () => this,
+			authorize: () => this
+		};
+	}
+	setInboxListeners(inboxPath, sharedInboxPath) {
+		this.inboxPath = inboxPath;
+		this.sharedInboxPath = sharedInboxPath;
+		const self = this;
+		return {
+			on(type, listener) {
+				const typeName = type.name;
+				if (!self.inboxListeners.has(typeName)) self.inboxListeners.set(typeName, []);
+				self.inboxListeners.get(typeName).push(listener);
+				return this;
+			},
+			onError() {
+				return this;
+			},
+			setSharedKeyDispatcher() {
+				return this;
+			},
+			withIdempotency() {
+				return this;
+			}
+		};
+	}
+	async startQueue(contextData, options) {
+		this.contextData = contextData;
+		this.queueStarted = true;
+		if (options?.queue) this.activeQueues.add(options.queue);
+		else {
+			this.activeQueues.add("inbox");
+			this.activeQueues.add("outbox");
+			this.activeQueues.add("fanout");
+		}
+	}
+	async processQueuedTask(contextData, _message) {
+		this.contextData = contextData;
+	}
+	createContext(baseUrlOrRequest, contextData) {
+		const mockFederation = this;
+		if (baseUrlOrRequest instanceof Request) return createRequestContext({
+			url: new URL(baseUrlOrRequest.url),
+			request: baseUrlOrRequest,
+			data: contextData,
+			federation: mockFederation,
+			sendActivity: async (sender, recipients, activity, options) => {
+				const tempContext = new MockContext({
+					url: new URL(baseUrlOrRequest.url),
+					data: contextData,
+					federation: mockFederation
+				});
+				await tempContext.sendActivity(sender, recipients, activity, options);
+			}
+		});
+		else return new MockContext({
+			url: baseUrlOrRequest,
+			data: contextData,
+			federation: mockFederation
+		});
+	}
+	async fetch(request, options) {
+		if (options.onNotFound) return options.onNotFound(request);
+		return new Response("Not Found", { status: 404 });
+	}
+	/**
+	* Simulates receiving an activity. This method is specific to the mock
+	* implementation and is used for testing purposes.
+	*
+	* @param activity The activity to receive.
+	* @returns A promise that resolves when the activity has been processed.
+	* @since 1.8.0
+	*/
+	async receiveActivity(activity) {
+		this.receivedActivities.push(activity);
+		const typeName = activity.constructor.name;
+		const listeners = this.inboxListeners.get(typeName) || [];
+		if (listeners.length > 0 && this.contextData === void 0) throw new Error("MockFederation.receiveActivity(): contextData is not initialized. Please provide contextData through the constructor or call startQueue() before receiving activities.");
+		for (const listener of listeners) {
+			const context = createInboxContext({
+				data: this.contextData,
+				federation: this
+			});
+			await listener(context, activity);
+		}
+	}
+	/**
+	* Clears all sent activities from the mock federation.
+	* This method is specific to the mock implementation and is used for
+	* testing purposes.
+	*
+	* @since 1.8.0
+	*/
+	reset() {
+		this.sentActivities = [];
+	}
+	setCollectionDispatcher(_name, _itemType, _path, _dispatcher) {
+		return {
+			setCounter: () => this,
+			setFirstCursor: () => this,
+			setLastCursor: () => this,
+			authorize: () => this
+		};
+	}
+	setOrderedCollectionDispatcher(_name, _itemType, _path, _dispatcher) {
+		return {
+			setCounter: () => this,
+			setFirstCursor: () => this,
+			setLastCursor: () => this,
+			authorize: () => this
+		};
+	}
+};
+/**
+* A mock implementation of the {@link Context} interface for unit testing.
+* This class provides a way to test Fedify applications without needing
+* a real federation context.
+*
+* @example
+* ```typescript
+* import { Person, Create } from "@fedify/fedify/vocab";
+* import { MockContext, MockFederation } from "@fedify/testing";
+*
+* // Create a mock context
+* const mockFederation = new MockFederation<{ userId: string }>();
+* const context = new MockContext({
+*   url: new URL("https://example.com"),
+*   data: { userId: "test-user" },
+*   federation: mockFederation
+* });
+*
+* // Send an activity
+* const recipient = new Person({ id: new URL("https://example.com/users/bob") });
+* const activity = new Create({
+*   id: new URL("https://example.com/create/1"),
+*   actor: new URL("https://example.com/users/alice")
+* });
+* await context.sendActivity(
+*   { identifier: "alice" },
+*   recipient,
+*   activity
+* );
+*
+* // Check sent activities
+* const sent = context.getSentActivities();
+* console.log(sent[0].activity);
+* ```
+*
+* @template TContextData The context data to pass to the {@link Context}.
+* @since 1.8.0
+*/
+var MockContext = class MockContext {
+	origin;
+	canonicalOrigin;
+	host;
+	hostname;
+	data;
+	federation;
+	documentLoader;
+	contextLoader;
+	tracerProvider;
+	sentActivities = [];
+	constructor(options) {
+		const url = options.url ?? new URL("https://example.com");
+		this.origin = url.origin;
+		this.canonicalOrigin = url.origin;
+		this.host = url.host;
+		this.hostname = url.hostname;
+		this.data = options.data;
+		this.federation = options.federation;
+		this.documentLoader = options.documentLoader ?? (async (url$1) => ({
+			contextUrl: null,
+			document: {},
+			documentUrl: url$1
+		}));
+		this.contextLoader = options.contextLoader ?? this.documentLoader;
+		this.tracerProvider = options.tracerProvider ?? __opentelemetry_api.trace.getTracerProvider();
+	}
+	clone(data) {
+		return new MockContext({
+			url: new URL(this.origin),
+			data,
+			federation: this.federation,
+			documentLoader: this.documentLoader,
+			contextLoader: this.contextLoader,
+			tracerProvider: this.tracerProvider
+		});
+	}
+	getNodeInfoUri() {
+		if (this.federation instanceof MockFederation && this.federation.nodeInfoPath) return new URL(this.federation.nodeInfoPath, this.origin);
+		return new URL("/nodeinfo/2.0", this.origin);
+	}
+	getActorUri(identifier) {
+		if (this.federation instanceof MockFederation && this.federation.actorPath) {
+			const path = expandUriTemplate(this.federation.actorPath, {
+				identifier,
+				handle: identifier
+			});
+			return new URL(path, this.origin);
+		}
+		return new URL(`/users/${identifier}`, this.origin);
+	}
+	getObjectUri(cls, values) {
+		if (this.federation instanceof MockFederation) {
+			const pathTemplate = this.federation.objectPaths.get(cls.typeId.href);
+			if (pathTemplate) {
+				const path$1 = expandUriTemplate(pathTemplate, values);
+				return new URL(path$1, this.origin);
+			}
+		}
+		const path = globalThis.Object.entries(values).map(([key, value]) => `${key}/${value}`).join("/");
+		return new URL(`/objects/${cls.name.toLowerCase()}/${path}`, this.origin);
+	}
+	getOutboxUri(identifier) {
+		if (this.federation instanceof MockFederation && this.federation.outboxPath) {
+			const path = expandUriTemplate(this.federation.outboxPath, {
+				identifier,
+				handle: identifier
+			});
+			return new URL(path, this.origin);
+		}
+		return new URL(`/users/${identifier}/outbox`, this.origin);
+	}
+	getInboxUri(identifier) {
+		if (identifier) {
+			if (this.federation instanceof MockFederation && this.federation.inboxPath) {
+				const path = expandUriTemplate(this.federation.inboxPath, {
+					identifier,
+					handle: identifier
+				});
+				return new URL(path, this.origin);
+			}
+			return new URL(`/users/${identifier}/inbox`, this.origin);
+		}
+		if (this.federation instanceof MockFederation && this.federation.sharedInboxPath) return new URL(this.federation.sharedInboxPath, this.origin);
+		return new URL("/inbox", this.origin);
+	}
+	getFollowingUri(identifier) {
+		if (this.federation instanceof MockFederation && this.federation.followingPath) {
+			const path = expandUriTemplate(this.federation.followingPath, {
+				identifier,
+				handle: identifier
+			});
+			return new URL(path, this.origin);
+		}
+		return new URL(`/users/${identifier}/following`, this.origin);
+	}
+	getFollowersUri(identifier) {
+		if (this.federation instanceof MockFederation && this.federation.followersPath) {
+			const path = expandUriTemplate(this.federation.followersPath, {
+				identifier,
+				handle: identifier
+			});
+			return new URL(path, this.origin);
+		}
+		return new URL(`/users/${identifier}/followers`, this.origin);
+	}
+	getLikedUri(identifier) {
+		if (this.federation instanceof MockFederation && this.federation.likedPath) {
+			const path = expandUriTemplate(this.federation.likedPath, {
+				identifier,
+				handle: identifier
+			});
+			return new URL(path, this.origin);
+		}
+		return new URL(`/users/${identifier}/liked`, this.origin);
+	}
+	getFeaturedUri(identifier) {
+		if (this.federation instanceof MockFederation && this.federation.featuredPath) {
+			const path = expandUriTemplate(this.federation.featuredPath, {
+				identifier,
+				handle: identifier
+			});
+			return new URL(path, this.origin);
+		}
+		return new URL(`/users/${identifier}/featured`, this.origin);
+	}
+	getFeaturedTagsUri(identifier) {
+		if (this.federation instanceof MockFederation && this.federation.featuredTagsPath) {
+			const path = expandUriTemplate(this.federation.featuredTagsPath, {
+				identifier,
+				handle: identifier
+			});
+			return new URL(path, this.origin);
+		}
+		return new URL(`/users/${identifier}/tags`, this.origin);
+	}
+	getCollectionUri(_name, values) {
+		const path = globalThis.Object.entries(values).map(([key, value]) => `${key}/${value}`).join("/");
+		return new URL(`/collections/${String(_name)}/${path}`, this.origin);
+	}
+	parseUri(uri) {
+		if (uri.pathname.startsWith("/users/")) {
+			const parts = uri.pathname.split("/");
+			if (parts.length >= 3) return {
+				type: "actor",
+				identifier: parts[2],
+				handle: parts[2]
+			};
+		}
+		return null;
+	}
+	getActorKeyPairs(_identifier) {
+		return Promise.resolve([]);
+	}
+	getDocumentLoader(params) {
+		if ("keyId" in params) return this.documentLoader;
+		return Promise.resolve(this.documentLoader);
+	}
+	lookupObject(_uri, _options) {
+		return Promise.resolve(null);
+	}
+	traverseCollection(_collection, _options) {
+		return { async *[Symbol.asyncIterator]() {} };
+	}
+	lookupNodeInfo(_url, _options) {
+		return Promise.resolve(void 0);
+	}
+	lookupWebFinger(_resource, _options) {
+		return Promise.resolve(null);
+	}
+	sendActivity(sender, recipients, activity, _options) {
+		this.sentActivities.push({
+			sender,
+			recipients,
+			activity
+		});
+		if (this.federation instanceof MockFederation) {
+			const queued = this.federation.queueStarted;
+			this.federation.sentActivities.push({
+				queued,
+				queue: queued ? "outbox" : void 0,
+				activity,
+				sentOrder: ++this.federation.sentCounter
+			});
+		}
+		return Promise.resolve();
+	}
+	routeActivity(_recipient, _activity, _options) {
+		return Promise.resolve(true);
+	}
+	/**
+	* Gets all activities that have been sent through this mock context.
+	* This method is specific to the mock implementation and is used for
+	* testing purposes.
+	*
+	* @returns An array of sent activity records.
+	*/
+	getSentActivities() {
+		return [...this.sentActivities];
+	}
+	/**
+	* Clears all sent activities from the mock context.
+	* This method is specific to the mock implementation and is used for
+	* testing purposes.
+	*/
+	reset() {
+		this.sentActivities = [];
+	}
+};
+
+//#endregion
+exports.MockContext = MockContext;
+exports.MockFederation = MockFederation;
+exports.createContext = createContext;
+exports.createInboxContext = createInboxContext;
+exports.createRequestContext = createRequestContext;

package/dist/mod.d.cts

@@ -0,0 +1,297 @@
+import { ActorCallbackSetters, ActorDispatcher, ActorKeyPair, CollectionCallbackSetters, CollectionDispatcher, Context, Federation, FederationFetchOptions, FederationStartQueueOptions, InboxContext, InboxListenerSetters, Message, NodeInfoDispatcher, ObjectCallbackSetters, ObjectDispatcher, ParseUriResult, RequestContext, RouteActivityOptions, SendActivityOptions, SendActivityOptionsForCollection, SenderKeyPair, WebFingerLinksDispatcher } from "@fedify/fedify/federation";
+import { JsonValue, NodeInfo } from "@fedify/fedify/nodeinfo";
+import { DocumentLoader } from "@fedify/fedify/runtime";
+import { Activity, Actor, Collection, Hashtag, LookupObjectOptions, Object as Object$1, Recipient, TraverseCollectionOptions } from "@fedify/fedify/vocab";
+import { ResourceDescriptor } from "@fedify/fedify/webfinger";
+import { TracerProvider } from "@opentelemetry/api";
+
+//#region src/mock.d.ts
+
+/**
+ * Represents a sent activity with metadata about how it was sent.
+ * @since 1.8.0
+ */
+interface SentActivity {
+  /** Whether the activity was queued or sent immediately. */
+  queued: boolean;
+  /** Which queue was used (if queued). */
+  queue?: "inbox" | "outbox" | "fanout";
+  /** The activity that was sent. */
+  activity: Activity;
+  /** The order in which the activity was sent (auto-incrementing counter). */
+  sentOrder: number;
+}
+/**
+ * A mock implementation of the {@link Federation} interface for unit testing.
+ * This class provides a way to test Fedify applications without needing
+ * a real federation setup.
+ *
+ * @example
+ * ```typescript
+ * import { Create } from "@fedify/fedify/vocab";
+ * import { MockFederation } from "@fedify/testing";
+ *
+ * // Create a mock federation with contextData
+ * const federation = new MockFederation<{ userId: string }>({
+ *   contextData: { userId: "test-user" }
+ * });
+ *
+ * // Set up inbox listeners
+ * federation
+ *   .setInboxListeners("/users/{identifier}/inbox")
+ *   .on(Create, async (ctx, activity) => {
+ *     console.log("Received:", activity);
+ *   });
+ *
+ * // Simulate receiving an activity
+ * const createActivity = new Create({
+ *   id: new URL("https://example.com/create/1"),
+ *   actor: new URL("https://example.com/users/alice")
+ * });
+ * await federation.receiveActivity(createActivity);
+ * ```
+ *
+ * @template TContextData The context data to pass to the {@link Context}.
+ * @since 1.8.0
+ */
+declare class MockFederation<TContextData> implements Federation<TContextData> {
+  private options;
+  sentActivities: SentActivity[];
+  queueStarted: boolean;
+  private activeQueues;
+  sentCounter: number;
+  private nodeInfoDispatcher?;
+  private webFingerDispatcher?;
+  private actorDispatchers;
+  actorPath?: string;
+  inboxPath?: string;
+  outboxPath?: string;
+  followingPath?: string;
+  followersPath?: string;
+  likedPath?: string;
+  featuredPath?: string;
+  featuredTagsPath?: string;
+  nodeInfoPath?: string;
+  sharedInboxPath?: string;
+  objectPaths: Map<string, string>;
+  private objectDispatchers;
+  private inboxDispatcher?;
+  private outboxDispatcher?;
+  private followingDispatcher?;
+  private followersDispatcher?;
+  private likedDispatcher?;
+  private featuredDispatcher?;
+  private featuredTagsDispatcher?;
+  private inboxListeners;
+  private contextData?;
+  private receivedActivities;
+  constructor(options?: {
+    contextData?: TContextData;
+    origin?: string;
+    tracerProvider?: TracerProvider;
+  });
+  setNodeInfoDispatcher(path: string, dispatcher: NodeInfoDispatcher<TContextData>): void;
+  setWebFingerLinksDispatcher(dispatcher: WebFingerLinksDispatcher<TContextData>): void;
+  setActorDispatcher(path: `${string}{identifier}${string}` | `${string}{handle}${string}`, dispatcher: ActorDispatcher<TContextData>): ActorCallbackSetters<TContextData>;
+  setObjectDispatcher<TObject extends Object$1, TParam extends string>(cls: (new (...args: any[]) => TObject) & {
+    typeId: URL;
+  }, path: string, dispatcher: ObjectDispatcher<TContextData, TObject, TParam>): ObjectCallbackSetters<TContextData, TObject, TParam>;
+  setInboxDispatcher(_path: `${string}{identifier}${string}` | `${string}{handle}${string}`, dispatcher: CollectionDispatcher<Activity, RequestContext<TContextData>, TContextData, void>): CollectionCallbackSetters<RequestContext<TContextData>, TContextData, void>;
+  setOutboxDispatcher(path: `${string}{identifier}${string}` | `${string}{handle}${string}`, dispatcher: CollectionDispatcher<Activity, RequestContext<TContextData>, TContextData, void>): CollectionCallbackSetters<RequestContext<TContextData>, TContextData, void>;
+  setFollowingDispatcher(path: `${string}{identifier}${string}` | `${string}{handle}${string}`, dispatcher: CollectionDispatcher<Actor | URL, RequestContext<TContextData>, TContextData, void>): CollectionCallbackSetters<RequestContext<TContextData>, TContextData, void>;
+  setFollowersDispatcher(path: `${string}{identifier}${string}` | `${string}{handle}${string}`, dispatcher: CollectionDispatcher<Recipient, Context<TContextData>, TContextData, URL>): CollectionCallbackSetters<Context<TContextData>, TContextData, URL>;
+  setLikedDispatcher(path: `${string}{identifier}${string}` | `${string}{handle}${string}`, dispatcher: CollectionDispatcher<Object$1 | URL, RequestContext<TContextData>, TContextData, void>): CollectionCallbackSetters<RequestContext<TContextData>, TContextData, void>;
+  setFeaturedDispatcher(path: `${string}{identifier}${string}` | `${string}{handle}${string}`, dispatcher: CollectionDispatcher<Object$1, RequestContext<TContextData>, TContextData, void>): CollectionCallbackSetters<RequestContext<TContextData>, TContextData, void>;
+  setFeaturedTagsDispatcher(path: `${string}{identifier}${string}` | `${string}{handle}${string}`, dispatcher: CollectionDispatcher<Hashtag, RequestContext<TContextData>, TContextData, void>): CollectionCallbackSetters<RequestContext<TContextData>, TContextData, void>;
+  setInboxListeners(inboxPath: `${string}{identifier}${string}` | `${string}{handle}${string}`, sharedInboxPath?: string): InboxListenerSetters<TContextData>;
+  startQueue(contextData: TContextData, options?: FederationStartQueueOptions): Promise<void>;
+  processQueuedTask(contextData: TContextData, _message: Message): Promise<void>;
+  createContext(baseUrl: URL, contextData: TContextData): Context<TContextData>;
+  createContext(request: Request, contextData: TContextData): RequestContext<TContextData>;
+  fetch(request: Request, options: FederationFetchOptions<TContextData>): Promise<Response>;
+  /**
+   * Simulates receiving an activity. This method is specific to the mock
+   * implementation and is used for testing purposes.
+   *
+   * @param activity The activity to receive.
+   * @returns A promise that resolves when the activity has been processed.
+   * @since 1.8.0
+   */
+  receiveActivity(activity: Activity): Promise<void>;
+  /**
+   * Clears all sent activities from the mock federation.
+   * This method is specific to the mock implementation and is used for
+   * testing purposes.
+   *
+   * @since 1.8.0
+   */
+  reset(): void;
+  setCollectionDispatcher<TObject extends Object$1, TParams extends Record<string, string>>(_name: string | symbol, _itemType: any, _path: any, _dispatcher: any): any;
+  setOrderedCollectionDispatcher<TObject extends Object$1, TParams extends Record<string, string>>(_name: string | symbol, _itemType: any, _path: any, _dispatcher: any): any;
+}
+/**
+ * A mock implementation of the {@link Context} interface for unit testing.
+ * This class provides a way to test Fedify applications without needing
+ * a real federation context.
+ *
+ * @example
+ * ```typescript
+ * import { Person, Create } from "@fedify/fedify/vocab";
+ * import { MockContext, MockFederation } from "@fedify/testing";
+ *
+ * // Create a mock context
+ * const mockFederation = new MockFederation<{ userId: string }>();
+ * const context = new MockContext({
+ *   url: new URL("https://example.com"),
+ *   data: { userId: "test-user" },
+ *   federation: mockFederation
+ * });
+ *
+ * // Send an activity
+ * const recipient = new Person({ id: new URL("https://example.com/users/bob") });
+ * const activity = new Create({
+ *   id: new URL("https://example.com/create/1"),
+ *   actor: new URL("https://example.com/users/alice")
+ * });
+ * await context.sendActivity(
+ *   { identifier: "alice" },
+ *   recipient,
+ *   activity
+ * );
+ *
+ * // Check sent activities
+ * const sent = context.getSentActivities();
+ * console.log(sent[0].activity);
+ * ```
+ *
+ * @template TContextData The context data to pass to the {@link Context}.
+ * @since 1.8.0
+ */
+declare class MockContext<TContextData> implements Context<TContextData> {
+  readonly origin: string;
+  readonly canonicalOrigin: string;
+  readonly host: string;
+  readonly hostname: string;
+  readonly data: TContextData;
+  readonly federation: Federation<TContextData>;
+  readonly documentLoader: DocumentLoader;
+  readonly contextLoader: DocumentLoader;
+  readonly tracerProvider: TracerProvider;
+  private sentActivities;
+  constructor(options: {
+    url?: URL;
+    data: TContextData;
+    federation: Federation<TContextData>;
+    documentLoader?: DocumentLoader;
+    contextLoader?: DocumentLoader;
+    tracerProvider?: TracerProvider;
+  });
+  clone(data: TContextData): Context<TContextData>;
+  getNodeInfoUri(): URL;
+  getActorUri(identifier: string): URL;
+  getObjectUri<TObject extends Object$1>(cls: (new (...args: any[]) => TObject) & {
+    typeId: URL;
+  }, values: Record<string, string>): URL;
+  getOutboxUri(identifier: string): URL;
+  getInboxUri(identifier: string): URL;
+  getInboxUri(): URL;
+  getFollowingUri(identifier: string): URL;
+  getFollowersUri(identifier: string): URL;
+  getLikedUri(identifier: string): URL;
+  getFeaturedUri(identifier: string): URL;
+  getFeaturedTagsUri(identifier: string): URL;
+  getCollectionUri<TParam extends Record<string, string>>(_name: string | symbol, values: TParam): URL;
+  parseUri(uri: URL): ParseUriResult | null;
+  getActorKeyPairs(_identifier: string): Promise<ActorKeyPair[]>;
+  getDocumentLoader(params: {
+    handle: string;
+  } | {
+    identifier: string;
+  }): Promise<DocumentLoader>;
+  getDocumentLoader(params: {
+    keyId: URL;
+    privateKey: CryptoKey;
+  }): DocumentLoader;
+  lookupObject(_uri: URL | string, _options?: LookupObjectOptions): Promise<Object$1 | null>;
+  traverseCollection<TItem, TContext extends Context<TContextData>>(_collection: Collection | URL | null, _options?: TraverseCollectionOptions): AsyncIterable<TItem>;
+  lookupNodeInfo(url: URL | string, options?: {
+    parse?: "strict" | "best-effort";
+  } & any): Promise<NodeInfo | undefined>;
+  lookupNodeInfo(url: URL | string, options?: {
+    parse: "none";
+  } & any): Promise<JsonValue | undefined>;
+  lookupWebFinger(_resource: URL | `acct:${string}@${string}` | string, _options?: any): Promise<ResourceDescriptor | null>;
+  sendActivity(sender: SenderKeyPair | SenderKeyPair[] | {
+    identifier: string;
+  } | {
+    username: string;
+  } | {
+    handle: string;
+  }, recipients: Recipient | Recipient[], activity: Activity, options?: SendActivityOptions): Promise<void>;
+  sendActivity(sender: {
+    identifier: string;
+  } | {
+    username: string;
+  } | {
+    handle: string;
+  }, recipients: "followers", activity: Activity, options?: SendActivityOptionsForCollection): Promise<void>;
+  sendActivity(sender: SenderKeyPair | SenderKeyPair[] | {
+    identifier: string;
+  } | {
+    username: string;
+  } | {
+    handle: string;
+  }, recipients: Recipient | Recipient[], activity: Activity, options?: SendActivityOptions): Promise<void>;
+  sendActivity(sender: {
+    identifier: string;
+  } | {
+    username: string;
+  } | {
+    handle: string;
+  }, recipients: "followers", activity: Activity, options?: SendActivityOptionsForCollection): Promise<void>;
+  routeActivity(_recipient: string | null, _activity: Activity, _options?: RouteActivityOptions): Promise<boolean>;
+  /**
+   * Gets all activities that have been sent through this mock context.
+   * This method is specific to the mock implementation and is used for
+   * testing purposes.
+   *
+   * @returns An array of sent activity records.
+   */
+  getSentActivities(): Array<{
+    sender: SenderKeyPair | SenderKeyPair[] | {
+      identifier: string;
+    } | {
+      username: string;
+    } | {
+      handle: string;
+    };
+    recipients: Recipient | Recipient[] | "followers";
+    activity: Activity;
+  }>;
+  /**
+   * Clears all sent activities from the mock context.
+   * This method is specific to the mock implementation and is used for
+   * testing purposes.
+   */
+  reset(): void;
+}
+//#endregion
+//#region src/context.d.ts
+declare function createContext<TContextData>(values: Partial<Context<TContextData>> & {
+  url?: URL;
+  data: TContextData;
+  federation: Federation<TContextData>;
+}): Context<TContextData>;
+declare function createRequestContext<TContextData>(args: Partial<RequestContext<TContextData>> & {
+  url: URL;
+  data: TContextData;
+  federation: Federation<TContextData>;
+}): RequestContext<TContextData>;
+declare function createInboxContext<TContextData>(args: Partial<InboxContext<TContextData>> & {
+  url?: URL;
+  data: TContextData;
+  recipient?: string | null;
+  federation: Federation<TContextData>;
+}): InboxContext<TContextData>;
+//#endregion
+export { MockContext, MockFederation, SentActivity, createContext, createInboxContext, createRequestContext };

package/dist/mod.js

@@ -295,6 +295,9 @@ var MockFederation = class {
 			},
 			setSharedKeyDispatcher() {
 				return this;
+			},
+			withIdempotency() {
+				return this;
 			}
 		};
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/testing",
-  "version": "2.0.0-dev.1604+23a1ea67",
+  "version": "2.0.0-dev.1690+304896b8",
   "description": "Testing utilities for Fedify applications",
   "keywords": [
     "fedify",
@@ -29,13 +29,18 @@
     "https://github.com/sponsors/dahlia"
   ],
   "type": "module",
-  "main": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
   "module": "./dist/mod.js",
   "types": "./dist/mod.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/mod.d.ts",
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts",
+        "default": "./dist/mod.d.ts"
+      },
       "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs",
       "default": "./dist/mod.js"
     },
     "./package.json": "./package.json"
@@ -45,7 +50,7 @@
     "package.json"
   ],
   "peerDependencies": {
-    "@fedify/fedify": "^2.0.0-dev.1604+23a1ea67"
+    "@fedify/fedify": "^2.0.0-dev.1690+304896b8"
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0"