Fix getActorKeyPairs() returning empty array

TestContext.getActorKeyPairs() method was always returning an empty
array instead of calling the registered key pairs dispatcher. This
made it impossible to test actor key pairs retrieval with the
@fedify/testing package.

The bug was caused by the setKeyPairsDispatcher() method not storing
the dispatcher, and MockContext.getActorKeyPairs() being hardcoded
to return an empty array without checking for registered dispatchers
in the MockFederation instance. Updated the implementation to:

- Store the key pairs dispatcher when setKeyPairsDispatcher() is
  called
- Call the stored dispatcher in getActorKeyPairs() when available
- Wrap returned key pairs with CryptographicKey and Multikey objects
  to match the real implementation behavior

Added regression tests to ensure the method correctly calls the
dispatcher and returns an empty array only when no dispatcher is
registered.

Fixes #530

Author: dahlia

CHANGES.md

@@ -8,6 +8,15 @@ Version 1.9.4
 
 To be released.
 
+### @fedify/testing
+
+ -  Fixed `TestContext.getActorKeyPairs()` returning empty array instead of
+    calling registered key pairs dispatcher.  The method now properly invokes
+    the key pairs dispatcher when it is registered via `setKeyPairsDispatcher()`.
+    [[#530]]
+
+[#530]: https://github.com/fedify-dev/fedify/issues/530
+
 
 Version 1.9.3
 -------------

packages/testing/src/mock.test.ts

@@ -440,3 +440,73 @@ test("MockContext.getObject() returns null when no dispatcher registered", async
   });
   assertEquals(note, null);
 });
+
+test("MockContext.getActorKeyPairs() calls registered key pairs dispatcher", async () => {
+  const mockFederation = createFederation<void>();
+
+  // Generate a test RSA key pair
+  const keyPair = await crypto.subtle.generateKey(
+    {
+      name: "RSASSA-PKCS1-v1_5",
+      modulusLength: 2048,
+      publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+      hash: "SHA-256",
+    },
+    true,
+    ["sign", "verify"],
+  );
+
+  // Register actor dispatcher with key pairs dispatcher
+  mockFederation
+    .setActorDispatcher("/users/{identifier}", (ctx, identifier) => {
+      return new Person({
+        id: ctx.getActorUri(identifier),
+        preferredUsername: identifier,
+      });
+    })
+    .setKeyPairsDispatcher((ctx, identifier) => {
+      return [
+        {
+          keyId: new URL(`${ctx.getActorUri(identifier).href}#main-key`),
+          privateKey: keyPair.privateKey,
+          publicKey: keyPair.publicKey,
+        },
+      ];
+    });
+
+  const context = mockFederation.createContext(
+    new URL("https://example.com"),
+    undefined,
+  );
+
+  const keyPairs = await context.getActorKeyPairs("alice");
+
+  assertEquals(keyPairs.length, 1);
+  assertEquals(
+    keyPairs[0].keyId.href,
+    "https://example.com/users/alice#main-key",
+  );
+  assertEquals(keyPairs[0].privateKey, keyPair.privateKey);
+  assertEquals(keyPairs[0].publicKey, keyPair.publicKey);
+  assertEquals(keyPairs[0].cryptographicKey.id?.href, keyPairs[0].keyId.href);
+  assertEquals(
+    keyPairs[0].cryptographicKey.ownerId?.href,
+    "https://example.com/users/alice",
+  );
+  assertEquals(keyPairs[0].multikey.id?.href, keyPairs[0].keyId.href);
+  assertEquals(
+    keyPairs[0].multikey.controllerId?.href,
+    "https://example.com/users/alice",
+  );
+});
+
+test("MockContext.getActorKeyPairs() returns empty array when no dispatcher registered", async () => {
+  const mockFederation = createFederation<void>();
+  const context = mockFederation.createContext(
+    new URL("https://example.com"),
+    undefined,
+  );
+
+  const keyPairs = await context.getActorKeyPairs("alice");
+  assertEquals(keyPairs, []);
+});

packages/testing/src/mock.ts

@@ -11,6 +11,7 @@ import type {
   RouteActivityOptions,
 } from "@fedify/fedify/federation";
 import type { DocumentLoader } from "@fedify/fedify/runtime";
+import { CryptographicKey, Multikey } from "@fedify/fedify/vocab";
 import type {
   Activity,
   Collection,
@@ -179,6 +180,7 @@ class MockFederation<TContextData> implements Federation<TContextData> {
   // types present in Context.tracerProvider (issue #468).
   private webFingerDispatcher?: any;
   public actorDispatchers: Map<string, any> = new Map();
+  public actorKeyPairsDispatcher?: any;
   public actorPath?: string;
   public inboxPath?: string;
   public outboxPath?: string;
@@ -229,7 +231,10 @@ class MockFederation<TContextData> implements Federation<TContextData> {
     this.actorDispatchers.set(path, dispatcher);
     this.actorPath = path;
     return {
-      setKeyPairsDispatcher: () => this as any,
+      setKeyPairsDispatcher: (keyPairsDispatcher: any) => {
+        this.actorKeyPairsDispatcher = keyPairsDispatcher;
+        return this as any;
+      },
       mapHandle: () => this as any,
       mapAlias: () => this as any,
       authorize: () => this as any,
@@ -836,8 +841,32 @@ class MockContext<TContextData> implements Context<TContextData> {
     return null;
   }
 
-  getActorKeyPairs(_identifier: string): Promise<ActorKeyPair[]> {
-    return Promise.resolve([]);
+  async getActorKeyPairs(identifier: string): Promise<ActorKeyPair[]> {
+    if (
+      this.federation instanceof MockFederation &&
+      this.federation.actorKeyPairsDispatcher
+    ) {
+      const keyPairs = await this.federation.actorKeyPairsDispatcher(
+        this,
+        identifier,
+      );
+      // Wrap with CryptographicKey and Multikey objects like real implementation
+      const owner = this.getActorUri(identifier);
+      return keyPairs.map((kp: any) => ({
+        ...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: any): any {