@kya-os/mcp-i-core 1.2.3-canary.7 → 1.3.0-canary.clientinfo.20251126003544

package/src/__tests__/identity/user-did-manager.test.ts

@@ -0,0 +1,213 @@
+/**
+ * User DID Manager Tests
+ *
+ * Tests for ephemeral user DID generation and management.
+ */
+
+import { describe, test, expect, beforeEach, vi } from 'vitest';
+import { UserDidManager, type UserDidStorage } from '../../identity/user-did-manager';
+import { MockCryptoProvider } from '../utils/mock-providers';
+
+describe('UserDidManager', () => {
+  let cryptoProvider: MockCryptoProvider;
+  let storage: UserDidStorage;
+  let manager: UserDidManager;
+
+  beforeEach(() => {
+    cryptoProvider = new MockCryptoProvider();
+    storage = {
+      get: vi.fn(),
+      set: vi.fn(),
+      delete: vi.fn(),
+    };
+    manager = new UserDidManager({
+      crypto: cryptoProvider,
+      storage,
+    });
+  });
+
+  describe('getOrCreateUserDid', () => {
+  test('should generate new did:key for new session', async () => {
+    const sessionId = 'session-123';
+    
+    // Mock generateKeyPair to return valid base64 keys
+    const mockKeyPair = {
+      privateKey: Buffer.from(new Uint8Array(32).fill(1)).toString('base64'),
+      publicKey: Buffer.from(new Uint8Array(32).fill(2)).toString('base64'),
+    };
+    vi.spyOn(cryptoProvider, 'generateKeyPair').mockResolvedValue(mockKeyPair);
+    
+    const userDid = await manager.getOrCreateUserDid(sessionId);
+
+    expect(userDid).toMatch(/^did:key:z/);
+    expect(userDid.length).toBeGreaterThan(40);
+  });
+
+    test('should return same DID for same session', async () => {
+      const sessionId = 'session-123';
+      const did1 = await manager.getOrCreateUserDid(sessionId);
+      const did2 = await manager.getOrCreateUserDid(sessionId);
+
+      expect(did1).toBe(did2);
+    });
+
+    test('should return different DIDs for different sessions', async () => {
+      const did1 = await manager.getOrCreateUserDid('session-1');
+      const did2 = await manager.getOrCreateUserDid('session-2');
+
+      expect(did1).not.toBe(did2);
+    });
+
+    test('should retrieve DID from storage if available', async () => {
+      const sessionId = 'session-123';
+      const storedDid = 'did:key:zTestStoredDID';
+      (storage.get as ReturnType<typeof vi.fn>).mockResolvedValue(storedDid);
+
+      const did = await manager.getOrCreateUserDid(sessionId);
+
+      expect(did).toBe(storedDid);
+      expect(storage.get).toHaveBeenCalledWith(sessionId);
+    });
+
+    test('should store new DID in storage', async () => {
+      const sessionId = 'session-123';
+      const did = await manager.getOrCreateUserDid(sessionId);
+
+      expect(storage.set).toHaveBeenCalledWith(sessionId, did, 1800);
+    });
+
+    test('should use cache for subsequent calls', async () => {
+      const sessionId = 'session-123';
+      const did1 = await manager.getOrCreateUserDid(sessionId);
+      
+      // Clear storage mock to ensure cache is used
+      (storage.get as ReturnType<typeof vi.fn>).mockResolvedValue(null);
+      
+      const did2 = await manager.getOrCreateUserDid(sessionId);
+
+      expect(did1).toBe(did2);
+      expect(storage.get).not.toHaveBeenCalledTimes(2); // Cache hit
+    });
+
+    test('should work without storage provider', async () => {
+      const ephemeralManager = new UserDidManager({
+        crypto: cryptoProvider,
+      });
+
+      const did = await ephemeralManager.getOrCreateUserDid('session-123');
+      expect(did).toMatch(/^did:key:z/);
+    });
+  });
+
+  describe('getUserDid', () => {
+    test('should return DID if exists in cache', async () => {
+      const sessionId = 'session-123';
+      const did = await manager.getOrCreateUserDid(sessionId);
+      
+      const retrievedDid = await manager.getUserDid(sessionId);
+      expect(retrievedDid).toBe(did);
+    });
+
+    test('should return DID if exists in storage', async () => {
+      const sessionId = 'session-123';
+      const storedDid = 'did:key:zTestStoredDID';
+      (storage.get as ReturnType<typeof vi.fn>).mockResolvedValue(storedDid);
+
+      const did = await manager.getUserDid(sessionId);
+      expect(did).toBe(storedDid);
+    });
+
+    test('should return null if DID does not exist', async () => {
+      const sessionId = 'new-session';
+      (storage.get as ReturnType<typeof vi.fn>).mockResolvedValue(null);
+
+      const did = await manager.getUserDid(sessionId);
+      expect(did).toBeNull();
+    });
+  });
+
+  describe('clearUserDid', () => {
+    test('should remove DID from cache and storage', async () => {
+      const sessionId = 'session-123';
+      await manager.getOrCreateUserDid(sessionId);
+
+      await manager.clearUserDid(sessionId);
+
+      const did = await manager.getUserDid(sessionId);
+      expect(did).toBeNull();
+      expect(storage.delete).toHaveBeenCalledWith(sessionId);
+    });
+  });
+
+  describe('clearCache', () => {
+    test('should clear all cached DIDs', async () => {
+      await manager.getOrCreateUserDid('session-1');
+      await manager.getOrCreateUserDid('session-2');
+
+      manager.clearCache();
+
+      // Cache should be empty, but storage should still have values
+      const did1 = await manager.getUserDid('session-1');
+      const did2 = await manager.getUserDid('session-2');
+      
+      // These will be null because we're using mocked storage
+      // But cache is definitely cleared
+      expect(did1).toBeNull();
+      expect(did2).toBeNull();
+    });
+  });
+
+  describe('DID format validation', () => {
+    test('should generate valid did:key format', async () => {
+      const did = await manager.getOrCreateUserDid('session-123');
+      
+      // did:key format: did:key:z<base58-encoded-multicodec-key>
+      expect(did).toMatch(/^did:key:z[1-9A-HJ-NP-Za-km-z]+$/);
+    });
+
+    test('should generate different DIDs each time generateUserDid is called', async () => {
+      const dids = new Set<string>();
+      
+      for (let i = 0; i < 10; i++) {
+        const manager = new UserDidManager({
+          crypto: cryptoProvider,
+        });
+        const did = await manager.getOrCreateUserDid(`session-${i}`);
+        dids.add(did);
+      }
+
+      // All DIDs should be unique
+      expect(dids.size).toBe(10);
+    });
+  });
+
+  describe('error handling', () => {
+    test('should handle storage.get errors gracefully', async () => {
+      const sessionId = 'session-123';
+      (storage.get as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('Storage error'));
+
+      // Should still generate DID despite storage error
+      const did = await manager.getOrCreateUserDid(sessionId);
+      expect(did).toMatch(/^did:key:z/);
+    });
+
+    test('should handle storage.set errors gracefully', async () => {
+      const sessionId = 'session-123';
+      (storage.set as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('Storage error'));
+
+      // Should still return DID despite storage error
+      const did = await manager.getOrCreateUserDid(sessionId);
+      expect(did).toMatch(/^did:key:z/);
+    });
+
+    test('should handle storage.delete errors gracefully', async () => {
+      const sessionId = 'session-123';
+      await manager.getOrCreateUserDid(sessionId);
+      (storage.delete as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('Storage error'));
+
+      // Should not throw
+      await expect(manager.clearUserDid(sessionId)).resolves.not.toThrow();
+    });
+  });
+});
+

