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

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

@@ -1,319 +0,0 @@
-/**
- * Tests for Memory Provider Implementations
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import {
-  MemoryStorageProvider,
-  MemoryNonceCacheProvider,
-  MemoryIdentityProvider
-} from '../../providers/memory';
-import { MockCryptoProvider } from '../utils/mock-providers';
-
-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}#key-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#key-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();
-      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();
-      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();
-      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 DID from public key', async () => {
-      // Test the DID generation logic
-      const identity = await provider.getIdentity();
-      const publicKeyPart = Buffer.from(identity.publicKey, 'base64')
-        .toString('base64url')
-        .substring(0, 32);
-      
-      expect(identity.did).toBe(`did:key:z${publicKeyPart}`);
-    });
-  });
-});