@celilo/cli 0.1.0

package/src/test-utils/modules.ts

@@ -0,0 +1,183 @@
+/**
+ * Module Test Utilities
+ *
+ * Provides functions for importing and cleaning up test modules.
+ * Simplifies integration test setup/teardown.
+ */
+
+import { eq } from 'drizzle-orm';
+import type { DbClient } from '../db/client';
+import { modules } from '../db/schema';
+import { importModule } from '../module/import';
+import { setModuleConfigValue } from '../services/module-config';
+
+/**
+ * Options for importing test modules
+ */
+export interface ImportTestModuleOptions {
+  /**
+   * Module configuration (key-value pairs)
+   */
+  config?: Record<string, string | number | boolean>;
+
+  /**
+   * Module secrets (will be encrypted)
+   */
+  secrets?: Record<string, string>;
+
+  /**
+   * Skip validation (useful for testing error cases)
+   */
+  skipValidation?: boolean;
+}
+
+/**
+ * Import test module from fixtures
+ *
+ * Imports module, applies configuration, and validates.
+ * Use for integration tests that need real modules.
+ *
+ * @param modulePath - Path to module directory
+ * @param db - Test database
+ * @param options - Import options
+ * @returns Module ID
+ *
+ * @example
+ * ```typescript
+ * const moduleId = await importTestModule(
+ *   './test-fixtures/modules/artifact-test',
+ *   db,
+ *   {
+ *     config: { vmid: '100', hostname: 'test' },
+ *     secrets: { api_key: 'test-key' }
+ *   }
+ * );
+ * await cleanupTestModule(moduleId, db);
+ * ```
+ */
+export async function importTestModule(
+  modulePath: string,
+  db: DbClient,
+  options: ImportTestModuleOptions = {},
+): Promise<string> {
+  // Import module
+  const result = await importModule({ sourcePath: modulePath, db });
+
+  // Check if import was successful
+  if (!result.success) {
+    throw new Error(`Failed to import module: ${result.error}`);
+  }
+
+  // Apply configuration if provided
+  if (options.config) {
+    for (const [key, value] of Object.entries(options.config)) {
+      await setModuleConfigValue(result.moduleId, key, String(value), db);
+    }
+  }
+
+  // TODO: Apply secrets when secret management is implemented
+  if (options.secrets) {
+    // For now, secrets are not yet implemented
+    // This will be added in the future
+  }
+
+  return result.moduleId;
+}
+
+/**
+ * Clean up test module
+ *
+ * Deletes module and all related data (configs, capabilities, secrets).
+ * Use in test cleanup to prevent state leakage.
+ *
+ * @param moduleId - Module ID to delete
+ * @param db - Test database
+ *
+ * @example
+ * ```typescript
+ * const moduleId = await importTestModule('./test-fixtures/modules/artifact-test', db);
+ * // ... tests ...
+ * await cleanupTestModule(moduleId, db);
+ * ```
+ */
+export async function cleanupTestModule(moduleId: string, db: DbClient): Promise<void> {
+  await db.delete(modules).where(eq(modules.id, moduleId));
+}
+
+/**
+ * Import multiple test modules
+ *
+ * Imports multiple modules in sequence.
+ * Useful for tests that need multiple modules.
+ *
+ * @param moduleSpecs - Array of module specs
+ * @param db - Test database
+ * @returns Array of module IDs
+ *
+ * @example
+ * ```typescript
+ * const [module1, module2] = await importMultipleTestModules([
+ *   { path: './test-fixtures/modules/artifact-test' },
+ *   { path: './test-fixtures/modules/caddy', config: { hostname: 'www' } }
+ * ], db);
+ * await cleanupMultipleTestModules([module1, module2], db);
+ * ```
+ */
+export async function importMultipleTestModules(
+  moduleSpecs: Array<{
+    path: string;
+    options?: ImportTestModuleOptions;
+  }>,
+  db: DbClient,
+): Promise<string[]> {
+  const moduleIds: string[] = [];
+  for (const spec of moduleSpecs) {
+    const moduleId = await importTestModule(spec.path, db, spec.options);
+    moduleIds.push(moduleId);
+  }
+  return moduleIds;
+}
+
+/**
+ * Clean up multiple test modules
+ *
+ * @param moduleIds - Array of module IDs to delete
+ * @param db - Test database
+ *
+ * @example
+ * ```typescript
+ * const moduleIds = await importMultipleTestModules([...], db);
+ * // ... tests ...
+ * await cleanupMultipleTestModules(moduleIds, db);
+ * ```
+ */
+export async function cleanupMultipleTestModules(moduleIds: string[], db: DbClient): Promise<void> {
+  for (const moduleId of moduleIds) {
+    await cleanupTestModule(moduleId, db);
+  }
+}
+
+/**
+ * Get module state
+ *
+ * Retrieves current module state from database.
+ * Useful for asserting state transitions in tests.
+ *
+ * @param moduleId - Module ID
+ * @param db - Test database
+ * @returns Module state or null if not found
+ *
+ * @example
+ * ```typescript
+ * const state = await getModuleState('artifact-test', db);
+ * expect(state).toBe('IMPORTED');
+ * ```
+ */
+export async function getModuleState(moduleId: string, db: DbClient): Promise<string | null> {
+  const result = await db
+    .select({ state: modules.state })
+    .from(modules)
+    .where(eq(modules.id, moduleId));
+
+  return result.length > 0 ? result[0].state : null;
+}

