@fedify/testing 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/mod.js

@@ -1,6 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { hasProofLike, hasSignatureLike } from "@fedify/fedify/sig";
-import { Activity, CryptographicKey, Multikey, lookupObject, traverseCollection } from "@fedify/vocab";
+import { Activity, CryptographicKey, Multikey, PUBLIC_COLLECTION, Tombstone, lookupObject, traverseCollection } from "@fedify/vocab";
+import { arePortableUrisEqual, canonicalizePortableUri, decodeMultibase, formatIri, fromCompatibleEf61Id, getFe34Origin, parseDigestMultibase, parseHashlink, parseIri } from "@fedify/vocab-runtime";
 import { RouterError } from "@fedify/fedify/federation";
 import { delay } from "es-toolkit";
 import { deepStrictEqual, ok, strictEqual } from "node:assert/strict";
@@ -37,7 +38,7 @@ const noopMeterProvider$1 = { getMeter: () => ({
 	removeBatchObservableCallback: () => void 0
 }) };
 function createContext(values) {
-	const { federation, url = new URL("http://example.com/"), canonicalOrigin, data, documentLoader, contextLoader, meterProvider, tracerProvider, clone, getNodeInfoUri, getActorUri, getObjectUri, getCollectionUri, getOutboxUri, getMediaUploaderUri, getInboxUri, getFollowingUri, getFollowersUri, getLikedUri, getFeaturedUri, getFeaturedTagsUri, parseUri, getActorKeyPairs, getDocumentLoader, lookupObject: lookupObject$1, traverseCollection: traverseCollection$1, lookupNodeInfo, lookupWebFinger, sendActivity, routeActivity, enqueueTask, enqueueTaskMany } = values;
+	const { federation, url = new URL("http://example.com/"), canonicalOrigin, data, documentLoader, contextLoader, verifyPortableObject, meterProvider, tracerProvider, clone, getNodeInfoUri, getActorUri, getPortableActorUri, getObjectUri, getPortableObjectUri, getPortableInboxUri, getPortableOutboxUri, getPortableFollowingUri, getPortableFollowersUri, getPortableLikedUri, getPortableFeaturedUri, getPortableFeaturedTagsUri, getPortableCollectionUri, getCollectionUri, getOutboxUri, getMediaUploaderUri, getInboxUri, getFollowingUri, getFollowersUri, getLikedUri, getFeaturedUri, getFeaturedTagsUri, parseUri, getActorKeyPairs, getDocumentLoader, lookupObject: lookupObject$1, traverseCollection: traverseCollection$1, lookupNodeInfo, lookupWebFinger, sendActivity, routeActivity, enqueueTask, enqueueTaskMany } = values;
 	function throwRouterError() {
 		throw new RouterError("Not implemented");
 	}
@@ -50,6 +51,7 @@ function createContext(values) {
 		hostname: url.hostname,
 		documentLoader: documentLoader ?? mockDocumentLoader,
 		contextLoader: contextLoader ?? mockDocumentLoader,
+		...verifyPortableObject == null ? {} : { verifyPortableObject },
 		meterProvider: meterProvider ?? noopMeterProvider$1,
 		tracerProvider: tracerProvider ?? noopTracerProvider$1,
 		clone: clone ?? ((data) => createContext({
@@ -58,7 +60,17 @@ function createContext(values) {
 		})),
 		getNodeInfoUri: getNodeInfoUri ?? throwRouterError,
 		getActorUri: getActorUri ?? throwRouterError,
+		getPortableActorUri: getPortableActorUri ?? throwRouterError,
 		getObjectUri: getObjectUri ?? throwRouterError,
+		getPortableObjectUri: getPortableObjectUri ?? throwRouterError,
+		getPortableInboxUri: getPortableInboxUri ?? throwRouterError,
+		getPortableOutboxUri: getPortableOutboxUri ?? throwRouterError,
+		getPortableFollowingUri: getPortableFollowingUri ?? throwRouterError,
+		getPortableFollowersUri: getPortableFollowersUri ?? throwRouterError,
+		getPortableLikedUri: getPortableLikedUri ?? throwRouterError,
+		getPortableFeaturedUri: getPortableFeaturedUri ?? throwRouterError,
+		getPortableFeaturedTagsUri: getPortableFeaturedTagsUri ?? throwRouterError,
+		getPortableCollectionUri: getPortableCollectionUri ?? throwRouterError,
 		getCollectionUri: getCollectionUri ?? throwRouterError,
 		getOutboxUri: getOutboxUri ?? throwRouterError,
 		getMediaUploaderUri: getMediaUploaderUri ?? throwRouterError,
@@ -78,13 +90,15 @@ function createContext(values) {
 		lookupObject: lookupObject$1 ?? ((uri, options = {}) => {
 			return lookupObject(uri, {
 				documentLoader: options.documentLoader ?? documentLoader ?? mockDocumentLoader,
-				contextLoader: options.contextLoader ?? contextLoader ?? mockDocumentLoader
+				contextLoader: options.contextLoader ?? contextLoader ?? mockDocumentLoader,
+				verifyPortableObject: options.verifyPortableObject ?? verifyPortableObject
 			});
 		}),
 		traverseCollection: traverseCollection$1 ?? ((collection, options = {}) => {
 			return traverseCollection(collection, {
 				documentLoader: options.documentLoader ?? documentLoader ?? mockDocumentLoader,
-				contextLoader: options.contextLoader ?? contextLoader ?? mockDocumentLoader
+				contextLoader: options.contextLoader ?? contextLoader ?? mockDocumentLoader,
+				verifyPortableObject: options.verifyPortableObject ?? verifyPortableObject
 			});
 		}),
 		lookupNodeInfo: lookupNodeInfo ?? ((_params) => {
@@ -123,15 +137,59 @@ function createRequestContext(args) {
 		})),
 		request: args.request ?? new Request(args.url),
 		url: args.url,
+		portableRequest: args.portableRequest,
 		getActor: args.getActor ?? (() => Promise.resolve(null)),
 		getObject: args.getObject ?? (() => Promise.resolve(null)),
 		getSignedKey: args.getSignedKey ?? (() => Promise.resolve(null)),
 		getSignedKeyOwner: args.getSignedKeyOwner ?? (() => Promise.resolve(null)),
+		isSignedByAudience: args.isSignedByAudience ?? ((object, options) => isSignedByAudience(() => args.getSignedKeyOwner == null ? Promise.resolve(null) : args.getSignedKeyOwner(options ?? {}), object, options?.isMember)),
 		sendActivity: args.sendActivity ?? ((_params) => {
 			throw new Error("Not implemented");
 		})
 	};
 }
+const PUBLIC_IDS = /* @__PURE__ */ new Set([
+	PUBLIC_COLLECTION.href,
+	"as:Public",
+	"Public"
+]);
+function getPortableIri(id) {
+	try {
+		if (id.protocol === "ap:" || id.protocol === "ap+ef61:") return formatIri(id);
+		const portable = fromCompatibleEf61Id(id);
+		return portable == null ? null : formatIri(portable);
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+}
+function isSameActorId(a, b) {
+	const portableA = getPortableIri(a);
+	const portableB = getPortableIri(b);
+	if (portableA != null || portableB != null) return portableA != null && portableB != null && arePortableUrisEqual(portableA, portableB);
+	return a.href === b.href;
+}
+/**
+* The default implementation of `RequestContext.isSignedByAudience()` for
+* testing, which checks the audience against `getSignedKeyOwner()`.
+*/
+async function isSignedByAudience(getSignedKeyOwner, object, isMember) {
+	const addressees = [
+		...object.toIds,
+		...object.ccIds,
+		...object.btoIds,
+		...object.bccIds,
+		...object.audienceIds
+	];
+	if (addressees.some((id) => PUBLIC_IDS.has(id.href))) return true;
+	const actor = await getSignedKeyOwner();
+	const actorId = actor?.id;
+	if (actor == null || actorId == null) return false;
+	if (addressees.some((id) => isSameActorId(id, actorId))) return true;
+	if (isMember == null) return false;
+	for (const addressee of addressees) if (await isMember(addressee, actor)) return true;
+	return false;
+}
 /**
 * Creates an InboxContext for testing purposes.
 * Not exported - used internally only. Public API is in mock.ts
@@ -225,6 +283,63 @@ function expandUriTemplate(template, values) {
 		}
 	});
 }
+/**
+* Builds an FEP-ef61 portable ID from a DID authority and a path, validating
+* the authority the same way as `@fedify/fedify` does.
+*/
+function buildPortableUri(authority, path) {
+	if (typeof authority !== "string" || !/^did:[a-z0-9]+:[^/?#]+$/i.test(authority)) throw new TypeError("The authority of a portable ID must be a DID without a path, query, or fragment.");
+	const did = getFe34Origin(authority);
+	if (!isBase58BtcDidKey(did)) throw new TypeError("The did:key authority of a portable ID must be encoded in base58-btc, i.e., start with z.");
+	return parseIri(`ap+ef61://${did}${path}`);
+}
+/**
+* Checks that a normalized DID, if it is a `did:key` DID, is encoded in
+* base58-btc, as `@fedify/fedify` requires of portable IDs.
+*/
+function isBase58BtcDidKey(did) {
+	return !did.startsWith("did:key:") || /^z[1-9A-HJ-NP-Za-km-z]+$/.test(did.slice(8));
+}
+/**
+* Recognizes an FEP-ef61 portable ID, i.e., an `ap:` or `ap+ef61:` URI, or
+* a compatible identifier on any gateway, validating it the same way as
+* `Context.parseUri()` of `@fedify/fedify` does.
+* @returns The DID and the path of the portable ID, `null` if it is
+*          malformed, or `undefined` if the URI is not a portable ID.
+*/
+function parseMockPortableId(uri) {
+	const portable = uri.protocol === "ap:" || uri.protocol === "ap+ef61:";
+	if (!portable && !((uri.protocol === "http:" || uri.protocol === "https:") && /^\/\.well-known\/apgateway\/did(?::|%3A)/i.test(uri.pathname))) return;
+	if (uri.username !== "" || uri.password !== "") return null;
+	try {
+		const id = portable ? parseIri(uri) : fromCompatibleEf61Id(uri.origin + uri.pathname);
+		if (id == null) return null;
+		canonicalizePortableUri(formatIri(id));
+		const authority = getFe34Origin(id);
+		if (!isBase58BtcDidKey(authority)) return null;
+		return {
+			authority,
+			path: id.pathname
+		};
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+}
+/**
+* Parses a path in the way {@link MockContext.parseUri} does, i.e., only
+* `/users/{identifier}` and its subpaths are recognized, as actors.
+*/
+function parseMockPath(path) {
+	if (path.startsWith("/users/")) {
+		const parts = path.split("/");
+		if (parts.length >= 3) return {
+			type: "actor",
+			identifier: parts[2]
+		};
+	}
+	return null;
+}
 function validateOutboxListenerPath(path, dispatcherPath) {
 	if (!path.startsWith("/")) throw new TypeError("Path must start with a slash.");
 	if (dispatcherPath != null && dispatcherPath !== path) throw new TypeError("Outbox listener path and outbox dispatcher path must match.");
@@ -301,6 +416,7 @@ var MockFederation = class {
 	outboxListenerErrorHandler;
 	mediaUploaderCallback;
 	mediaUploaderAuthorizePredicate;
+	hashlinkMediaDispatcher;
 	followingDispatcher;
 	followersDispatcher;
 	likedDispatcher;
@@ -338,93 +454,103 @@ var MockFederation = class {
 	setActorDispatcher(path, dispatcher) {
 		this.actorDispatchers.set(path, dispatcher);
 		this.actorPath = path;
-		return {
+		const setters = {
 			setKeyPairsDispatcher: (keyPairsDispatcher) => {
 				this.actorKeyPairsDispatcher = keyPairsDispatcher;
-				return this;
+				return setters;
 			},
-			mapHandle: () => this,
-			mapAlias: () => this,
-			authorize: () => this
+			mapHandle: () => setters,
+			mapAlias: () => setters,
+			mapPortableActorId: () => setters,
+			authorize: () => setters
 		};
+		return setters;
 	}
 	setObjectDispatcher(cls, path, dispatcher) {
 		this.objectDispatchers.set(path, dispatcher);
 		this.objectPaths.set(cls.typeId.href, path);
-		return { authorize: () => this };
+		const setters = { authorize: () => setters };
+		return setters;
 	}
 	setInboxDispatcher(_path, dispatcher) {
 		this.inboxDispatcher = dispatcher;
-		return {
-			setCounter: () => this,
-			setFirstCursor: () => this,
-			setLastCursor: () => this,
-			authorize: () => this
+		const setters = {
+			setCounter: () => setters,
+			setFirstCursor: () => setters,
+			setLastCursor: () => setters,
+			authorize: () => setters
 		};
+		return setters;
 	}
 	setOutboxDispatcher(path, dispatcher) {
 		validateOutboxListenerPath(path, this.outboxListenersInitialized ? this.outboxPath : void 0);
 		this.outboxDispatcher = dispatcher;
 		this.outboxPath = path;
-		return {
-			setCounter: () => this,
-			setFirstCursor: () => this,
-			setLastCursor: () => this,
+		const setters = {
+			setCounter: () => setters,
+			setFirstCursor: () => setters,
+			setLastCursor: () => setters,
 			authorize: (predicate) => {
 				this.outboxDispatcherAuthorizePredicate = predicate;
-				return this;
+				return setters;
 			}
 		};
+		return setters;
 	}
 	setFollowingDispatcher(path, dispatcher) {
 		this.followingDispatcher = dispatcher;
 		this.followingPath = path;
-		return {
-			setCounter: () => this,
-			setFirstCursor: () => this,
-			setLastCursor: () => this,
-			authorize: () => this
+		const setters = {
+			setCounter: () => setters,
+			setFirstCursor: () => setters,
+			setLastCursor: () => setters,
+			authorize: () => setters
 		};
+		return setters;
 	}
 	setFollowersDispatcher(path, dispatcher) {
 		this.followersDispatcher = dispatcher;
 		this.followersPath = path;
-		return {
-			setCounter: () => this,
-			setFirstCursor: () => this,
-			setLastCursor: () => this,
-			authorize: () => this
+		const setters = {
+			setCounter: () => setters,
+			setFirstCursor: () => setters,
+			setLastCursor: () => setters,
+			authorize: () => setters
 		};
+		return setters;
 	}
 	setLikedDispatcher(path, dispatcher) {
 		this.likedDispatcher = dispatcher;
 		this.likedPath = path;
-		return {
-			setCounter: () => this,
-			setFirstCursor: () => this,
-			setLastCursor: () => this,
-			authorize: () => this
+		const setters = {
+			setCounter: () => setters,
+			setFirstCursor: () => setters,
+			setLastCursor: () => setters,
+			authorize: () => setters
 		};
+		return setters;
 	}
 	setFeaturedDispatcher(path, dispatcher) {
 		this.featuredDispatcher = dispatcher;
 		this.featuredPath = path;
-		return {
-			setCounter: () => this,
-			setFirstCursor: () => this,
-			setLastCursor: () => this,
-			authorize: () => this
+		const setters = {
+			setCounter: () => setters,
+			setFirstCursor: () => setters,
+			setLastCursor: () => setters,
+			authorize: () => setters
 		};
+		return setters;
 	}
 	setFeaturedTagsDispatcher(path, dispatcher) {
 		this.featuredTagsDispatcher = dispatcher;
 		this.featuredTagsPath = path;
-		return {
-			setCounter: () => this,
-			setFirstCursor: () => this,
-			setLastCursor: () => this,
-			authorize: () => this
+		const setters = {
+			setCounter: () => setters,
+			setFirstCursor: () => setters,
+			setLastCursor: () => setters,
+			authorize: () => setters
 		};
+		return setters;
 	}
 	setInboxListeners(inboxPath, sharedInboxPath) {
 		this.inboxPath = inboxPath;
@@ -443,6 +569,9 @@ var MockFederation = class {
 			onUnverifiedActivity() {
 				return this;
 			},
+			onRequestFinished() {
+				return this;
+			},
 			setSharedKeyDispatcher() {
 				return this;
 			},
@@ -483,6 +612,10 @@ var MockFederation = class {
 			return this;
 		} };
 	}
+	setHashlinkMediaDispatcher(dispatcher) {
+		if (this.hashlinkMediaDispatcher != null) throw new TypeError("Hashlink media dispatcher already set.");
+		this.hashlinkMediaDispatcher = dispatcher;
+	}
 	setOutboxPermanentFailureHandler(_handler) {}
 	async startQueue(contextData, options) {
 		this.contextData = contextData;
@@ -498,7 +631,7 @@ var MockFederation = class {
 	async processQueuedTask(contextData, _message) {
 		this.contextData = contextData;
 	}
-	createContext(baseUrlOrRequest, contextData) {
+	createContext(baseUrlOrRequest, contextData, options = {}) {
 		const mockFederation = this;
 		const request = baseUrlOrRequest instanceof Request ? baseUrlOrRequest : null;
 		return new MockContext({
@@ -507,10 +640,63 @@ var MockFederation = class {
 			data: contextData,
 			federation: mockFederation,
 			meterProvider: this.options.meterProvider,
-			tracerProvider: this.options.tracerProvider
+			tracerProvider: this.options.tracerProvider,
+			documentLoader: this.options.documentLoader,
+			contextLoader: this.options.contextLoader,
+			verifyPortableObject: this.options.verifyPortableObject,
+			portableRequest: options.portableRequest
 		});
 	}
 	async fetch(request, options) {
+		if (this.hashlinkMediaDispatcher != null) {
+			const url = new URL(request.url);
+			if ((url.protocol === "http:" || url.protocol === "https:") && url.pathname.startsWith("/.well-known/apgateway/")) {
+				const encoded = url.pathname.slice(23);
+				if (/^hl(?::|%3A)/i.test(encoded)) {
+					if (request.method !== "GET" && request.method !== "HEAD") return new Response("Method not allowed.", {
+						status: 405,
+						headers: {
+							Allow: "GET, HEAD",
+							"Content-Type": "text/plain; charset=utf-8"
+						}
+					});
+					let media;
+					try {
+						let hashlink;
+						try {
+							hashlink = decodeURIComponent(encoded);
+						} catch (error) {
+							throw new TypeError("Invalid percent-encoding in the hashlink.", { cause: error });
+						}
+						const { digestMultibase } = parseHashlink(hashlink);
+						const { digest } = parseDigestMultibase(digestMultibase);
+						media = globalThis.Object.freeze({
+							hashlink: `hl:${digestMultibase}`,
+							digestMultibase,
+							algorithm: "sha2-256",
+							digest,
+							multihash: decodeMultibase(digestMultibase)
+						});
+					} catch (error) {
+						if (!(error instanceof TypeError)) throw error;
+						return new Response(request.method === "HEAD" ? null : "Malformed hashlink.", {
+							status: 400,
+							headers: { "Content-Type": "text/plain; charset=utf-8" }
+						});
+					}
+					const context = this.createContext(request, options.contextData);
+					const response = await this.hashlinkMediaDispatcher(context, media);
+					if (response == null) return options.onNotFound == null ? new Response("Not Found", { status: 404 }) : await options.onNotFound(request);
+					if (request.method !== "HEAD" || response.body == null) return response;
+					response.body.cancel().catch(() => {});
+					return new Response(null, {
+						status: response.status,
+						statusText: response.statusText,
+						headers: response.headers
+					});
+				}
+			}
+		}
 		if (options.onNotFound) return options.onNotFound(request);
 		return new Response("Not Found", { status: 404 });
 	}
@@ -618,20 +804,24 @@ var MockFederation = class {
 		this.sentActivities = [];
 	}
 	setCollectionDispatcher(_name, _itemType, _path, _dispatcher) {
-		return {
-			setCounter: () => this,
-			setFirstCursor: () => this,
-			setLastCursor: () => this,
-			authorize: () => this
+		const setters = {
+			setCounter: () => setters,
+			setFirstCursor: () => setters,
+			setLastCursor: () => setters,
+			authorize: () => setters,
+			mapPortableOwner: () => setters
 		};
+		return setters;
 	}
 	setOrderedCollectionDispatcher(_name, _itemType, _path, _dispatcher) {
-		return {
-			setCounter: () => this,
-			setFirstCursor: () => this,
-			setLastCursor: () => this,
-			authorize: () => this
+		const setters = {
+			setCounter: () => setters,
+			setFirstCursor: () => setters,
+			setLastCursor: () => setters,
+			authorize: () => setters,
+			mapPortableOwner: () => setters
 		};
+		return setters;
 	}
 };
 /**
@@ -729,6 +919,10 @@ var MockContext = class MockContext {
 	tracerProvider;
 	request;
 	url;
+	portableRequest;
+	verifyPortableObject;
+	hasDocumentLoader;
+	hasContextLoader;
 	sentActivities = [];
 	constructor(options) {
 		const url = options.url ?? new URL("https://example.com");
@@ -738,6 +932,10 @@ var MockContext = class MockContext {
 		this.hostname = url.hostname;
 		this.url = url;
 		this.request = options.request ?? new Request(url);
+		this.portableRequest = options.portableRequest;
+		this.verifyPortableObject = options.verifyPortableObject;
+		this.hasDocumentLoader = options.hasDocumentLoader ?? options.documentLoader != null;
+		this.hasContextLoader = options.hasContextLoader ?? options.contextLoader != null;
 		this.data = options.data;
 		this.federation = options.federation;
 		this.documentLoader = options.documentLoader ?? (async (url) => ({
@@ -756,12 +954,16 @@ var MockContext = class MockContext {
 		}
 		return null;
 	}
-	async getObject(cls, values) {
+	async getObject(cls, values, options) {
 		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);
+				if (dispatcher) {
+					const object = await dispatcher(this, values);
+					if (object instanceof Tombstone && !(object instanceof cls) && options?.tombstone !== "passthrough") return null;
+					return object;
+				}
 			}
 		}
 		return null;
@@ -772,6 +974,9 @@ var MockContext = class MockContext {
 	getSignedKeyOwner() {
 		return Promise.resolve(null);
 	}
+	isSignedByAudience(object, options) {
+		return isSignedByAudience(() => this.getSignedKeyOwner(), object, options?.isMember);
+	}
 	#resolveTaskDefinition(task) {
 		if (!(this.federation instanceof MockFederation)) throw new TypeError("No task definitions are available.");
 		const def = this.federation.taskDefinitions.get(task.name);
@@ -795,10 +1000,15 @@ var MockContext = class MockContext {
 	clone(data) {
 		return new MockContext({
 			url: this.url,
+			request: this.request,
 			data,
 			federation: this.federation,
 			documentLoader: this.documentLoader,
 			contextLoader: this.contextLoader,
+			verifyPortableObject: this.verifyPortableObject,
+			portableRequest: this.portableRequest,
+			hasDocumentLoader: this.hasDocumentLoader,
+			hasContextLoader: this.hasContextLoader,
 			meterProvider: this.meterProvider,
 			tracerProvider: this.tracerProvider
 		});
@@ -825,6 +1035,46 @@ var MockContext = class MockContext {
 		const path = globalThis.Object.entries(values).map(([key, value]) => `${key}/${value}`).join("/");
 		return new URL(`/objects/${cls.name.toLowerCase()}/${path}`, this.origin);
 	}
+	getPortableActorUri(identifier, authority) {
+		const { pathname } = this.getActorUri(identifier);
+		return buildPortableUri(authority, pathname);
+	}
+	getPortableObjectUri(cls, values, authority) {
+		const { pathname } = this.getObjectUri(cls, values);
+		return buildPortableUri(authority, pathname);
+	}
+	getPortableInboxUri(identifier, authority) {
+		const { pathname } = this.getInboxUri(identifier);
+		return buildPortableUri(authority, pathname);
+	}
+	getPortableOutboxUri(identifier, authority) {
+		const { pathname } = this.getOutboxUri(identifier);
+		return buildPortableUri(authority, pathname);
+	}
+	getPortableFollowingUri(identifier, authority) {
+		const { pathname } = this.getFollowingUri(identifier);
+		return buildPortableUri(authority, pathname);
+	}
+	getPortableFollowersUri(identifier, authority) {
+		const { pathname } = this.getFollowersUri(identifier);
+		return buildPortableUri(authority, pathname);
+	}
+	getPortableLikedUri(identifier, authority) {
+		const { pathname } = this.getLikedUri(identifier);
+		return buildPortableUri(authority, pathname);
+	}
+	getPortableFeaturedUri(identifier, authority) {
+		const { pathname } = this.getFeaturedUri(identifier);
+		return buildPortableUri(authority, pathname);
+	}
+	getPortableFeaturedTagsUri(identifier, authority) {
+		const { pathname } = this.getFeaturedTagsUri(identifier);
+		return buildPortableUri(authority, pathname);
+	}
+	getPortableCollectionUri(name, values, authority) {
+		const { pathname } = this.getCollectionUri(name, values);
+		return buildPortableUri(authority, pathname);
+	}
 	getOutboxUri(identifier) {
 		if (this.federation instanceof MockFederation && this.federation.outboxPath) {
 			const path = expandUriTemplate(this.federation.outboxPath, { identifier });
@@ -889,15 +1139,16 @@ var MockContext = class MockContext {
 		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]
-			};
-		}
-		return null;
+	parseUri(uri, options = {}) {
+		if (uri == null) return null;
+		const portable = parseMockPortableId(uri);
+		if (portable === void 0) return parseMockPath(uri.pathname);
+		if (portable === null || !options.portable) return null;
+		const result = parseMockPath(portable.path);
+		return result == null ? null : {
+			...result,
+			authority: portable.authority
+		};
 	}
 	async getActorKeyPairs(identifier) {
 		if (this.federation instanceof MockFederation && this.federation.actorKeyPairsDispatcher) {
@@ -923,8 +1174,21 @@ var MockContext = class MockContext {
 		if ("keyId" in params) return this.documentLoader;
 		return Promise.resolve(this.documentLoader);
 	}
-	lookupObject(_uri, _options) {
-		return Promise.resolve(null);
+	lookupObject(uri, options = {}) {
+		if (!this.hasDocumentLoader && options.documentLoader == null || (options.verifyPortableObject ?? this.verifyPortableObject) == null) return Promise.resolve(null);
+		const value = typeof uri === "string" ? uri : formatIri(uri);
+		if (!/^ap(?:\+ef61)?:\/\//i.test(value)) try {
+			if (fromCompatibleEf61Id(value) == null) return Promise.resolve(null);
+		} catch (error) {
+			if (error instanceof TypeError) return Promise.resolve(null);
+			throw error;
+		}
+		return lookupObject(uri, {
+			...options,
+			documentLoader: options.documentLoader ?? this.documentLoader,
+			contextLoader: options.contextLoader ?? (this.hasContextLoader ? this.contextLoader : options.documentLoader ?? this.contextLoader),
+			verifyPortableObject: options.verifyPortableObject ?? this.verifyPortableObject
+		});
 	}
 	traverseCollection(_collection, _options) {
 		return { async *[Symbol.asyncIterator]() {} };
@@ -977,6 +1241,147 @@ var MockContext = class MockContext {
 	}
 };
 //#endregion
+//#region src/kv-tester.ts
+/**
+* Tests a {@link KvStore} implementation with a standard set of tests.
+*
+* The suite covers reads and writes, deletion, structured keys and values,
+* prefix listing, TTL expiration, and optional compare-and-swap behavior.
+* Every key is isolated below a random prefix and is deleted after the suite.
+*
+* @example
+* ```typescript ignore
+* import { test } from "@fedify/fixture";
+* import { testKvStore } from "@fedify/testing";
+* import { MyKvStore } from "./my-kv.ts";
+*
+* test("MyKvStore", () =>
+*   testKvStore(
+*     () => new MyKvStore(),
+*     async ({ store }) => await store.close(),
+*   )
+* );
+* ```
+*
+* @param getKvStore A factory that creates the store to test.
+* @param onFinally A cleanup function called after the suite completes.
+* @param options Optional configuration for the suite.
+*/
+async function testKvStore(getKvStore, onFinally, options = {}) {
+	const store = await getKvStore();
+	const prefix = [`fedify_test_${crypto.randomUUID()}`];
+	const key = (...segments) => [...prefix, ...segments];
+	try {
+		strictEqual(await store.get(key("missing")), void 0);
+		for (const [index, value] of [
+			"text",
+			42,
+			true,
+			null,
+			[
+				1,
+				"two",
+				false
+			],
+			{ nested: { value: "test" } }
+		].entries()) {
+			const valueKey = key("values", index.toString());
+			await store.set(valueKey, value);
+			deepStrictEqual(await store.get(valueKey), value);
+		}
+		const overwriteKey = key("overwrite");
+		await store.set(overwriteKey, "before");
+		await store.set(overwriteKey, "after");
+		strictEqual(await store.get(overwriteKey), "after");
+		const deleteKey = key("delete");
+		await store.set(deleteKey, "value");
+		await store.delete(deleteKey);
+		strictEqual(await store.get(deleteKey), void 0);
+		await store.delete(deleteKey);
+		const isolatedKeys = [
+			key("a", "b"),
+			key("a,b"),
+			key("a:b")
+		];
+		for (const [index, isolatedKey] of isolatedKeys.entries()) await store.set(isolatedKey, index);
+		for (const [index, isolatedKey] of isolatedKeys.entries()) strictEqual(await store.get(isolatedKey), index);
+		if (options.testTtl ?? true) {
+			const expiringKey = key("ttl", "expiring");
+			await store.set(expiringKey, "expired", { ttl: Temporal.Duration.from({ milliseconds: 50 }) });
+			await delay(100);
+			strictEqual(await store.get(expiringKey), void 0);
+			deepStrictEqual(await collect(store.list(key("ttl"))), []);
+			const refreshedKey = key("ttl", "refreshed");
+			await store.set(refreshedKey, "temporary", { ttl: Temporal.Duration.from({ milliseconds: 50 }) });
+			await store.set(refreshedKey, "persistent");
+			await delay(100);
+			strictEqual(await store.get(refreshedKey), "persistent");
+		}
+		const listPrefix = key("list");
+		const listEntries = [
+			{
+				key: listPrefix,
+				value: "exact"
+			},
+			{
+				key: key("list", "child"),
+				value: "child"
+			},
+			{
+				key: key("list", "child", "nested"),
+				value: "nested"
+			},
+			{
+				key: key("list-other"),
+				value: "other"
+			}
+		];
+		for (const entry of listEntries) await store.set(entry.key, entry.value);
+		deepStrictEqual(normalize(await collect(store.list(listPrefix))), normalize(listEntries.slice(0, 3)));
+		const prefixedEntries = await collect(store.list(prefix));
+		deepStrictEqual(normalize(filterByPrefix(await collect(store.list()), prefix)), normalize(prefixedEntries));
+		deepStrictEqual(normalize(filterByPrefix(await collect(store.list([])), prefix)), normalize(prefixedEntries));
+		if (options.testCas ?? store.cas != null) {
+			if (store.cas == null) throw new TypeError("KvStore.cas is not implemented");
+			const cas = store.cas.bind(store);
+			const casKey = key("cas", "value");
+			strictEqual(await cas(casKey, "wrong", "value"), false);
+			strictEqual(await cas(casKey, void 0, "created"), true);
+			strictEqual(await cas(casKey, "wrong", "updated"), false);
+			strictEqual(await cas(casKey, "created", "updated"), true);
+			strictEqual(await store.get(casKey), "updated");
+			strictEqual(await cas(casKey, "updated", void 0), true);
+			strictEqual(await store.get(casKey), void 0);
+			if (options.testTtl ?? true) {
+				const expiredCasKey = key("cas", "expired");
+				await store.set(expiredCasKey, "old", { ttl: Temporal.Duration.from({ milliseconds: 50 }) });
+				await delay(100);
+				strictEqual(await cas(expiredCasKey, void 0, "replaced"), true);
+				const ttlCasKey = key("cas", "ttl");
+				strictEqual(await cas(ttlCasKey, void 0, "temporary", { ttl: Temporal.Duration.from({ milliseconds: 50 }) }), true);
+				await delay(100);
+				strictEqual(await store.get(ttlCasKey), void 0);
+			}
+			const concurrentKey = key("cas", "concurrent");
+			strictEqual((await Promise.all(Array.from({ length: 8 }, (_, index) => cas(concurrentKey, void 0, index)))).filter(Boolean).length, 1);
+		}
+	} finally {
+		for await (const entry of store.list(prefix)) await store.delete(entry.key);
+		await onFinally({ store });
+	}
+}
+async function collect(entries) {
+	const results = [];
+	for await (const entry of entries) results.push(entry);
+	return results;
+}
+function normalize(entries) {
+	return entries.map((entry) => JSON.stringify(entry)).sort();
+}
+function filterByPrefix(entries, prefix) {
+	return entries.filter((entry) => prefix.every((segment, index) => entry.key[index] === segment));
+}
+//#endregion
 //#region src/mq-tester.ts
 /**
 * Tests a {@link MessageQueue} implementation with a standard set of tests.
@@ -1157,4 +1562,4 @@ async function waitFor(predicate, timeoutMs) {
 }
 const getRandomKey = (prefix) => `fedify_test_${prefix}_${crypto.randomUUID()}`;
 //#endregion
-export { createContext, createFederation, createInboxContext, createOutboxContext, createRequestContext, getRandomKey, testMessageQueue, waitFor };
+export { createContext, createFederation, createInboxContext, createOutboxContext, createRequestContext, getRandomKey, testKvStore, testMessageQueue, waitFor };