@kya-os/mcp-i-core 1.3.12 → 1.3.14

package/src/__tests__/runtime/base-extensions.test.ts

@@ -1,595 +0,0 @@
-/**
- * Base Extensions Tests
- *
- * Tests for extension methods, edge cases, and additional functionality
- * not covered in base.test.ts.
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { MCPIRuntimeBase } from '../../runtime/base';
-import { ProviderRuntimeConfig } from '../../config';
-import { createMockProviders, MockClockProvider, MockFetchProvider, MockIdentityProvider } from '../utils/mock-providers';
-import { UserDidManager } from '../../identity/user-did-manager';
-
-describe('MCPIRuntimeBase - Base Extensions', () => {
-  let runtime: MCPIRuntimeBase;
-  let config: ProviderRuntimeConfig;
-  let mockProviders: ReturnType<typeof createMockProviders>;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    mockProviders = createMockProviders();
-    config = {
-      ...mockProviders,
-      environment: 'development',
-      session: {
-        timestampSkewSeconds: 120,
-        ttlMinutes: 30
-      },
-      audit: {
-        enabled: false
-      }
-    };
-    runtime = new MCPIRuntimeBase(config);
-  });
-
-  describe('initialize with user DID generation', () => {
-    it('should initialize UserDidManager when generateUserDids enabled', async () => {
-      const configWithUserDid = {
-        ...config,
-        identity: {
-          enabled: true,
-          generateUserDids: true,
-          environment: 'development',
-          userDidStorage: 'ephemeral'
-        }
-      };
-      const runtimeWithUserDid = new MCPIRuntimeBase(configWithUserDid);
-      await runtimeWithUserDid.initialize();
-
-      const userDidManager = (runtimeWithUserDid as any).userDidManager;
-      expect(userDidManager).toBeInstanceOf(UserDidManager);
-    });
-
-    it('should not initialize UserDidManager when generateUserDids disabled', async () => {
-      const configWithoutUserDid = {
-        ...config,
-        identity: {
-          enabled: true,
-          generateUserDids: false,
-          environment: 'development'
-        }
-      };
-      const runtimeWithoutUserDid = new MCPIRuntimeBase(configWithoutUserDid);
-      await runtimeWithoutUserDid.initialize();
-
-      const userDidManager = (runtimeWithoutUserDid as any).userDidManager;
-      expect(userDidManager).toBeUndefined();
-    });
-
-    it('should initialize UserDidManager with persistent storage when configured', async () => {
-      const configWithPersistent = {
-        ...config,
-        identity: {
-          enabled: true,
-          generateUserDids: true,
-          environment: 'development',
-          userDidStorage: 'persistent'
-        }
-      };
-      const runtimeWithPersistent = new MCPIRuntimeBase(configWithPersistent);
-      await runtimeWithPersistent.initialize();
-
-      const userDidManager = (runtimeWithPersistent as any).userDidManager;
-      expect(userDidManager).toBeInstanceOf(UserDidManager);
-    });
-
-    it('should handle UserDidManager initialization errors gracefully', async () => {
-      const configWithUserDid = {
-        ...config,
-        identity: {
-          enabled: true,
-          generateUserDids: true,
-          environment: 'development'
-        }
-      };
-      const runtimeWithUserDid = new MCPIRuntimeBase(configWithUserDid);
-      
-      // Mock storage.set to throw error
-      const originalSet = mockProviders.storageProvider.set;
-      mockProviders.storageProvider.set = vi.fn().mockRejectedValue(new Error('Storage error'));
-
-      // Should not throw
-      await expect(runtimeWithUserDid.initialize()).resolves.not.toThrow();
-
-      // Restore original
-      mockProviders.storageProvider.set = originalSet;
-    });
-  });
-
-  describe('handleHandshake with user DID generation', () => {
-    it('should start session as anonymous (Phase 5)', async () => {
-      // Phase 5: Sessions start anonymous - userDid is only set after OAuth
-      const configWithUserDid = {
-        ...config,
-        identity: {
-          enabled: true,
-          generateUserDids: true,
-          environment: 'development'
-        }
-      };
-      const runtimeWithUserDid = new MCPIRuntimeBase(configWithUserDid);
-      await runtimeWithUserDid.initialize();
-
-      const response = await runtimeWithUserDid.handleHandshake({
-        audience: 'https://client.example.com'
-      });
-
-      // Phase 5: userDid is undefined in response - session is anonymous
-      expect(response.userDid).toBeUndefined();
-
-      // Check session's identityState
-      const session = await runtimeWithUserDid.getCurrentSession();
-      expect(session.identityState).toBe('anonymous');
-    });
-
-    it('should use provided clientDid with anonymous session (Phase 5)', async () => {
-      // Phase 5: clientDid can be set while session stays anonymous (no userDid)
-      const configWithUserDid = {
-        ...config,
-        identity: {
-          enabled: true,
-          generateUserDids: true,
-          environment: 'development'
-        }
-      };
-      const runtimeWithUserDid = new MCPIRuntimeBase(configWithUserDid);
-      await runtimeWithUserDid.initialize();
-
-      const response = await runtimeWithUserDid.handleHandshake({
-        clientDid: 'did:key:zprovided123',
-        audience: 'https://client.example.com'
-      });
-
-      const session = await runtimeWithUserDid.getCurrentSession();
-      expect(session.clientDid).toBe('did:key:zprovided123');
-
-      // Phase 5: userDid is undefined - session is anonymous until OAuth
-      expect(session.userDid).toBeUndefined();
-      expect(session.identityState).toBe('anonymous');
-    });
-
-    it('should handle user DID generation errors gracefully', async () => {
-      const configWithUserDid = {
-        ...config,
-        identity: {
-          enabled: true,
-          generateUserDids: true,
-          environment: 'development'
-        }
-      };
-      const runtimeWithUserDid = new MCPIRuntimeBase(configWithUserDid);
-      await runtimeWithUserDid.initialize();
-
-      // Phase 5: getOrCreateUserDid now returns null instead of generating ephemeral DIDs
-      // Sessions start anonymous - no userDid at handshake
-      const userDidManager = (runtimeWithUserDid as any).userDidManager;
-      const originalGetOrCreate = userDidManager.getOrCreateUserDid;
-      userDidManager.getOrCreateUserDid = vi.fn().mockResolvedValue(null);
-
-      const response = await runtimeWithUserDid.handleHandshake({
-        audience: 'https://client.example.com'
-      });
-
-      // Should succeed with anonymous session (no userDid)
-      expect(response.sessionId).toBeDefined();
-
-      // Phase 5: Session should be anonymous without userDid
-      const session = await runtimeWithUserDid.getCurrentSession();
-      expect(session.userDid).toBeUndefined();
-      expect(session.identityState).toBe('anonymous');
-
-      userDidManager.getOrCreateUserDid = originalGetOrCreate;
-    });
-  });
-
-  describe('createWellKnownHandler edge cases', () => {
-    let handler: any;
-
-    beforeEach(async () => {
-      await runtime.initialize();
-      handler = runtime.createWellKnownHandler({
-        serviceName: 'Test Service',
-        serviceEndpoint: 'https://test.example.com'
-      });
-    });
-
-    it('should handle /.well-known/agent.json with all fields', async () => {
-      const response = await handler('/.well-known/agent.json');
-
-      expect(response.status).toBe(200);
-      expect(response.headers['Content-Type']).toBe('application/json');
-
-      const result = JSON.parse(response.body);
-      expect(result.id).toBe('did:key:zmock123');
-      expect(result.capabilities).toEqual({
-        'mcp-i': ['handshake', 'signing', 'verification']
-      });
-      expect(result.metadata.name).toBe('Test Service');
-      expect(result.metadata.serviceEndpoint).toBe('https://test.example.com');
-    });
-
-    it('should handle /.well-known/agent.json with partial config', async () => {
-      const partialHandler = runtime.createWellKnownHandler({
-        serviceName: 'Partial Service'
-      });
-
-      const response = await partialHandler('/.well-known/agent.json');
-      const result = JSON.parse(response.body);
-
-      expect(result.metadata.name).toBe('Partial Service');
-      // serviceEndpoint may not be included if not provided in config
-      if (result.metadata.serviceEndpoint) {
-        expect(result.metadata.serviceEndpoint).toBe('https://example.com');
-      }
-    });
-
-    it('should set cache headers based on environment', async () => {
-      const prodConfig = {
-        ...config,
-        environment: 'production'
-      };
-      const prodRuntime = new MCPIRuntimeBase(prodConfig);
-      await prodRuntime.initialize();
-
-      const prodHandler = prodRuntime.createWellKnownHandler();
-      const response = await prodHandler('/.well-known/did.json');
-
-      expect(response.headers['Cache-Control']).toBe('public, max-age=300');
-    });
-
-    it('should set no-store cache headers in development', async () => {
-      const response = await handler('/.well-known/did.json');
-      expect(response.headers['Cache-Control']).toBe('no-store');
-    });
-
-    it('should handle unknown paths gracefully', async () => {
-      const result = await handler('/.well-known/unknown');
-      expect(result).toBeNull();
-    });
-
-    it('should handle empty path', async () => {
-      const result = await handler('');
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('createDebugEndpoint edge cases', () => {
-    it('should return null in production environment', () => {
-      const prodConfig = {
-        ...config,
-        environment: 'production'
-      };
-      const prodRuntime = new MCPIRuntimeBase(prodConfig);
-      const endpoint = prodRuntime.createDebugEndpoint();
-      expect(endpoint).toBeNull();
-    });
-
-    it('should include all config values in debug output', async () => {
-      const customConfig = {
-        ...config,
-        environment: 'development',
-        session: {
-          timestampSkewSeconds: 60,
-          ttlMinutes: 60
-        }
-      };
-      const customRuntime = new MCPIRuntimeBase(customConfig);
-      await customRuntime.initialize();
-
-      const endpoint = customRuntime.createDebugEndpoint();
-      const result = await endpoint!();
-
-      expect(result.config.timestampSkewSeconds).toBe(60);
-      expect(result.config.sessionTtlMinutes).toBe(60);
-      expect(result.config.environment).toBe('development');
-    });
-
-    it('should handle missing session gracefully', async () => {
-      await runtime.initialize();
-      const endpoint = runtime.createDebugEndpoint();
-      const result = await endpoint!();
-
-      expect(result.session).toBeNull();
-    });
-  });
-
-  describe('getAuditLogger', () => {
-    it('should return logger with log method', () => {
-      const logger = runtime.getAuditLogger();
-      expect(logger).toBeDefined();
-      expect(typeof logger.log).toBe('function');
-    });
-
-    it('should log through runtime audit system', async () => {
-      const auditConfig = {
-        ...config,
-        audit: {
-          enabled: true,
-          logFunction: vi.fn(),
-          includePayloads: true
-        }
-      };
-      const auditRuntime = new MCPIRuntimeBase(auditConfig);
-      await auditRuntime.initialize();
-
-      const logger = auditRuntime.getAuditLogger();
-      logger.log('test_event', { test: 'data' });
-
-      expect(auditConfig.audit!.logFunction).toHaveBeenCalledWith(
-        expect.stringContaining('test_event')
-      );
-    });
-
-    it('should handle audit disabled', () => {
-      const noAuditConfig = {
-        ...config,
-        audit: {
-          enabled: false
-        }
-      };
-      const noAuditRuntime = new MCPIRuntimeBase(noAuditConfig);
-      const logger = noAuditRuntime.getAuditLogger();
-
-      // Should not throw
-      logger.log('test_event', { test: 'data' });
-    });
-  });
-
-  describe('rotateKeys', () => {
-    beforeEach(async () => {
-      await runtime.initialize();
-    });
-
-    it('should update cached identity after rotation', async () => {
-      const oldIdentity = await runtime.getIdentity();
-      const newIdentity = await runtime.rotateKeys();
-      
-      const currentIdentity = await runtime.getIdentity();
-      expect(currentIdentity.did).toBe(newIdentity.did);
-      expect(currentIdentity.did).not.toBe(oldIdentity.did);
-    });
-
-    it('should handle rotation errors gracefully', async () => {
-      const identityProvider = mockProviders.identityProvider as MockIdentityProvider;
-      const originalRotate = identityProvider.rotateKeys;
-      identityProvider.rotateKeys = vi.fn().mockRejectedValue(new Error('Rotation failed'));
-
-      await expect(runtime.rotateKeys()).rejects.toThrow('Rotation failed');
-
-      identityProvider.rotateKeys = originalRotate;
-    });
-  });
-
-  describe('helper methods', () => {
-    beforeEach(async () => {
-      await runtime.initialize();
-    });
-
-    describe('extractPublicKey', () => {
-      it('should extract publicKeyBase64 from DID document', () => {
-        const didDoc = {
-          verificationMethod: [{
-            publicKeyBase64: 'test-key-base64'
-          }]
-        };
-
-        const extractPublicKey = (runtime as any).extractPublicKey.bind(runtime);
-        const publicKey = extractPublicKey(didDoc);
-        expect(publicKey).toBe('test-key-base64');
-      });
-
-      it('should extract publicKeyMultibase from DID document', () => {
-        const didDoc = {
-          verificationMethod: [{
-            publicKeyMultibase: 'zmultibase-key'
-          }]
-        };
-
-        const extractPublicKey = (runtime as any).extractPublicKey.bind(runtime);
-        const publicKey = extractPublicKey(didDoc);
-        expect(publicKey).toBe('zmultibase-key');
-      });
-
-      it('should prioritize publicKeyBase64 over publicKeyMultibase', () => {
-        const didDoc = {
-          verificationMethod: [{
-            publicKeyBase64: 'base64-key',
-            publicKeyMultibase: 'multibase-key'
-          }]
-        };
-
-        const extractPublicKey = (runtime as any).extractPublicKey.bind(runtime);
-        const publicKey = extractPublicKey(didDoc);
-        expect(publicKey).toBe('base64-key');
-      });
-
-      it('should throw if no public key found', () => {
-        const didDoc = {
-          verificationMethod: [{}]
-        };
-
-        const extractPublicKey = (runtime as any).extractPublicKey.bind(runtime);
-        expect(() => extractPublicKey(didDoc)).toThrow('Public key not found');
-      });
-
-      it('should throw if verificationMethod is empty', () => {
-        const didDoc = {
-          verificationMethod: []
-        };
-
-        const extractPublicKey = (runtime as any).extractPublicKey.bind(runtime);
-        expect(() => extractPublicKey(didDoc)).toThrow('Public key not found');
-      });
-
-      it('should throw if verificationMethod is missing', () => {
-        const didDoc = {};
-
-        const extractPublicKey = (runtime as any).extractPublicKey.bind(runtime);
-        expect(() => extractPublicKey(didDoc)).toThrow('Public key not found');
-      });
-    });
-
-    describe('bytesToBase64', () => {
-      it('should convert Uint8Array to base64', () => {
-        const bytes = new Uint8Array([1, 2, 3, 4, 5]);
-        const bytesToBase64 = (runtime as any).bytesToBase64.bind(runtime);
-        const base64 = bytesToBase64(bytes);
-        expect(base64).toBeDefined();
-        expect(typeof base64).toBe('string');
-      });
-    });
-
-    describe('base64ToBytes', () => {
-      it('should convert base64 to Uint8Array', () => {
-        const base64 = Buffer.from([1, 2, 3, 4, 5]).toString('base64');
-        const base64ToBytes = (runtime as any).base64ToBytes.bind(runtime);
-        const bytes = base64ToBytes(base64);
-        expect(bytes).toBeInstanceOf(Uint8Array);
-        expect(bytes.length).toBe(5);
-      });
-    });
-
-    describe('bytesToHex', () => {
-      it('should convert Uint8Array to hex string', () => {
-        const bytes = new Uint8Array([1, 2, 3, 4, 5]);
-        const bytesToHex = (runtime as any).bytesToHex.bind(runtime);
-        const hex = bytesToHex(bytes);
-        expect(hex).toBeDefined();
-        expect(typeof hex).toBe('string');
-        expect(hex.length).toBe(10); // 5 bytes * 2 hex chars
-      });
-    });
-  });
-
-  describe('session management edge cases', () => {
-    beforeEach(async () => {
-      await runtime.initialize();
-    });
-
-    it('should handle multiple sessions', async () => {
-      const handshake1 = await runtime.handleHandshake({
-        clientDid: 'did:key:zclient1',
-        audience: 'https://client1.example.com'
-      });
-
-      const handshake2 = await runtime.handleHandshake({
-        clientDid: 'did:key:zclient2',
-        audience: 'https://client2.example.com'
-      });
-
-      const session = await runtime.getCurrentSession();
-      // Should return a non-expired session (could be either)
-      expect(session).toBeDefined();
-      expect([handshake1.sessionId, handshake2.sessionId]).toContain(session.id);
-    });
-
-    it('should filter out expired sessions', async () => {
-      const clock = mockProviders.clockProvider as MockClockProvider;
-      const currentTime = Date.now();
-      clock.setTime(currentTime);
-
-      const handshake1 = await runtime.handleHandshake({
-        clientDid: 'did:key:zclient1',
-        audience: 'https://client1.example.com'
-      });
-
-      // Advance time past expiry
-      clock.setTime(currentTime + (31 * 60 * 1000));
-
-      const handshake2 = await runtime.handleHandshake({
-        clientDid: 'did:key:zclient2',
-        audience: 'https://client2.example.com'
-      });
-
-      const session = await runtime.getCurrentSession();
-      expect(session.id).toBe(handshake2.sessionId);
-    });
-
-    it('should handle empty sessions map', async () => {
-      const session = await runtime.getCurrentSession();
-      expect(session).toBeNull();
-    });
-  });
-
-  describe('nonce cache integration', () => {
-    beforeEach(async () => {
-      await runtime.initialize();
-    });
-
-    it('should cache nonce with proper expiry', async () => {
-      const clock = mockProviders.clockProvider as MockClockProvider;
-      const currentTime = Date.now();
-      clock.setTime(currentTime);
-
-      const nonce = await runtime.issueNonce('session123');
-      const nonceCache = mockProviders.nonceCacheProvider as any;
-      const identity = await runtime.getIdentity();
-      expect(await nonceCache.has(nonce, identity.did)).toBe(true);
-
-      // Advance time past expiry
-      clock.setTime(currentTime + (5 * 60 * 1000) + 1);
-      expect(await nonceCache.has(nonce, identity.did)).toBe(false);
-    });
-
-    it('should use session nonce if provided', async () => {
-      const session = {
-        id: 'session123',
-        audience: 'https://client.example.com',
-        nonce: 'pre-generated-nonce'
-      };
-
-      const proof = await runtime.createProof({ test: 'data' }, session);
-      expect(proof.nonce).toBe('pre-generated-nonce');
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle identity provider errors gracefully', async () => {
-      const identityProvider = mockProviders.identityProvider as MockIdentityProvider;
-      const originalGetIdentity = identityProvider.getIdentity;
-      identityProvider.getIdentity = vi.fn().mockRejectedValue(new Error('Identity error'));
-
-      await expect(runtime.getIdentity()).rejects.toThrow('Identity error');
-
-      identityProvider.getIdentity = originalGetIdentity;
-    });
-
-    it('should handle crypto provider errors gracefully', async () => {
-      const originalSign = mockProviders.cryptoProvider.sign;
-      mockProviders.cryptoProvider.sign = vi.fn().mockRejectedValue(new Error('Crypto error'));
-
-      await expect(
-        runtime.createProof({ test: 'data' })
-      ).rejects.toThrow('Crypto error');
-
-      mockProviders.cryptoProvider.sign = originalSign;
-    });
-
-    it('should handle fetch provider errors in verifyProof', async () => {
-      await runtime.initialize();
-
-      const fetchProvider = mockProviders.fetchProvider as MockFetchProvider;
-      const originalResolveDID = fetchProvider.resolveDID;
-      fetchProvider.resolveDID = vi.fn().mockRejectedValue(new Error('DID resolution failed'));
-
-      const proof = await runtime.createProof({ test: 'data' });
-      const isValid = await runtime.verifyProof({ test: 'data' }, proof);
-
-      expect(isValid).toBe(false); // Should return false on error
-
-      fetchProvider.resolveDID = originalResolveDID;
-    });
-  });
-});
-