package/src/test-utils/setup-test-db.ts

@@ -0,0 +1,90 @@
+import { existsSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { migrate } from 'drizzle-orm/bun-sqlite/migrator';
+import { type DbClient, createDbClient } from '../db/client';
+
+/**
+ * Find migrations folder relative to current working directory
+ */
+function findMigrationsFolder(): string {
+  // Try common locations
+  const candidates = [
+    './drizzle', // Running from backend directory
+    './backend/drizzle', // Running from celilo directory
+    join(process.cwd(), 'drizzle'), // Absolute from backend
+    join(process.cwd(), 'backend', 'drizzle'), // Absolute from celilo
+  ];
+
+  for (const candidate of candidates) {
+    const metaPath = join(candidate, 'meta', '_journal.json');
+    if (existsSync(metaPath)) {
+      return candidate;
+    }
+  }
+
+  throw new Error(`Could not find drizzle migrations folder. Tried: ${candidates.join(', ')}`);
+}
+
+/**
+ * Setup test database with real migrations
+ *
+ * This helper ensures tests use the same schema as production by running
+ * actual migrations instead of manual CREATE TABLE statements.
+ *
+ * Benefits:
+ * - Single source of truth for schema
+ * - Tests automatically use latest schema
+ * - Validates migration correctness
+ *
+ * @param testDbPath - Path to test database file
+ * @returns Database client instance
+ */
+export async function setupTestDatabase(testDbPath: string) {
+  // Create database client
+  const db = createDbClient({ path: testDbPath });
+
+  // Find and run migrations
+  const migrationsFolder = findMigrationsFolder();
+  await migrate(db, { migrationsFolder });
+
+  return db;
+}
+
+/**
+ * Cleanup test database
+ *
+ * @param db - Database client to close
+ * @param testDbPath - Path to test database file to delete
+ */
+export async function cleanupTestDatabase(db: DbClient, testDbPath: string) {
+  // Close database connection
+  db.$client.close();
+
+  // Delete test database file
+  if (existsSync(testDbPath)) {
+    await unlink(testDbPath);
+  }
+
+  // Also delete WAL and SHM files if they exist
+  const walPath = `${testDbPath}-wal`;
+  const shmPath = `${testDbPath}-shm`;
+
+  if (existsSync(walPath)) {
+    await unlink(walPath);
+  }
+
+  if (existsSync(shmPath)) {
+    await unlink(shmPath);
+  }
+}
+
+/**
+ * Generate unique test database path
+ *
+ * @param prefix - Optional prefix for the database file (defaults to 'test-celilo')
+ * @returns Unique database file path
+ */
+export function generateTestDbPath(prefix = 'test-celilo'): string {
+  return `./${prefix}-${Date.now()}-${Math.random()}.db`;
+}

package/src/test-utils/value-extractor.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Value Extractor Tests
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import {
+  compareExtractedValues,
+  extractAnsibleValues,
+  extractTerraformValues,
+} from './value-extractor';
+
+const TEST_DIR = './test-value-extractor-temp';
+
+describe('Value Extractor', () => {
+  beforeEach(async () => {
+    if (existsSync(TEST_DIR)) {
+      await rm(TEST_DIR, { recursive: true });
+    }
+    await mkdir(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    if (existsSync(TEST_DIR)) {
+      await rm(TEST_DIR, { recursive: true });
+    }
+  });
+
+  describe('extractTerraformValues', () => {
+    test('should extract all terraform values correctly', async () => {
+      const terraformContent = `
+resource "proxmox_lxc" "homebridge" {
+  target_node = var.node_name
+  vmid        = 2110
+  hostname    = "iot"
+  ostemplate  = var.lxc_template_id
+
+  cores  = 2
+  memory = 1024
+
+  network {
+    name   = "eth0"
+    bridge = "vmbr0"
+    tag    = 192
+    ip     = "192.168.0.110/24"
+    gw     = "192.168.0.254"
+  }
+
+  rootfs {
+    storage = "datacenter"
+    size    = "20G"
+  }
+}
+`;
+
+      const terraformPath = `${TEST_DIR}/main.tf`;
+      await writeFile(terraformPath, terraformContent);
+
+      const values = await extractTerraformValues(terraformPath);
+
+      expect(values.vmid).toBe(2110);
+      expect(values.hostname).toBe('iot');
+      expect(values.ip).toBe('192.168.0.110/24');
+      expect(values.gateway).toBe('192.168.0.254');
+      expect(values.vlan).toBe(192);
+      expect(values.cores).toBe(2);
+      expect(values.memory).toBe(1024);
+      expect(values.storage).toBe('datacenter');
+      expect(values.rootfs_size).toBe('20G');
+    });
+
+    test('should handle missing values gracefully', async () => {
+      const terraformContent = `
+resource "proxmox_lxc" "homebridge" {
+  vmid     = 2110
+  hostname = "iot"
+}
+`;
+
+      const terraformPath = `${TEST_DIR}/main.tf`;
+      await writeFile(terraformPath, terraformContent);
+
+      const values = await extractTerraformValues(terraformPath);
+
+      expect(values.vmid).toBe(2110);
+      expect(values.hostname).toBe('iot');
+      expect(values.ip).toBeUndefined();
+      expect(values.cores).toBeUndefined();
+    });
+  });
+
+  describe('extractAnsibleValues', () => {
+    test('should extract all ansible values correctly', async () => {
+      // Create proper inventory structure
+      await mkdir(`${TEST_DIR}/ansible/inventory/group_vars`, { recursive: true });
+
+      // Create group_vars/all.yml with system config (not a playbook)
+      const groupVarsContent = `---
+# System-wide variables available to all hosts
+dns_primary: 192.168.0.1
+dns_fallback: 8.8.8.8 1.1.1.1
+routing_internal_gateway: 192.168.0.254
+`;
+
+      await writeFile(`${TEST_DIR}/ansible/inventory/group_vars/all.yml`, groupVarsContent);
+
+      const values = await extractAnsibleValues(`${TEST_DIR}/ansible`);
+
+      expect(values.dns_primary).toBe('192.168.0.1');
+      expect(values.dns_fallback).toBe('8.8.8.8 1.1.1.1');
+      expect(values.gateway).toBe('192.168.0.254');
+    });
+  });
+
+  describe('compareExtractedValues', () => {
+    test('should pass when all values match', async () => {
+      // Setup test files
+      await mkdir(`${TEST_DIR}/terraform`, { recursive: true });
+      await mkdir(`${TEST_DIR}/ansible/inventory/group_vars`, { recursive: true });
+
+      const terraformContent = `
+resource "proxmox_lxc" "homebridge" {
+  vmid        = 2110
+  hostname    = "iot"
+  cores       = 1
+  memory      = 1024
+
+  network {
+    tag    = 192
+    ip     = "192.168.0.110/24"
+    gw     = "192.168.0.254"
+  }
+
+  rootfs {
+    storage = "datacenter"
+    size    = "20G"
+  }
+}
+`;
+
+      const groupVarsContent = `---
+# System-wide variables available to all hosts
+dns_primary: 192.168.0.1
+dns_fallback: 8.8.8.8 1.1.1.1
+routing_internal_gateway: 192.168.0.254
+`;
+
+      await writeFile(`${TEST_DIR}/terraform/main.tf`, terraformContent);
+      await writeFile(`${TEST_DIR}/ansible/inventory/group_vars/all.yml`, groupVarsContent);
+
+      const expectedValues = {
+        terraform: {
+          vmid: 2110,
+          hostname: 'iot',
+          ip: '192.168.0.110/24',
+          gateway: '192.168.0.254',
+          vlan: 192,
+          cores: 1,
+          memory: 1024,
+          storage: 'datacenter',
+          rootfs_size: '20G',
+        },
+        ansible: {
+          dns_primary: '192.168.0.1',
+          dns_fallback: '8.8.8.8 1.1.1.1',
+          gateway: '192.168.0.254',
+        },
+      };
+
+      const result = await compareExtractedValues(TEST_DIR, expectedValues);
+
+      expect(result.pass).toBe(true);
+      expect(result.mismatches).toHaveLength(0);
+    });
+
+    test('should detect mismatches when values differ', async () => {
+      // Setup test files with wrong values
+      await mkdir(`${TEST_DIR}/terraform`, { recursive: true });
+      await mkdir(`${TEST_DIR}/ansible/inventory/group_vars`, { recursive: true });
+
+      const terraformContent = `
+resource "proxmox_lxc" "homebridge" {
+  vmid        = 9999
+  hostname    = "wrong-host"
+  cores       = 1
+}
+`;
+
+      const groupVarsContent = `---
+# System-wide variables with wrong values
+dns_primary: 1.1.1.1
+`;
+
+      await writeFile(`${TEST_DIR}/terraform/main.tf`, terraformContent);
+      await writeFile(`${TEST_DIR}/ansible/inventory/group_vars/all.yml`, groupVarsContent);
+
+      const expectedValues = {
+        terraform: {
+          vmid: 2110,
+          hostname: 'iot',
+          cores: 1,
+        },
+        ansible: {
+          dns_primary: '192.168.0.1',
+        },
+      };
+
+      const result = await compareExtractedValues(TEST_DIR, expectedValues);
+
+      expect(result.pass).toBe(false);
+      expect(result.mismatches).toHaveLength(3);
+
+      // Check specific mismatches
+      const vmidMismatch = result.mismatches.find((m) => m.path === 'terraform.vmid');
+      expect(vmidMismatch).toBeDefined();
+      expect(vmidMismatch?.expected).toBe(2110);
+      expect(vmidMismatch?.actual).toBe(9999);
+
+      const hostnameMismatch = result.mismatches.find((m) => m.path === 'terraform.hostname');
+      expect(hostnameMismatch).toBeDefined();
+      expect(hostnameMismatch?.expected).toBe('iot');
+      expect(hostnameMismatch?.actual).toBe('wrong-host');
+
+      const dnsMismatch = result.mismatches.find((m) => m.path === 'ansible.dns_primary');
+      expect(dnsMismatch).toBeDefined();
+      expect(dnsMismatch?.expected).toBe('192.168.0.1');
+      expect(dnsMismatch?.actual).toBe('1.1.1.1');
+    });
+  });
+});