@mcp-i/core 0.1.0

package/src/__tests__/providers/memory.test.ts

@@ -0,0 +1,332 @@
+/**
+ * Tests for Memory Provider Implementations
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import {
+  MemoryStorageProvider,
+  MemoryNonceCacheProvider,
+  MemoryIdentityProvider
+} from '../../providers/memory.js';
+import { MockCryptoProvider } from '../utils/mock-providers.js';
+
+describe('MemoryStorageProvider', () => {
+  let provider: MemoryStorageProvider;
+
+  beforeEach(() => {
+    provider = new MemoryStorageProvider();
+  });
+
+  describe('get', () => {
+    it('should return null for non-existent keys', async () => {
+      const value = await provider.get('nonexistent');
+      expect(value).toBeNull();
+    });
+
+    it('should return stored values', async () => {
+      await provider.set('key1', 'value1');
+      const value = await provider.get('key1');
+      expect(value).toBe('value1');
+    });
+  });
+
+  describe('set', () => {
+    it('should store values', async () => {
+      await provider.set('key1', 'value1');
+      const value = await provider.get('key1');
+      expect(value).toBe('value1');
+    });
+
+    it('should overwrite existing values', async () => {
+      await provider.set('key1', 'value1');
+      await provider.set('key1', 'value2');
+      const value = await provider.get('key1');
+      expect(value).toBe('value2');
+    });
+
+    it('should handle empty string values', async () => {
+      await provider.set('key1', '');
+      const value = await provider.get('key1');
+      expect(value).toBe('');
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete existing keys', async () => {
+      await provider.set('key1', 'value1');
+      await provider.delete('key1');
+      const value = await provider.get('key1');
+      expect(value).toBeNull();
+    });
+
+    it('should handle deleting non-existent keys', async () => {
+      await expect(provider.delete('nonexistent')).resolves.toBeUndefined();
+    });
+  });
+
+  describe('exists', () => {
+    it('should return false for non-existent keys', async () => {
+      const exists = await provider.exists('nonexistent');
+      expect(exists).toBe(false);
+    });
+
+    it('should return true for existing keys', async () => {
+      await provider.set('key1', 'value1');
+      const exists = await provider.exists('key1');
+      expect(exists).toBe(true);
+    });
+
+    it('should return true for empty string values', async () => {
+      await provider.set('key1', '');
+      const exists = await provider.exists('key1');
+      expect(exists).toBe(true);
+    });
+  });
+
+  describe('list', () => {
+    beforeEach(async () => {
+      await provider.set('prefix/key1', 'value1');
+      await provider.set('prefix/key2', 'value2');
+      await provider.set('other/key3', 'value3');
+      await provider.set('key4', 'value4');
+    });
+
+    it('should list all keys when no prefix provided', async () => {
+      const keys = await provider.list();
+      expect(keys).toHaveLength(4);
+      expect(keys).toContain('prefix/key1');
+      expect(keys).toContain('prefix/key2');
+      expect(keys).toContain('other/key3');
+      expect(keys).toContain('key4');
+    });
+
+    it('should filter by prefix', async () => {
+      const keys = await provider.list('prefix/');
+      expect(keys).toHaveLength(2);
+      expect(keys).toContain('prefix/key1');
+      expect(keys).toContain('prefix/key2');
+    });
+
+    it('should return empty array for non-matching prefix', async () => {
+      const keys = await provider.list('nonexistent/');
+      expect(keys).toHaveLength(0);
+    });
+
+    it('should handle empty prefix', async () => {
+      const keys = await provider.list('');
+      expect(keys).toHaveLength(4);
+    });
+  });
+});
+
+describe('MemoryNonceCacheProvider', () => {
+  let provider: MemoryNonceCacheProvider;
+
+  beforeEach(() => {
+    provider = new MemoryNonceCacheProvider();
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('has', () => {
+    it('should return false for non-existent nonces', async () => {
+      const has = await provider.has('nonexistent');
+      expect(has).toBe(false);
+    });
+
+    it('should return true for valid nonces', async () => {
+      await provider.add('nonce1', 5); // 5 seconds TTL
+      const has = await provider.has('nonce1');
+      expect(has).toBe(true);
+    });
+
+    it('should return false for expired nonces', async () => {
+      await provider.add('nonce1', -1); // Negative TTL = expired
+      const has = await provider.has('nonce1');
+      expect(has).toBe(false);
+    });
+
+    it('should remove expired nonces when checking', async () => {
+      await provider.add('nonce1', -1); // Negative TTL = expired
+      await provider.has('nonce1'); // This should remove it
+
+      // Check internal state
+      const has = await provider.has('nonce1');
+      expect(has).toBe(false);
+    });
+  });
+
+  describe('add', () => {
+    it('should add nonces with expiry', async () => {
+      await provider.add('nonce1', 5); // 5 seconds TTL
+      const has = await provider.has('nonce1');
+      expect(has).toBe(true);
+    });
+
+    it('should overwrite existing nonces', async () => {
+      await provider.add('nonce1', 5); // 5 seconds TTL
+      await provider.add('nonce1', 10); // 10 seconds TTL
+
+      // Advance time by 7 seconds (between 5 and 10)
+      vi.advanceTimersByTime(7000);
+
+      const has = await provider.has('nonce1');
+      expect(has).toBe(true); // Should still be valid with new expiry
+    });
+  });
+
+  describe('cleanup', () => {
+    it('should remove expired nonces', async () => {
+      await provider.add('expired', -1); // Negative TTL = expired
+      await provider.add('valid', 5); // 5 seconds TTL
+
+      await provider.cleanup();
+
+      expect(await provider.has('expired')).toBe(false);
+      expect(await provider.has('valid')).toBe(true);
+    });
+
+    it('should handle empty cache', async () => {
+      await expect(provider.cleanup()).resolves.toBeUndefined();
+    });
+  });
+
+  describe('destroy', () => {
+    it('should clear all nonces', async () => {
+      await provider.add('nonce1', 5); // 5 seconds TTL
+      await provider.add('nonce2', 5); // 5 seconds TTL
+
+      await provider.destroy();
+
+      expect(await provider.has('nonce1')).toBe(false);
+      expect(await provider.has('nonce2')).toBe(false);
+    });
+  });
+});
+
+describe('MemoryIdentityProvider', () => {
+  let provider: MemoryIdentityProvider;
+  let cryptoProvider: MockCryptoProvider;
+
+  beforeEach(() => {
+    cryptoProvider = new MockCryptoProvider();
+    provider = new MemoryIdentityProvider(cryptoProvider);
+  });
+
+  describe('getIdentity', () => {
+    it('should generate identity on first call', async () => {
+      const identity = await provider.getIdentity();
+
+      expect(identity).toBeDefined();
+      expect(identity.did).toMatch(/^did:key:z/);
+      expect(identity.kid).toBe(`${identity.did}#keys-1`);
+      expect(identity.privateKey).toMatch(/^[A-Za-z0-9+/=]+$/); // Valid base64 string
+      expect(identity.publicKey).toMatch(/^[A-Za-z0-9+/=]+$/); // Valid base64 string
+      expect(identity.type).toBe('development');
+      expect(identity.createdAt).toBeDefined();
+    });
+
+    it('should return same identity on subsequent calls', async () => {
+      const identity1 = await provider.getIdentity();
+      const identity2 = await provider.getIdentity();
+
+      expect(identity1).toEqual(identity2);
+    });
+
+    it('should throw without crypto provider', async () => {
+      const providerNoCrypto = new MemoryIdentityProvider();
+      await expect(providerNoCrypto.getIdentity()).rejects.toThrow('Crypto provider required');
+    });
+  });
+
+  describe('saveIdentity', () => {
+    it('should save and return the saved identity', async () => {
+      const customIdentity = {
+        did: 'did:key:zcustom',
+        kid: 'did:key:zcustom#keys-1',
+        privateKey: 'custom-private',
+        publicKey: 'custom-public',
+        createdAt: new Date().toISOString(),
+        type: 'production' as const,
+        metadata: { custom: true }
+      };
+
+      await provider.saveIdentity(customIdentity);
+      const retrieved = await provider.getIdentity();
+
+      expect(retrieved).toEqual(customIdentity);
+    });
+  });
+
+  describe('rotateKeys', () => {
+    it('should generate new identity', async () => {
+      const oldIdentity = await provider.getIdentity();
+      // Change the mock to return different keys for rotation
+      cryptoProvider.keyPairResult = {
+        privateKey: 'cm90YXRlZC1wcml2YXRlLWtleQ==', // base64 of "rotated-private-key"
+        publicKey: 'cm90YXRlZC1wdWJsaWMta2V5', // base64 of "rotated-public-key"
+      };
+      const newIdentity = await provider.rotateKeys();
+
+      expect(newIdentity.did).not.toBe(oldIdentity.did);
+      expect(newIdentity.privateKey).toMatch(/^[A-Za-z0-9+/=]+$/); // Valid base64 string
+      expect(newIdentity.publicKey).toMatch(/^[A-Za-z0-9+/=]+$/); // Valid base64 string
+    });
+
+    it('should return new identity on subsequent calls', async () => {
+      const oldIdentity = await provider.getIdentity();
+      // Change the mock to return different keys for rotation
+      cryptoProvider.keyPairResult = {
+        privateKey: 'cm90YXRlZC1wcml2YXRlLWtleQ==',
+        publicKey: 'cm90YXRlZC1wdWJsaWMta2V5',
+      };
+      await provider.rotateKeys();
+      const currentIdentity = await provider.getIdentity();
+
+      expect(currentIdentity.did).not.toBe(oldIdentity.did);
+    });
+
+    it('should throw without crypto provider', async () => {
+      const providerNoCrypto = new MemoryIdentityProvider();
+      await expect(providerNoCrypto.rotateKeys()).rejects.toThrow('Crypto provider required');
+    });
+  });
+
+  describe('deleteIdentity', () => {
+    it('should delete existing identity', async () => {
+      const identity = await provider.getIdentity();
+      // Change mock keys so regenerated identity differs
+      cryptoProvider.keyPairResult = {
+        privateKey: 'ZGVsZXRlZC1wcml2YXRlLWtleQ==', // base64 of "deleted-private-key"
+        publicKey: 'ZGVsZXRlZC1wdWJsaWMta2V5', // base64 of "deleted-public-key"
+      };
+      await provider.deleteIdentity();
+
+      // Should generate new identity after deletion
+      const newIdentity = await provider.getIdentity();
+      expect(newIdentity.did).not.toBe(identity.did);
+    });
+
+    it('should handle deleting when no identity exists', async () => {
+      await expect(provider.deleteIdentity()).resolves.toBeUndefined();
+    });
+  });
+
+  describe('DID generation', () => {
+    it('should generate consistent DID format', async () => {
+      const identity = await provider.getIdentity();
+      expect(identity.did).toMatch(/^did:key:z[A-Za-z0-9]+$/);
+    });
+
+    it('should generate proper did:key DID from public key', async () => {
+      const identity = await provider.getIdentity();
+      // The DID should start with did:key:z (multibase base58btc prefix)
+      expect(identity.did).toMatch(/^did:key:z/);
+      // DID should be longer than just the prefix (base58btc encoded Ed25519 multicodec + key)
+      expect(identity.did.length).toBeGreaterThan(10);
+    });
+  });
+});

package/src/__tests__/utils/mock-providers.ts

@@ -0,0 +1,319 @@
+/**
+ * Mock Provider Implementations for Testing
+ *
+ * Provides controllable mock versions of all provider abstract classes.
+ */
+
+import { vi } from 'vitest';
+import {
+  CryptoProvider,
+  ClockProvider,
+  FetchProvider,
+  StorageProvider,
+  NonceCacheProvider,
+  IdentityProvider,
+  type AgentIdentity,
+} from '../../providers/base.js';
+import type { DIDDocument } from '../../delegation/vc-verifier.js';
+import type { StatusList2021Credential, DelegationRecord } from '../../types/protocol.js';
+
+/**
+ * Mock Crypto Provider
+ */
+export class MockCryptoProvider extends CryptoProvider {
+  public signResult = new Uint8Array([1, 2, 3, 4]);
+  public verifyResult = true;
+  public hashResult = 'sha256:mock-hash';
+  public keyPairResult = {
+    privateKey: 'bW9jay1wcml2YXRlLWtleQ==', // base64 of "mock-private-key"
+    publicKey: 'bW9jay1wdWJsaWMta2V5', // base64 of "mock-public-key"
+  };
+
+  async sign(_data: Uint8Array, _privateKey: string): Promise<Uint8Array> {
+    return this.signResult;
+  }
+
+  async verify(
+    _data: Uint8Array,
+    _signature: Uint8Array,
+    _publicKey: string
+  ): Promise<boolean> {
+    return this.verifyResult;
+  }
+
+  async generateKeyPair(): Promise<{ privateKey: string; publicKey: string }> {
+    return this.keyPairResult;
+  }
+
+  async hash(_data: Uint8Array): Promise<string> {
+    return this.hashResult;
+  }
+
+  async randomBytes(length: number): Promise<Uint8Array> {
+    return new Uint8Array(length).fill(42);
+  }
+}
+
+/**
+ * Mock Clock Provider
+ */
+export class MockClockProvider extends ClockProvider {
+  private currentTime: number = Date.now();
+
+  setTime(time: number): void {
+    this.currentTime = time;
+  }
+
+  advance(ms: number): void {
+    this.currentTime += ms;
+  }
+
+  now(): number {
+    return this.currentTime;
+  }
+
+  isWithinSkew(timestamp: number, skewSeconds: number): boolean {
+    const skewMs = skewSeconds * 1000;
+    return Math.abs(this.currentTime - timestamp) <= skewMs;
+  }
+
+  hasExpired(expiresAt: number): boolean {
+    return this.currentTime > expiresAt;
+  }
+
+  calculateExpiry(ttlSeconds: number): number {
+    return this.currentTime + ttlSeconds * 1000;
+  }
+
+  format(timestamp: number): string {
+    return new Date(timestamp).toISOString();
+  }
+}
+
+/**
+ * Mock Fetch Provider
+ */
+export class MockFetchProvider extends FetchProvider {
+  private didDocuments = new Map<string, DIDDocument>();
+  private statusLists = new Map<string, StatusList2021Credential>();
+  private delegationChains = new Map<string, DelegationRecord[]>();
+  public fetch: (url: string, options?: unknown) => Promise<Response>;
+
+  constructor() {
+    super();
+    this.fetch = vi.fn(
+      async (url: string, _options?: unknown): Promise<Response> => {
+        return new Response(JSON.stringify({ url }), {
+          status: 200,
+          headers: { 'Content-Type': 'application/json' },
+        });
+      }
+    ) as (url: string, options?: unknown) => Promise<Response>;
+  }
+
+  setDIDDocument(did: string, doc: DIDDocument): void {
+    this.didDocuments.set(did, doc);
+  }
+
+  setStatusList(url: string, list: StatusList2021Credential): void {
+    this.statusLists.set(url, list);
+  }
+
+  setDelegationChain(id: string, chain: DelegationRecord[]): void {
+    this.delegationChains.set(id, chain);
+  }
+
+  async resolveDID(did: string): Promise<DIDDocument | null> {
+    return this.didDocuments.get(did) ?? null;
+  }
+
+  async fetchStatusList(url: string): Promise<StatusList2021Credential | null> {
+    return this.statusLists.get(url) ?? null;
+  }
+
+  async fetchDelegationChain(id: string): Promise<DelegationRecord[]> {
+    return this.delegationChains.get(id) ?? [];
+  }
+}
+
+/**
+ * Mock Storage Provider
+ */
+export class MockStorageProvider extends StorageProvider {
+  private store: Map<string, string> = new Map();
+
+  async get(key: string): Promise<string | null> {
+    return this.store.get(key) || null;
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    this.store.set(key, value);
+  }
+
+  async delete(key: string): Promise<void> {
+    this.store.delete(key);
+  }
+
+  async exists(key: string): Promise<boolean> {
+    return this.store.has(key);
+  }
+
+  async list(prefix?: string): Promise<string[]> {
+    const keys = Array.from(this.store.keys());
+    if (prefix) {
+      return keys.filter((k) => k.startsWith(prefix));
+    }
+    return keys;
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+}
+
+/**
+ * Mock Nonce Cache Provider
+ */
+export class MockNonceCacheProvider extends NonceCacheProvider {
+  private nonces: Map<string, number> = new Map();
+  public cleanupCalled = false;
+  public destroyCalled = false;
+  private clock?: ClockProvider;
+
+  setClock(clock: ClockProvider): void {
+    this.clock = clock;
+  }
+
+  async has(nonce: string, agentDid?: string): Promise<boolean> {
+    const key = agentDid ? `nonce:${agentDid}:${nonce}` : `nonce:${nonce}`;
+    const expiry = this.nonces.get(key);
+    if (!expiry) return false;
+
+    const now = this.clock ? this.clock.now() : Date.now();
+    if (now > expiry) {
+      this.nonces.delete(key);
+      return false;
+    }
+
+    return true;
+  }
+
+  async add(
+    nonce: string,
+    ttlSeconds: number,
+    agentDid?: string
+  ): Promise<void> {
+    const key = agentDid ? `nonce:${agentDid}:${nonce}` : `nonce:${nonce}`;
+    const now = this.clock ? this.clock.now() : Date.now();
+    const expiresAt = now + ttlSeconds * 1000;
+    this.nonces.set(key, expiresAt);
+  }
+
+  async cleanup(): Promise<void> {
+    this.cleanupCalled = true;
+    const now = this.clock ? this.clock.now() : Date.now();
+    for (const [nonce, expiry] of this.nonces) {
+      if (now > expiry) {
+        this.nonces.delete(nonce);
+      }
+    }
+  }
+
+  async destroy(): Promise<void> {
+    this.destroyCalled = true;
+    this.nonces.clear();
+  }
+
+  clear(): void {
+    this.nonces.clear();
+  }
+
+  size(): number {
+    return this.nonces.size;
+  }
+}
+
+/**
+ * Mock Identity Provider
+ */
+export class MockIdentityProvider extends IdentityProvider {
+  private identity?: AgentIdentity;
+  public rotateKeysCalled = false;
+  public deleteIdentityCalled = false;
+  private rotateCount = 0;
+
+  constructor(identity?: AgentIdentity) {
+    super();
+    this.identity = identity;
+  }
+
+  async getIdentity(): Promise<AgentIdentity> {
+    if (!this.identity) {
+      this.identity = {
+        did: 'did:key:zmock123',
+        kid: 'did:key:zmock123#keys-1',
+        privateKey: 'mock-private-key',
+        publicKey: 'mock-public-key',
+        createdAt: new Date().toISOString(),
+        type: 'development',
+        metadata: { mock: true },
+      };
+    }
+    return this.identity;
+  }
+
+  async saveIdentity(identity: AgentIdentity): Promise<void> {
+    this.identity = identity;
+  }
+
+  async rotateKeys(): Promise<AgentIdentity> {
+    this.rotateKeysCalled = true;
+    this.rotateCount++;
+    this.identity = {
+      did: `did:key:zmock456-${this.rotateCount}`,
+      kid: `did:key:zmock456-${this.rotateCount}#keys-1`,
+      privateKey: `mock-private-key-rotated-${this.rotateCount}`,
+      publicKey: `mock-public-key-rotated-${this.rotateCount}`,
+      createdAt: new Date().toISOString(),
+      type: 'development',
+      metadata: {
+        mock: true,
+        rotated: true,
+        rotateCount: this.rotateCount,
+      },
+    };
+    return this.identity;
+  }
+
+  async deleteIdentity(): Promise<void> {
+    this.deleteIdentityCalled = true;
+    this.identity = undefined;
+  }
+
+  setIdentity(identity: AgentIdentity): void {
+    this.identity = identity;
+  }
+}
+
+/**
+ * Create a full set of mock providers for testing
+ */
+export function createMockProviders() {
+  const cryptoProvider = new MockCryptoProvider();
+  const clockProvider = new MockClockProvider();
+  const fetchProvider = new MockFetchProvider();
+  const storageProvider = new MockStorageProvider();
+  const nonceCacheProvider = new MockNonceCacheProvider();
+  const identityProvider = new MockIdentityProvider();
+
+  nonceCacheProvider.setClock(clockProvider);
+
+  return {
+    cryptoProvider,
+    clockProvider,
+    fetchProvider,
+    storageProvider,
+    nonceCacheProvider,
+    identityProvider,
+  };
+}