@celilo/cli 0.1.0

package/src/ipam/allocator.test.ts

@@ -0,0 +1,442 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { type DbClient, createDbClient } from '../db/client';
+import {
+  ipAllocations,
+  ipReservations,
+  modules,
+  systemConfig,
+  vmidReservations,
+} from '../db/schema';
+import type { NewModule } from '../db/schema';
+import {
+  allocateIPFromSubnet,
+  allocateResources,
+  allocateVMID,
+  deallocateResources,
+  getAllocatedIPsInSubnet,
+  getAllocation,
+  isIPAvailable,
+  isVMIDAvailable,
+  listReservations,
+  listVMIDReservations,
+  reserveIP,
+  reserveVMID,
+  unreserveIP,
+  unreserveVMID,
+} from './allocator';
+
+describe('IPAM Allocator', () => {
+  let db: DbClient;
+  let testDbPath: string;
+
+  beforeEach(async () => {
+    testDbPath = `./test-ipam-${Date.now()}-${Math.random()}.db`;
+    db = createDbClient({ path: testDbPath });
+
+    // Tables are automatically created by auto-migration in createDbClient()
+
+    // Insert test module
+    const testModule: NewModule = {
+      id: 'test-module',
+      name: 'Test Module',
+      version: '1.0.0',
+      sourcePath: '/test',
+      manifestData: {},
+    };
+    db.insert(modules).values(testModule).run();
+
+    // Insert network config for DMZ zone
+    db.insert(systemConfig)
+      .values({
+        key: 'network.dmz.subnet',
+        value: '10.0.10.0/24',
+      })
+      .run();
+  });
+
+  afterEach(async () => {
+    db.$client.close();
+    if (existsSync(testDbPath)) {
+      await unlink(testDbPath);
+    }
+    const walPath = `${testDbPath}-wal`;
+    const shmPath = `${testDbPath}-shm`;
+    if (existsSync(walPath)) {
+      await unlink(walPath);
+    }
+    if (existsSync(shmPath)) {
+      await unlink(shmPath);
+    }
+  });
+
+  describe('allocateVMID', () => {
+    test('should allocate first VMID as 2100', async () => {
+      const vmid = await allocateVMID(db);
+      expect(vmid).toBe(2100);
+    });
+
+    test('should increment VMID sequentially', async () => {
+      // Manually insert allocation
+      db.insert(ipAllocations)
+        .values({
+          moduleId: 'test-module',
+          vmid: 2100,
+          containerIp: '10.0.10.10/24',
+          zone: 'dmz',
+        })
+        .run();
+
+      const vmid = await allocateVMID(db);
+      expect(vmid).toBe(2101);
+    });
+
+    test('should find max VMID from multiple allocations', async () => {
+      db.insert(ipAllocations)
+        .values([
+          { moduleId: 'test-module', vmid: 2100, containerIp: '10.0.10.10/24', zone: 'dmz' },
+          { moduleId: 'test-module', vmid: 2105, containerIp: '10.0.10.11/24', zone: 'dmz' },
+          { moduleId: 'test-module', vmid: 2102, containerIp: '10.0.10.12/24', zone: 'dmz' },
+        ])
+        .run();
+
+      const vmid = await allocateVMID(db);
+      expect(vmid).toBe(2106);
+    });
+  });
+
+  describe('allocateIPFromSubnet', () => {
+    test('should allocate first IP as .10', async () => {
+      const ip = await allocateIPFromSubnet('10.0.10.0/24', 'dmz', db);
+      expect(ip).toBe('10.0.10.10/24');
+    });
+
+    test('should skip already allocated IPs', async () => {
+      // Allocate .10
+      db.insert(ipAllocations)
+        .values({
+          moduleId: 'test-module',
+          vmid: 2100,
+          containerIp: '10.0.10.10/24',
+          zone: 'dmz',
+        })
+        .run();
+
+      // Next allocation should be .11
+      const ip = await allocateIPFromSubnet('10.0.10.0/24', 'dmz', db);
+      expect(ip).toBe('10.0.10.11/24');
+    });
+
+    test('should skip reserved IPs', async () => {
+      // Reserve .10 and .11
+      db.insert(ipReservations)
+        .values({
+          ipStart: '10.0.10.10',
+          ipEnd: '10.0.10.11',
+          zone: 'dmz',
+          reason: 'Test reservation',
+        })
+        .run();
+
+      // Should allocate .12
+      const ip = await allocateIPFromSubnet('10.0.10.0/24', 'dmz', db);
+      expect(ip).toBe('10.0.10.12/24');
+    });
+
+    test('should skip single IP reservation', async () => {
+      // Reserve .10 only
+      db.insert(ipReservations)
+        .values({
+          ipStart: '10.0.10.10',
+          ipEnd: null,
+          zone: 'dmz',
+          reason: 'Single IP reservation',
+        })
+        .run();
+
+      // Should allocate .11
+      const ip = await allocateIPFromSubnet('10.0.10.0/24', 'dmz', db);
+      expect(ip).toBe('10.0.10.11/24');
+    });
+
+    test('should throw error when subnet exhausted', async () => {
+      // Fill up subnet (.10 to .254 = 245 IPs)
+      const allocations = [];
+      for (let i = 10; i <= 254; i++) {
+        allocations.push({
+          moduleId: 'test-module',
+          vmid: 2000 + i,
+          containerIp: `10.0.10.${i}/24`,
+          zone: 'dmz' as const,
+        });
+      }
+      db.insert(ipAllocations).values(allocations).run();
+
+      await expect(allocateIPFromSubnet('10.0.10.0/24', 'dmz', db)).rejects.toThrow(
+        'No available IPs in subnet',
+      );
+    });
+  });
+
+  describe('allocateResources', () => {
+    test('should allocate both VMID and IP', async () => {
+      const result = await allocateResources('test-module', 'dmz', db);
+
+      expect(result.vmid).toBe(2100);
+      expect(result.containerIp).toBe('10.0.10.10/24');
+
+      // Verify stored in database
+      const allocations = await db.select().from(ipAllocations).all();
+      expect(allocations).toHaveLength(1);
+      expect(allocations[0].moduleId).toBe('test-module');
+      expect(allocations[0].vmid).toBe(2100);
+      expect(allocations[0].containerIp).toBe('10.0.10.10/24');
+    });
+
+    test('should throw error if zone not configured', async () => {
+      await expect(allocateResources('test-module', 'app', db)).rejects.toThrow(
+        "Network zone 'app' not configured",
+      );
+    });
+
+    test('should allocate different resources for multiple modules', async () => {
+      // Insert additional test modules
+      db.insert(modules)
+        .values([
+          {
+            id: 'module1',
+            name: 'Module 1',
+            version: '1.0.0',
+            sourcePath: '/test1',
+            manifestData: {},
+          },
+          {
+            id: 'module2',
+            name: 'Module 2',
+            version: '1.0.0',
+            sourcePath: '/test2',
+            manifestData: {},
+          },
+        ])
+        .run();
+
+      const result1 = await allocateResources('module1', 'dmz', db);
+      const result2 = await allocateResources('module2', 'dmz', db);
+
+      expect(result1.vmid).toBe(2100);
+      expect(result1.containerIp).toBe('10.0.10.10/24');
+
+      expect(result2.vmid).toBe(2101);
+      expect(result2.containerIp).toBe('10.0.10.11/24');
+    });
+  });
+
+  describe('deallocateResources', () => {
+    test('should remove allocation', async () => {
+      await allocateResources('test-module', 'dmz', db);
+
+      await deallocateResources('test-module', db);
+
+      const allocations = await db.select().from(ipAllocations).all();
+      expect(allocations).toHaveLength(0);
+    });
+  });
+
+  describe('getAllocation', () => {
+    test('should return allocation for module', async () => {
+      await allocateResources('test-module', 'dmz', db);
+
+      const allocation = await getAllocation('test-module', db);
+
+      expect(allocation).toBeDefined();
+      expect(allocation?.vmid).toBe(2100);
+      expect(allocation?.containerIp).toBe('10.0.10.10/24');
+    });
+
+    test('should return null if no allocation', async () => {
+      const allocation = await getAllocation('nonexistent', db);
+      expect(allocation).toBeNull();
+    });
+  });
+
+  describe('IP Reservations', () => {
+    test('should reserve single IP', async () => {
+      await reserveIP('10.0.10.50', 'dmz', 'Load balancer', null, db);
+
+      const reservations = await db.select().from(ipReservations).all();
+      expect(reservations).toHaveLength(1);
+      expect(reservations[0].ipStart).toBe('10.0.10.50');
+      expect(reservations[0].ipEnd).toBeNull();
+      expect(reservations[0].reason).toBe('Load balancer');
+    });
+
+    test('should reserve IP range', async () => {
+      await reserveIP('10.0.10.100', 'dmz', 'Manual VMs', '10.0.10.110', db);
+
+      const reservations = await db.select().from(ipReservations).all();
+      expect(reservations).toHaveLength(1);
+      expect(reservations[0].ipStart).toBe('10.0.10.100');
+      expect(reservations[0].ipEnd).toBe('10.0.10.110');
+    });
+
+    test('should unreserve IP', async () => {
+      await reserveIP('10.0.10.50', 'dmz', 'Test', null, db);
+      await unreserveIP('10.0.10.50', 'dmz', db);
+
+      const reservations = await db.select().from(ipReservations).all();
+      expect(reservations).toHaveLength(0);
+    });
+
+    test('should list all reservations', async () => {
+      await reserveIP('10.0.10.50', 'dmz', 'LB', null, db);
+      await reserveIP('10.0.10.100', 'dmz', 'VMs', '10.0.10.110', db);
+
+      const reservations = await listReservations(db);
+      expect(reservations).toHaveLength(2);
+    });
+  });
+
+  describe('getAllocatedIPsInSubnet', () => {
+    test('should return allocated IPs in subnet', async () => {
+      // Insert additional test modules
+      db.insert(modules)
+        .values([
+          {
+            id: 'module1',
+            name: 'Module 1',
+            version: '1.0.0',
+            sourcePath: '/test1',
+            manifestData: {},
+          },
+          {
+            id: 'module2',
+            name: 'Module 2',
+            version: '1.0.0',
+            sourcePath: '/test2',
+            manifestData: {},
+          },
+        ])
+        .run();
+
+      await allocateResources('module1', 'dmz', db);
+      await allocateResources('module2', 'dmz', db);
+
+      const ips = await getAllocatedIPsInSubnet('10.0.10.0/24', db);
+
+      expect(ips).toHaveLength(2);
+      expect(ips).toContain('10.0.10.10/24');
+      expect(ips).toContain('10.0.10.11/24');
+    });
+
+    test('should return empty array if no allocations', async () => {
+      const ips = await getAllocatedIPsInSubnet('10.0.10.0/24', db);
+      expect(ips).toHaveLength(0);
+    });
+  });
+
+  describe('isIPAvailable', () => {
+    test('should return true for available IP', async () => {
+      const available = await isIPAvailable('10.0.10.50/24', 'dmz', db);
+      expect(available).toBe(true);
+    });
+
+    test('should return false for allocated IP', async () => {
+      await allocateResources('test-module', 'dmz', db);
+
+      const available = await isIPAvailable('10.0.10.10/24', 'dmz', db);
+      expect(available).toBe(false);
+    });
+
+    test('should return false for reserved IP', async () => {
+      await reserveIP('10.0.10.50', 'dmz', 'Test', null, db);
+
+      const available = await isIPAvailable('10.0.10.50/24', 'dmz', db);
+      expect(available).toBe(false);
+    });
+  });
+
+  describe('VMID Reservations', () => {
+    test('should reserve VMID', async () => {
+      await reserveVMID(2100, 'Test reservation', db);
+
+      const reservations = await db.select().from(vmidReservations).all();
+      expect(reservations).toHaveLength(1);
+      expect(reservations[0].vmid).toBe(2100);
+      expect(reservations[0].reason).toBe('Test reservation');
+    });
+
+    test('should throw error if VMID already allocated', async () => {
+      await allocateResources('test-module', 'dmz', db);
+
+      await expect(reserveVMID(2100, 'Test', db)).rejects.toThrow(
+        'VMID 2100 is already allocated to module test-module',
+      );
+    });
+
+    test('should throw error if VMID already reserved', async () => {
+      await reserveVMID(2100, 'First reservation', db);
+
+      await expect(reserveVMID(2100, 'Second reservation', db)).rejects.toThrow(
+        'VMID 2100 is already reserved: First reservation',
+      );
+    });
+
+    test('should unreserve VMID', async () => {
+      await reserveVMID(2100, 'Test', db);
+      await unreserveVMID(2100, db);
+
+      const reservations = await db.select().from(vmidReservations).all();
+      expect(reservations).toHaveLength(0);
+    });
+
+    test('should list VMID reservations', async () => {
+      await reserveVMID(2100, 'First', db);
+      await reserveVMID(2101, 'Second', db);
+
+      const reservations = await listVMIDReservations(db);
+      expect(reservations).toHaveLength(2);
+      expect(reservations[0].vmid).toBe(2100);
+      expect(reservations[1].vmid).toBe(2101);
+    });
+
+    test('should skip reserved VMIDs during allocation', async () => {
+      await reserveVMID(2100, 'Reserved for external VM', db);
+
+      const vmid = await allocateVMID(db);
+
+      expect(vmid).toBe(2101);
+    });
+
+    test('should skip multiple reserved VMIDs', async () => {
+      await reserveVMID(2100, 'First', db);
+      await reserveVMID(2101, 'Second', db);
+      await reserveVMID(2102, 'Third', db);
+
+      const vmid = await allocateVMID(db);
+
+      expect(vmid).toBe(2103);
+    });
+  });
+
+  describe('isVMIDAvailable', () => {
+    test('should return true for available VMID', async () => {
+      const available = await isVMIDAvailable(2100, db);
+      expect(available).toBe(true);
+    });
+
+    test('should return false for allocated VMID', async () => {
+      await allocateResources('test-module', 'dmz', db);
+
+      const available = await isVMIDAvailable(2100, db);
+      expect(available).toBe(false);
+    });
+
+    test('should return false for reserved VMID', async () => {
+      await reserveVMID(2100, 'Test', db);
+
+      const available = await isVMIDAvailable(2100, db);
+      expect(available).toBe(false);
+    });
+  });
+});