package/src/__tests__/index.test.ts

@@ -0,0 +1,56 @@
+/**
+ * Tests for main exports from index.ts
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as exports from '../index';
+
+describe('Package exports', () => {
+  it('should export base providers', () => {
+    expect(exports.CryptoProvider).toBeDefined();
+    expect(exports.ClockProvider).toBeDefined();
+    expect(exports.FetchProvider).toBeDefined();
+    expect(exports.StorageProvider).toBeDefined();
+    expect(exports.NonceCacheProvider).toBeDefined();
+    expect(exports.IdentityProvider).toBeDefined();
+  });
+
+  it('should export memory providers', () => {
+    expect(exports.MemoryStorageProvider).toBeDefined();
+    expect(exports.MemoryNonceCacheProvider).toBeDefined();
+    expect(exports.MemoryIdentityProvider).toBeDefined();
+  });
+
+  it('should export runtime', () => {
+    expect(exports.MCPIRuntimeBase).toBeDefined();
+  });
+
+  it('should export types from contracts', () => {
+    // These are type exports, so we just check they exist in the module
+    const typeExports = [
+      'HandshakeRequest',
+      'SessionContext',
+      'NonceCache',
+      'NonceCacheEntry',
+      'NonceCacheConfig',
+      'ProofMeta',
+      'DetachedProof',
+      'CanonicalHashes',
+      'AuditRecord'
+    ];
+
+    // TypeScript types are erased at runtime, but we can check the module structure
+    expect(Object.keys(exports)).toEqual(expect.arrayContaining([
+      'CryptoProvider',
+      'ClockProvider',
+      'FetchProvider',
+      'StorageProvider',
+      'NonceCacheProvider',
+      'IdentityProvider',
+      'MemoryStorageProvider',
+      'MemoryNonceCacheProvider',
+      'MemoryIdentityProvider',
+      'MCPIRuntimeBase'
+    ]));
+  });
+});