@celilo/cli 0.1.0

package/src/services/machine-pool.test.ts

@@ -0,0 +1,405 @@
+/**
+ * Unit tests for machine pool operations
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { eq } from 'drizzle-orm';
+import { closeDb, createDbClient } from '../db/client';
+import { runMigrations } from '../db/migrate';
+import { machines } from '../db/schema';
+import {
+  addMachine,
+  assignModuleToMachine,
+  getMachine,
+  getMachineByHostname,
+  getMachineSshKey,
+  listMachines,
+  removeMachine,
+  unassignModuleFromMachine,
+} from './machine-pool';
+
+describe('machine-pool', () => {
+  let testDbPath: string;
+  let testDir: string;
+
+  beforeEach(async () => {
+    // Create temp directory for test database
+    testDir = mkdtempSync(join(tmpdir(), 'celilo-test-'));
+    testDbPath = join(testDir, 'test.db');
+
+    // Set environment variable for database path
+    process.env.CELILO_DB_PATH = testDbPath;
+
+    // Initialize database and run migrations
+    await runMigrations(testDbPath);
+
+    // Create a dummy master key for encryption
+    const masterKeyPath = join(testDir, 'master.key');
+    process.env.CELILO_MASTER_KEY_PATH = masterKeyPath;
+    const fs = await import('node:fs/promises');
+    await fs.writeFile(masterKeyPath, 'a'.repeat(64), 'utf8');
+  });
+
+  afterEach(() => {
+    // Close database connection
+    closeDb();
+
+    // Clean up test directory
+    if (testDir) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+
+    // Clear environment variables
+    process.env.CELILO_DB_PATH = undefined;
+    process.env.CELILO_MASTER_KEY_PATH = undefined;
+  });
+
+  describe('addMachine', () => {
+    it('creates a machine with hardware specs', async () => {
+      const machine = await addMachine({
+        hostname: 'rpi4-lr',
+        zone: 'internal',
+        ipAddress: '192.168.1.100',
+        sshUser: 'ubuntu',
+        sshKey: 'ssh-ed25519 AAAA...',
+        hardware: {
+          cpu_cores: 4,
+          memory_mb: 4096,
+          disk_gb: 128,
+        },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      expect(machine.id).toBeDefined();
+      expect(machine.hostname).toBe('rpi4-lr');
+      expect(machine.zone).toBe('internal');
+      expect(machine.ipAddress).toBe('192.168.1.100');
+      expect(machine.hardware.cpu_cores).toBe(4);
+      expect(machine.assignedModuleIds).toEqual([]);
+      expect(machine.createdAt).toBeInstanceOf(Date);
+    });
+
+    it('encrypts SSH key', async () => {
+      const machine = await addMachine({
+        hostname: 'test-machine',
+        zone: 'dmz',
+        ipAddress: '10.0.10.100',
+        sshUser: 'root',
+        sshKey: 'ssh-ed25519 AAAA_SECRET_KEY_12345',
+        hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      // Verify key is encrypted in database
+      const db = createDbClient({ path: testDbPath });
+      const dbRecord = await db.select().from(machines).where(eq(machines.id, machine.id)).get();
+
+      expect(dbRecord?.sshKeyEncrypted).toBeDefined();
+      expect(dbRecord?.sshKeyEncrypted).not.toContain('AAAA_SECRET_KEY_12345');
+    });
+
+    it('supports different zones', async () => {
+      const dmzMachine = await addMachine({
+        hostname: 'dmz-server',
+        zone: 'dmz',
+        ipAddress: '10.0.10.100',
+        sshUser: 'root',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      const externalMachine = await addMachine({
+        hostname: 'vps-external',
+        zone: 'external',
+        ipAddress: '167.99.123.45',
+        sshUser: 'root',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 1, memory_mb: 1024, disk_gb: 25 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      expect(dmzMachine.zone).toBe('dmz');
+      expect(externalMachine.zone).toBe('external');
+    });
+  });
+
+  describe('getMachine', () => {
+    it('retrieves machine by ID', async () => {
+      const created = await addMachine({
+        hostname: 'test-machine',
+        zone: 'dmz',
+        ipAddress: '10.0.10.100',
+        sshUser: 'root',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      const retrieved = await getMachine(created.id);
+
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.id).toBe(created.id);
+      expect(retrieved?.hostname).toBe('test-machine');
+    });
+
+    it('returns null for non-existent machine', async () => {
+      const result = await getMachine('non-existent-id');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getMachineByHostname', () => {
+    it('retrieves machine by hostname', async () => {
+      await addMachine({
+        hostname: 'unique-hostname',
+        zone: 'internal',
+        ipAddress: '192.168.1.100',
+        sshUser: 'ubuntu',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      const retrieved = await getMachineByHostname('unique-hostname');
+
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.hostname).toBe('unique-hostname');
+    });
+
+    it('returns null for non-existent hostname', async () => {
+      const result = await getMachineByHostname('does-not-exist');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('listMachines', () => {
+    it('returns empty array when no machines', async () => {
+      const result = await listMachines();
+      expect(result).toEqual([]);
+    });
+
+    it('lists all machines without filters', async () => {
+      await addMachine({
+        hostname: 'machine-1',
+        zone: 'dmz',
+        ipAddress: '10.0.10.100',
+        sshUser: 'root',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      await addMachine({
+        hostname: 'machine-2',
+        zone: 'internal',
+        ipAddress: '192.168.1.100',
+        sshUser: 'ubuntu',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      const result = await listMachines();
+      expect(result).toHaveLength(2);
+    });
+
+    it('filters machines by zone', async () => {
+      await addMachine({
+        hostname: 'dmz-machine',
+        zone: 'dmz',
+        ipAddress: '10.0.10.100',
+        sshUser: 'root',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      await addMachine({
+        hostname: 'external-machine',
+        zone: 'external',
+        ipAddress: '167.99.123.45',
+        sshUser: 'root',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 1, memory_mb: 1024, disk_gb: 25 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      const dmzMachines = await listMachines({ zone: 'dmz' });
+      expect(dmzMachines).toHaveLength(1);
+      expect(dmzMachines[0].hostname).toBe('dmz-machine');
+
+      const externalMachines = await listMachines({ zone: 'external' });
+      expect(externalMachines).toHaveLength(1);
+      expect(externalMachines[0].hostname).toBe('external-machine');
+    });
+  });
+
+  describe('getMachineSshKey', () => {
+    it('decrypts and returns SSH key', async () => {
+      const machine = await addMachine({
+        hostname: 'test-machine',
+        zone: 'dmz',
+        ipAddress: '10.0.10.100',
+        sshUser: 'root',
+        sshKey: 'ssh-ed25519 AAAA_SECRET_KEY_12345',
+        hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      const decryptedKey = await getMachineSshKey(machine.id);
+      expect(decryptedKey).toBe('ssh-ed25519 AAAA_SECRET_KEY_12345');
+    });
+
+    it('throws error for non-existent machine', async () => {
+      await expect(getMachineSshKey('non-existent-id')).rejects.toThrow(/Machine not found/);
+    });
+  });
+
+  describe('assignModuleToMachine', () => {
+    it('assigns module to machine', async () => {
+      const machine = await addMachine({
+        hostname: 'test-machine',
+        zone: 'internal',
+        ipAddress: '192.168.1.100',
+        sshUser: 'ubuntu',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      await assignModuleToMachine(machine.id, 'homebridge');
+
+      const updated = await getMachine(machine.id);
+      expect(updated?.assignedModuleIds).toEqual(['homebridge']);
+    });
+
+    it('supports multiple modules on same machine', async () => {
+      const machine = await addMachine({
+        hostname: 'multi-module-machine',
+        zone: 'internal',
+        ipAddress: '192.168.1.100',
+        sshUser: 'ubuntu',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 8, memory_mb: 16384, disk_gb: 256 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      await assignModuleToMachine(machine.id, 'module-1');
+      await assignModuleToMachine(machine.id, 'module-2');
+      await assignModuleToMachine(machine.id, 'module-3');
+
+      const updated = await getMachine(machine.id);
+      expect(updated?.assignedModuleIds).toEqual(['module-1', 'module-2', 'module-3']);
+    });
+
+    it('throws error for non-existent machine', async () => {
+      await expect(assignModuleToMachine('non-existent-id', 'module-id')).rejects.toThrow(
+        /Machine not found/,
+      );
+    });
+  });
+
+  describe('unassignModuleFromMachine', () => {
+    it('removes module from machine', async () => {
+      const machine = await addMachine({
+        hostname: 'test-machine',
+        zone: 'internal',
+        ipAddress: '192.168.1.100',
+        sshUser: 'ubuntu',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 4, memory_mb: 4096, disk_gb: 128 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: ['homebridge'],
+      });
+
+      await unassignModuleFromMachine(machine.id, 'homebridge');
+
+      const updated = await getMachine(machine.id);
+      expect(updated?.assignedModuleIds).toEqual([]);
+    });
+
+    it('removes specific module from multiple assignments', async () => {
+      const machine = await addMachine({
+        hostname: 'test-machine',
+        zone: 'internal',
+        ipAddress: '192.168.1.100',
+        sshUser: 'ubuntu',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 8, memory_mb: 16384, disk_gb: 256 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: ['module-1', 'module-2', 'module-3'],
+      });
+
+      await unassignModuleFromMachine(machine.id, 'module-2');
+
+      const updated = await getMachine(machine.id);
+      expect(updated?.assignedModuleIds).toEqual(['module-1', 'module-3']);
+    });
+
+    it('throws error for non-existent machine', async () => {
+      await expect(unassignModuleFromMachine('non-existent-id', 'module-id')).rejects.toThrow(
+        /Machine not found/,
+      );
+    });
+  });
+
+  describe('removeMachine', () => {
+    it('deletes machine from database', async () => {
+      const machine = await addMachine({
+        hostname: 'machine-to-delete',
+        zone: 'dmz',
+        ipAddress: '10.0.10.100',
+        sshUser: 'root',
+        sshKey: 'test-key',
+        hardware: { cpu_cores: 2, memory_mb: 2048, disk_gb: 64 },
+        role: 'host',
+        interfaces: [],
+        assignedModuleIds: [],
+      });
+
+      await removeMachine(machine.id);
+
+      const retrieved = await getMachine(machine.id);
+      expect(retrieved).toBeNull();
+    });
+
+    it('does not throw when removing non-existent machine', async () => {
+      // Should complete without error
+      await removeMachine('non-existent-id');
+      // If we get here, no error was thrown
+      expect(true).toBe(true);
+    });
+  });
+});