@kya-os/create-mcpi-app 1.7.17 → 1.7.20

package/src/__tests__/helpers/generate-identity.test.ts

@@ -0,0 +1,271 @@
+/**
+ * Generate Identity Tests
+ *
+ * Tests for identity generation, key pair creation, DID format validation,
+ * and identity persistence.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  generateIdentity,
+  isValidDIDKey,
+  extractMultibaseFromDID,
+  type GeneratedIdentity
+} from '../../helpers/generate-identity';
+
+describe('generateIdentity', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Identity generation', () => {
+    it('should generate a valid identity', async () => {
+      const identity = await generateIdentity();
+
+      expect(identity).toBeDefined();
+      expect(identity.did).toBeDefined();
+      expect(identity.kid).toBeDefined();
+      expect(identity.privateKey).toBeDefined();
+      expect(identity.publicKey).toBeDefined();
+      expect(identity.createdAt).toBeDefined();
+      expect(identity.type).toBe('development');
+    });
+
+    it('should generate unique identities on each call', async () => {
+      const identity1 = await generateIdentity();
+      const identity2 = await generateIdentity();
+
+      expect(identity1.did).not.toBe(identity2.did);
+      expect(identity1.privateKey).not.toBe(identity2.privateKey);
+      expect(identity1.publicKey).not.toBe(identity2.publicKey);
+    });
+
+    it('should generate identity with correct structure', async () => {
+      const identity = await generateIdentity();
+
+      expect(typeof identity.did).toBe('string');
+      expect(typeof identity.kid).toBe('string');
+      expect(typeof identity.privateKey).toBe('string');
+      expect(typeof identity.publicKey).toBe('string');
+      expect(typeof identity.createdAt).toBe('string');
+      expect(typeof identity.type).toBe('string');
+    });
+
+    it('should generate identity with valid ISO timestamp', async () => {
+      const identity = await generateIdentity();
+      const timestamp = new Date(identity.createdAt);
+
+      expect(timestamp.getTime()).not.toBeNaN();
+      expect(timestamp.toISOString()).toBe(identity.createdAt);
+    });
+  });
+
+  describe('Key pair creation', () => {
+    it('should generate valid Ed25519 key pair', async () => {
+      const identity = await generateIdentity();
+
+      // Private key should be base64 encoded (32 bytes raw = 44 chars base64)
+      const privateKeyBuffer = Buffer.from(identity.privateKey, 'base64');
+      expect(privateKeyBuffer.length).toBe(32);
+
+      // Public key should be base64 encoded (32 bytes raw = 44 chars base64)
+      const publicKeyBuffer = Buffer.from(identity.publicKey, 'base64');
+      expect(publicKeyBuffer.length).toBe(32);
+    });
+
+    it('should generate keys in correct format', async () => {
+      const identity = await generateIdentity();
+
+      // Keys should be valid base64 strings
+      expect(/^[A-Za-z0-9+/=]+$/.test(identity.privateKey)).toBe(true);
+      expect(/^[A-Za-z0-9+/=]+$/.test(identity.publicKey)).toBe(true);
+    });
+
+    it('should generate different private and public keys', async () => {
+      const identity = await generateIdentity();
+
+      expect(identity.privateKey).not.toBe(identity.publicKey);
+    });
+
+    it('should generate keys that can be used for signing', async () => {
+      const identity = await generateIdentity();
+
+      // Keys should be valid base64 and decode to 32 bytes
+      const privateKey = Buffer.from(identity.privateKey, 'base64');
+      const publicKey = Buffer.from(identity.publicKey, 'base64');
+
+      expect(privateKey.length).toBe(32);
+      expect(publicKey.length).toBe(32);
+    });
+  });
+
+  describe('DID format validation', () => {
+    it('should generate valid DID:key format', async () => {
+      const identity = await generateIdentity();
+
+      expect(isValidDIDKey(identity.did)).toBe(true);
+      expect(identity.did).toMatch(/^did:key:z/);
+    });
+
+    it('should generate DID with correct prefix', async () => {
+      const identity = await generateIdentity();
+
+      expect(identity.did.startsWith('did:key:z')).toBe(true);
+    });
+
+    it('should generate KID that references DID', async () => {
+      const identity = await generateIdentity();
+
+      expect(identity.kid).toBe(`${identity.did}#key-1`);
+    });
+
+    it('should validate correctly formatted DID', () => {
+      expect(isValidDIDKey('did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK')).toBe(true);
+      // Minimum valid length - needs at least 47 characters after 'z' according to regex
+      // A shorter DID like 'did:key:z6Mk' is not valid
+      expect(isValidDIDKey('did:key:z6Mk')).toBe(false);
+    });
+
+    it('should reject invalid DID formats', () => {
+      expect(isValidDIDKey('did:key:')).toBe(false);
+      expect(isValidDIDKey('did:key:z')).toBe(false);
+      expect(isValidDIDKey('did:web:example.com')).toBe(false);
+      expect(isValidDIDKey('not-a-did')).toBe(false);
+      expect(isValidDIDKey('')).toBe(false);
+    });
+
+    it('should extract multibase from valid DID', () => {
+      const did = 'did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK';
+      const multibase = extractMultibaseFromDID(did);
+
+      expect(multibase).toBe('6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK');
+      expect(multibase).not.toContain('did:key:');
+      // Multibase should not contain 'z' prefix (it's removed)
+      expect(multibase).toBeTruthy();
+      expect(multibase?.charAt(0)).not.toBe('z');
+    });
+
+    it('should return null for invalid DID when extracting multibase', () => {
+      expect(extractMultibaseFromDID('invalid-did')).toBeNull();
+      expect(extractMultibaseFromDID('did:key:')).toBeNull();
+      expect(extractMultibaseFromDID('')).toBeNull();
+    });
+  });
+
+  describe('Identity persistence', () => {
+    it('should generate identity that can be serialized to JSON', async () => {
+      const identity = await generateIdentity();
+
+      const json = JSON.stringify(identity);
+      expect(json).toBeDefined();
+
+      const parsed = JSON.parse(json) as GeneratedIdentity;
+      expect(parsed.did).toBe(identity.did);
+      expect(parsed.kid).toBe(identity.kid);
+      expect(parsed.privateKey).toBe(identity.privateKey);
+      expect(parsed.publicKey).toBe(identity.publicKey);
+      expect(parsed.createdAt).toBe(identity.createdAt);
+      expect(parsed.type).toBe(identity.type);
+    });
+
+    it('should generate identity with consistent structure', async () => {
+      const identities = await Promise.all([
+        generateIdentity(),
+        generateIdentity(),
+        generateIdentity()
+      ]);
+
+      // All identities should have same structure
+      identities.forEach(identity => {
+        expect(identity).toHaveProperty('did');
+        expect(identity).toHaveProperty('kid');
+        expect(identity).toHaveProperty('privateKey');
+        expect(identity).toHaveProperty('publicKey');
+        expect(identity).toHaveProperty('createdAt');
+        expect(identity).toHaveProperty('type');
+      });
+    });
+
+    it('should generate identity that matches expected interface', async () => {
+      const identity = await generateIdentity();
+
+      // Verify all required fields exist
+      const requiredFields: (keyof GeneratedIdentity)[] = [
+        'did',
+        'kid',
+        'privateKey',
+        'publicKey',
+        'createdAt',
+        'type'
+      ];
+
+      requiredFields.forEach(field => {
+        expect(identity).toHaveProperty(field);
+        expect(identity[field]).toBeDefined();
+      });
+    });
+
+    it('should generate identity with correct type', async () => {
+      const identity = await generateIdentity();
+
+      expect(identity.type).toBe('development');
+      expect(['development', 'production']).toContain(identity.type);
+    });
+  });
+
+  describe('DID generation from public key', () => {
+    it('should generate DID that corresponds to public key', async () => {
+      const identity1 = await generateIdentity();
+      const identity2 = await generateIdentity();
+
+      // Different public keys should generate different DIDs
+      expect(identity1.publicKey).not.toBe(identity2.publicKey);
+      expect(identity1.did).not.toBe(identity2.did);
+    });
+
+    it('should generate DID with correct length', async () => {
+      const identity = await generateIdentity();
+
+      // DID:key format should be: did:key:z + base58-encoded key (typically 47+ chars)
+      expect(identity.did.length).toBeGreaterThan(50);
+      expect(identity.did.length).toBeLessThan(100);
+    });
+
+    it('should generate DID with base58 encoding', async () => {
+      const identity = await generateIdentity();
+      const multibase = extractMultibaseFromDID(identity.did);
+
+      if (multibase) {
+        // Base58 should only contain valid characters (no 0, O, I, l)
+        expect(/^[1-9A-HJ-NP-Za-km-z]+$/.test(multibase)).toBe(true);
+      }
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle concurrent identity generation', async () => {
+      const promises = Array.from({ length: 10 }, () => generateIdentity());
+      const identities = await Promise.all(promises);
+
+      // All should be unique
+      const dids = identities.map(i => i.did);
+      const uniqueDids = new Set(dids);
+      expect(uniqueDids.size).toBe(10);
+    });
+
+    it('should generate identity consistently', async () => {
+      // Generate multiple identities and verify they're all valid
+      const identities = await Promise.all([
+        generateIdentity(),
+        generateIdentity(),
+        generateIdentity()
+      ]);
+
+      identities.forEach(identity => {
+        expect(isValidDIDKey(identity.did)).toBe(true);
+        expect(identity.kid).toBe(`${identity.did}#key-1`);
+      });
+    });
+  });
+});
+

package/src/__tests__/helpers/install.test.ts

@@ -0,0 +1,362 @@
+/**
+ * Install Tests
+ *
+ * Tests for dependency installation, package manager detection,
+ * error handling, and install progress reporting.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+
+// Mock child_process module
+// Use a shared object to store the mock function
+const mockExecSyncStore = { fn: vi.fn() };
+vi.mock('child_process', () => ({
+  get execSync() {
+    return mockExecSyncStore.fn;
+  },
+}));
+
+// Import after mock setup
+import { install, detectPackageManager } from '../../helpers/install';
+
+// Export the mock for use in tests
+const mockExecSync = mockExecSyncStore.fn;
+
+describe('detectPackageManager', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = path.join(process.cwd(), 'test-temp', `detect-test-${Date.now()}-${Math.random().toString(36).substring(7)}`);
+    fs.ensureDirSync(tempDir);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.removeSync(tempDir);
+    }
+    if (fs.existsSync(path.join(process.cwd(), 'test-temp'))) {
+      const testTempContents = fs.readdirSync(path.join(process.cwd(), 'test-temp'));
+      if (testTempContents.length === 0) {
+        fs.removeSync(path.join(process.cwd(), 'test-temp'));
+      }
+    }
+  });
+
+  describe('Package manager detection', () => {
+    it('should detect npm from package-lock.json', () => {
+      fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+
+      const result = detectPackageManager(tempDir);
+
+      expect(result).toBe('npm');
+    });
+
+    it('should detect yarn from yarn.lock', () => {
+      fs.writeFileSync(path.join(tempDir, 'yarn.lock'), '# yarn lock');
+
+      const result = detectPackageManager(tempDir);
+
+      expect(result).toBe('yarn');
+    });
+
+    it('should detect pnpm from pnpm-lock.yaml', () => {
+      fs.writeFileSync(path.join(tempDir, 'pnpm-lock.yaml'), '# pnpm lock');
+
+      const result = detectPackageManager(tempDir);
+
+      expect(result).toBe('pnpm');
+    });
+
+    it('should return null when no lockfile exists', () => {
+      const result = detectPackageManager(tempDir);
+
+      expect(result).toBeNull();
+    });
+
+    it('should prioritize pnpm over npm', () => {
+      fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+      fs.writeFileSync(path.join(tempDir, 'pnpm-lock.yaml'), '# pnpm lock');
+
+      const result = detectPackageManager(tempDir);
+
+      // pnpm should be detected first (check order in implementation)
+      expect(['pnpm', 'npm']).toContain(result);
+    });
+
+    it('should prioritize yarn over npm', () => {
+      fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+      fs.writeFileSync(path.join(tempDir, 'yarn.lock'), '# yarn lock');
+
+      const result = detectPackageManager(tempDir);
+
+      // yarn should be detected first (check order in implementation)
+      expect(['yarn', 'npm']).toContain(result);
+    });
+  });
+});
+
+describe('install', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = path.join(process.cwd(), 'test-temp', `install-test-${Date.now()}-${Math.random().toString(36).substring(7)}`);
+    fs.ensureDirSync(tempDir);
+    
+    // Create minimal package.json for installation
+    fs.writeJsonSync(path.join(tempDir, 'package.json'), {
+      name: 'test-project',
+      version: '1.0.0',
+      dependencies: {}
+    });
+
+    // Reset mock before each test
+    mockExecSync.mockReset();
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.removeSync(tempDir);
+    }
+    if (fs.existsSync(path.join(process.cwd(), 'test-temp'))) {
+      const testTempContents = fs.readdirSync(path.join(process.cwd(), 'test-temp'));
+      if (testTempContents.length === 0) {
+        fs.removeSync(path.join(process.cwd(), 'test-temp'));
+      }
+    }
+    vi.clearAllMocks();
+  });
+
+  describe('Dependency installation', () => {
+    it('should install dependencies with npm', () => {
+      mockExecSync.mockImplementation(() => {
+        fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+        return Buffer.from('');
+      });
+
+      install(tempDir, 'npm', '1.0.0');
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'npm install',
+        expect.objectContaining({
+          cwd: tempDir,
+          stdio: 'inherit'
+        })
+      );
+    });
+
+    it('should install dependencies with yarn', () => {
+      mockExecSync.mockImplementation(() => {
+        fs.writeFileSync(path.join(tempDir, 'yarn.lock'), '# yarn lock');
+        return Buffer.from('');
+      });
+
+      install(tempDir, 'yarn', '1.0.0');
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'yarn install',
+        expect.objectContaining({
+          cwd: tempDir,
+          stdio: 'inherit'
+        })
+      );
+    });
+
+    it('should install dependencies with pnpm', () => {
+      mockExecSync.mockImplementation(() => {
+        fs.writeFileSync(path.join(tempDir, 'pnpm-lock.yaml'), '# pnpm lock');
+        return Buffer.from('');
+      });
+
+      install(tempDir, 'pnpm', '1.0.0');
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'pnpm install',
+        expect.objectContaining({
+          cwd: tempDir,
+          stdio: 'inherit'
+        })
+      );
+    });
+
+    it('should use correct working directory', () => {
+      mockExecSync.mockImplementation(() => {
+        fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+        return Buffer.from('');
+      });
+
+      install(tempDir, 'npm', '1.0.0');
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          cwd: tempDir
+        })
+      );
+    });
+  });
+
+  describe('Install progress reporting', () => {
+    it('should log installation start message', () => {
+      mockExecSync.mockImplementation(() => {
+        fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+        return Buffer.from('');
+      });
+
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      install(tempDir, 'npm', '1.0.0');
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Installing dependencies')
+      );
+
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should report correct package manager in log', () => {
+      mockExecSync.mockImplementation(() => {
+        fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+        return Buffer.from('');
+      });
+
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      install(tempDir, 'pnpm', '1.0.0');
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('pnpm')
+      );
+
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should check for lockfile after installation', () => {
+      mockExecSync.mockImplementation(() => {
+        fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+        return Buffer.from('');
+      });
+
+      install(tempDir, 'npm', '1.0.0');
+
+      // Should check for lockfile (via checkLockfile function)
+      expect(fs.existsSync(path.join(tempDir, 'package-lock.json'))).toBe(true);
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should throw error when installation fails', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Installation failed');
+      });
+
+      expect(() => {
+        install(tempDir, 'npm', '1.0.0');
+      }).toThrow('Installation failed');
+    });
+
+    it('should handle network errors during installation', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('ENOTFOUND registry.npmjs.org');
+      });
+
+      expect(() => {
+        install(tempDir, 'npm', '1.0.0');
+      }).toThrow();
+    });
+
+    it('should handle permission errors during installation', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('EACCES: permission denied');
+      });
+
+      expect(() => {
+        install(tempDir, 'npm', '1.0.0');
+      }).toThrow();
+    });
+
+    it('should log error message when installation fails', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Installation failed');
+      });
+
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      try {
+        install(tempDir, 'npm', '1.0.0');
+      } catch {
+        // Expected to throw
+      }
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to install dependencies')
+      );
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should handle invalid package manager gracefully', () => {
+      mockExecSync.mockImplementation(() => {
+        fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+        return Buffer.from('');
+      });
+
+      // Should default to npm for unknown package manager
+      install(tempDir, 'unknown' as any, '1.0.0');
+
+      expect(mockExecSync).toHaveBeenCalledWith(
+        'npm install',
+        expect.any(Object)
+      );
+    });
+  });
+
+  describe('Lockfile validation', () => {
+    it('should validate npm lockfile after installation', () => {
+      mockExecSync.mockImplementation(() => {
+        fs.writeFileSync(path.join(tempDir, 'package-lock.json'), '{}');
+        return Buffer.from('');
+      });
+
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      install(tempDir, 'npm', '1.0.0');
+
+      // Should log lockfile creation message
+      // chalk.gray() wraps the message, so check that log was called
+      expect(consoleLogSpy).toHaveBeenCalled();
+      const logCalls = consoleLogSpy.mock.calls;
+      const hasLockfileMessage = logCalls.some(call => 
+        call[0] && typeof call[0] === 'string' && 
+        (call[0].includes('Lockfile created') || call[0].includes('package-lock.json'))
+      );
+      expect(hasLockfileMessage).toBe(true);
+
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should warn when lockfile not created', () => {
+      mockExecSync.mockImplementation(() => {
+        // Mock successful install but don't create lockfile
+        // The checkLockfile function will check if file exists after install
+        return Buffer.from('');
+      });
+
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      install(tempDir, 'npm', '1.0.0');
+
+      // checkLockfile is called after install succeeds, and should warn if lockfile doesn't exist
+      // chalk.yellow() wraps the message, so we check that warn was called with a string containing the message
+      expect(consoleWarnSpy).toHaveBeenCalled();
+      const warnCalls = consoleWarnSpy.mock.calls;
+      const hasWarningMessage = warnCalls.some(call => 
+        call[0] && typeof call[0] === 'string' && call[0].includes('Warning: No lockfile generated')
+      );
+      expect(hasWarningMessage).toBe(true);
+
+      consoleWarnSpy.mockRestore();
+    });
+  });
+});