@celilo/cli 0.1.0

package/src/test-utils/integration.ts

@@ -0,0 +1,81 @@
+import { existsSync, rmSync } from 'node:fs';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setupTestDatabaseFile } from './database';
+
+/**
+ * Integration test context with isolated database and data directory
+ */
+export interface IntegrationTestContext {
+  /** Path to test database file */
+  dbPath: string;
+  /** Path to test data directory */
+  dataDir: string;
+  /** CLI command prefix with environment variables */
+  cli: string;
+  /** Cleanup function (closes DB and removes temp directories) */
+  cleanup: () => Promise<void>;
+}
+
+/**
+ * Setup complete integration test environment
+ *
+ * Creates:
+ * - Isolated test database (file-based for CLI access)
+ * - Isolated data directory
+ * - Runs migrations
+ * - Returns CLI command prefix with proper env vars
+ *
+ * @returns Integration test context with cleanup function
+ *
+ * @example
+ * ```typescript
+ * let ctx: IntegrationTestContext;
+ *
+ * beforeEach(async () => {
+ *   ctx = await setupIntegrationTest();
+ * });
+ *
+ * afterEach(async () => {
+ *   await ctx.cleanup();
+ * });
+ *
+ * test('my test', () => {
+ *   const output = runCli(ctx.cli, 'system config get');
+ *   expect(output).toContain('...');
+ * });
+ * ```
+ */
+export async function setupIntegrationTest(): Promise<IntegrationTestContext> {
+  // Setup isolated database
+  const testDb = await setupTestDatabaseFile();
+  const dbPath = testDb.path;
+  const dbCleanup = testDb.cleanup;
+
+  // Setup isolated data directory (use mkdtemp to avoid timestamp collisions in parallel tests)
+  const dataDir = await mkdtemp(join(tmpdir(), 'celilo-test-'));
+
+  // CLI with isolated environment
+  const cli = `CELILO_DB_PATH="${dbPath}" CELILO_DATA_DIR="${dataDir}" bun run src/cli/index.ts`;
+
+  // Note: Migrations are auto-run by createDbClient() in setupTestDatabaseFile()
+
+  // Unified cleanup function
+  const cleanup = async () => {
+    // Cleanup data directory
+    if (existsSync(dataDir)) {
+      rmSync(dataDir, { recursive: true, force: true });
+    }
+
+    // Cleanup database
+    await dbCleanup();
+  };
+
+  return {
+    dbPath,
+    dataDir,
+    cli,
+    cleanup,
+  };
+}

package/src/test-utils/module-fixtures.ts

@@ -0,0 +1,468 @@
+/**
+ * Module-Specific Test Fixtures
+ *
+ * Factory functions that create pre-configured test environments for specific modules.
+ * Each fixture knows what config keys the module needs and sets up dependencies.
+ *
+ * Reduces test setup from 30+ lines to a single function call.
+ */
+
+import { CLIContext } from './cli-context';
+import { type IntegrationTestContext, setupIntegrationTest } from './integration';
+
+/**
+ * Base fixture options
+ */
+interface BaseFixtureOptions {
+  /** Whether to run module generate (default: false) */
+  generated?: boolean;
+}
+
+/**
+ * Homebridge module fixture options
+ */
+interface HomebridgeModuleOptions extends BaseFixtureOptions {
+  /** Hostname (default: 'iot') */
+  hostname?: string;
+  /** Bridge name (default: 'Home Bridge') */
+  bridgeName?: string;
+  /** Bridge username MAC address (default: generated) */
+  bridgeUsername?: string;
+  /** Bridge port (default: 51826) */
+  bridgePort?: number;
+  /** Bridge PIN (default: '031-45-154') */
+  bridgePin?: string;
+  /** Setup full system config for generation (default: false) */
+  withSystemConfig?: boolean;
+  /** Setup mock infrastructure for generation (default: false) */
+  withMockInfrastructure?: boolean;
+}
+
+/**
+ * Homebridge module fixture result
+ */
+interface HomebridgeModuleFixture {
+  /** CLI context (persistent process) */
+  cli: CLIContext;
+  /** Module ID */
+  moduleId: string;
+  /** Configuration used */
+  config: Record<string, unknown>;
+  /** Integration test context (DB, data dir) */
+  context: IntegrationTestContext;
+  /** Cleanup function */
+  cleanup: () => Promise<void>;
+}
+
+/**
+ * Homebridge module fixture
+ *
+ * Sets up Homebridge module with all required configuration.
+ * Optionally runs module generate to create Terraform/Ansible files.
+ *
+ * @example
+ * ```typescript
+ * const { cli, moduleId, config, cleanup } = await homebridgeModule({
+ *   generated: true,
+ *   bridgePort: 51826,
+ *   hostname: 'iot'
+ * });
+ *
+ * // Module is configured and generated - run tests
+ * await cli.run('module status homebridge').expectSuccess();
+ *
+ * // Cleanup
+ * await cleanup();
+ * ```
+ */
+export async function homebridgeModule(
+  options: HomebridgeModuleOptions = {},
+): Promise<HomebridgeModuleFixture> {
+  // Setup integration test environment
+  const ctx = await setupIntegrationTest();
+
+  // Setup mock infrastructure if requested (needed for generation)
+  if (options.withMockInfrastructure) {
+    const { getDb } = await import('../db/client');
+    const { containerServices } = await import('../db/schema');
+    const originalDbPath = process.env.CELILO_DB_PATH;
+    process.env.CELILO_DB_PATH = ctx.dbPath;
+    try {
+      const db = getDb();
+      await db.insert(containerServices).values({
+        id: 'test-proxmox',
+        serviceId: 'test-proxmox',
+        name: 'Test Proxmox',
+        providerName: 'proxmox',
+        zones: ['internal', 'dmz', 'app', 'secure'],
+        apiCredentialsEncrypted: JSON.stringify({
+          encryptedValue: 'dummy',
+          iv: 'dummy',
+          authTag: 'dummy',
+        }),
+        providerConfig: {
+          default_target_node: 'pve',
+          lxc_template: 'local:vztmpl/ubuntu-22.04-standard_22.04-1_amd64.tar.zst',
+          storage: 'local-lvm',
+        },
+        verified: true,
+        verifiedAt: new Date(),
+        verificationError: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      });
+    } finally {
+      if (originalDbPath) {
+        process.env.CELILO_DB_PATH = originalDbPath;
+      } else {
+        process.env.CELILO_DB_PATH = undefined;
+      }
+    }
+  }
+
+  // Create CLI context with integration test env
+  const cli = await CLIContext.create('src/cli/index.ts', {
+    CELILO_DB_PATH: ctx.dbPath,
+    CELILO_DATA_DIR: ctx.dataDir,
+  });
+
+  const moduleId = 'homebridge';
+
+  // Setup system config if requested (needed for generation)
+  if (options.withSystemConfig) {
+    // DNS configuration
+    (await cli.run('system config set dns.primary 192.168.0.1')).expectSuccess();
+    (await cli.run(`system config set dns.fallback '8.8.8.8 1.1.1.1'`)).expectSuccess();
+
+    // Network configuration
+    (await cli.run('system config set network.bridge vmbr0')).expectSuccess();
+    (await cli.run('system config set network.dmz.vlan 10')).expectSuccess();
+    (await cli.run('system config set network.dmz.gateway 10.0.10.1')).expectSuccess();
+    (await cli.run('system config set network.dmz.subnet 10.0.10.0/24')).expectSuccess();
+    (await cli.run('system config set network.app.vlan 20')).expectSuccess();
+    (await cli.run('system config set network.app.gateway 10.0.20.1')).expectSuccess();
+    (await cli.run('system config set network.app.subnet 10.0.20.0/24')).expectSuccess();
+
+    // SSH configuration
+    (
+      await cli.run(
+        'system config set ssh.public_key ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC... test@celilo',
+      )
+    ).expectSuccess();
+
+    // Note: primary_domain and admin.email are no longer system config —
+    // they live in the dns_registrar capability and the authentik/caddy
+    // module variables respectively (see MANIFEST_V2 D9).
+  }
+
+  // User-configurable fields only (match manifest.yml)
+  const config = {
+    hostname: options.hostname ?? 'iot',
+    bridge_name: options.bridgeName ?? 'Home Bridge',
+    bridge_username: options.bridgeUsername ?? '0E:21:4A:BC:DE:F0',
+    bridge_pin: options.bridgePin ?? '031-45-154',
+    bridge_port: options.bridgePort ?? 51826,
+  };
+
+  // Import module from fixture path
+  const modulePath = './test-fixtures/modules/homebridge';
+  (await cli.run(`module import ${modulePath}`)).expectSuccess();
+
+  // Configure module (only user-configurable fields)
+  for (const [key, value] of Object.entries(config)) {
+    // Don't quote numbers, they need to be parsed as integers
+    const valueStr = typeof value === 'number' ? String(value) : `"${value}"`;
+    (await cli.run(`module config set ${moduleId} ${key} ${valueStr}`)).expectSuccess();
+  }
+
+  // Generate if requested
+  if (options.generated) {
+    (await cli.run(`module generate ${moduleId}`)).expectSuccess();
+  }
+
+  // Unified cleanup
+  const cleanup = async () => {
+    await cli.dispose();
+    await ctx.cleanup();
+  };
+
+  return {
+    cli,
+    moduleId,
+    config,
+    context: ctx,
+    cleanup,
+  };
+}
+
+/**
+ * Caddy module fixture options
+ */
+interface CaddyModuleOptions extends BaseFixtureOptions {
+  /** Hostname (default: 'www-test') */
+  hostname?: string;
+  /** Whether to build Caddy from source (default: true) */
+  buildCaddy?: boolean;
+  /** DNS provider (default: 'cloudflare') */
+  dnsProvider?: string;
+}
+
+/**
+ * Caddy module fixture result
+ */
+interface CaddyModuleFixture {
+  cli: CLIContext;
+  moduleId: string;
+  /** DNS external module ID (dependency) */
+  dnsExternalId: string;
+  config: Record<string, unknown>;
+  context: IntegrationTestContext;
+  cleanup: () => Promise<void>;
+}
+
+/**
+ * Caddy module fixture
+ *
+ * Sets up Caddy module with dns-external dependency.
+ * Automatically creates and configures dns-external module.
+ *
+ * @example
+ * ```typescript
+ * const { cli, moduleId, dnsExternalId, cleanup } = await caddyModule({
+ *   generated: true,
+ *   hostname: 'www'
+ * });
+ * ```
+ */
+export async function caddyModule(options: CaddyModuleOptions = {}): Promise<CaddyModuleFixture> {
+  const ctx = await setupIntegrationTest();
+  const cli = await CLIContext.create('src/cli/index.ts', {
+    CELILO_DB_PATH: ctx.dbPath,
+    CELILO_DATA_DIR: ctx.dataDir,
+  });
+
+  const moduleId = 'caddy';
+  const dnsExternalId = 'dns-external';
+
+  // Setup dns-external dependency first
+  (await cli.run(`module add ${dnsExternalId}`)).expectSuccess();
+  (await cli.run(`module config set ${dnsExternalId} hostname dns-ext`)).expectSuccess();
+  (await cli.run(`module config set ${dnsExternalId} cores 1`)).expectSuccess();
+  (await cli.run(`module config set ${dnsExternalId} memory 512`)).expectSuccess();
+
+  // Setup caddy
+  const config = {
+    hostname: options.hostname ?? 'www-test',
+    cores: 1,
+    memory: 1024,
+    build_caddy: options.buildCaddy ?? true,
+    dns_provider: options.dnsProvider ?? 'cloudflare',
+  };
+
+  (await cli.run(`module add ${moduleId}`)).expectSuccess();
+
+  for (const [key, value] of Object.entries(config)) {
+    const valueStr = typeof value === 'boolean' ? String(value) : value;
+    (await cli.run(`module config set ${moduleId} ${key} "${valueStr}"`)).expectSuccess();
+  }
+
+  // Generate if requested
+  if (options.generated) {
+    (await cli.run(`module generate ${dnsExternalId}`)).expectSuccess();
+    (await cli.run(`module generate ${moduleId}`)).expectSuccess();
+  }
+
+  const cleanup = async () => {
+    await cli.dispose();
+    await ctx.cleanup();
+  };
+
+  return {
+    cli,
+    moduleId,
+    dnsExternalId,
+    config,
+    context: ctx,
+    cleanup,
+  };
+}
+
+/**
+ * DNS-external module fixture options
+ */
+interface DnsExternalModuleOptions extends BaseFixtureOptions {
+  /** DNS provider (default: 'cloudflare') */
+  provider?: string;
+  /** API token for testing (default: 'test-token-123') */
+  apiToken?: string;
+}
+
+/**
+ * DNS-external module fixture result
+ */
+interface DnsExternalModuleFixture {
+  cli: CLIContext;
+  moduleId: string;
+  apiToken: string;
+  config: Record<string, unknown>;
+  context: IntegrationTestContext;
+  cleanup: () => Promise<void>;
+}
+
+/**
+ * DNS-external module fixture
+ *
+ * Sets up dns-external module for external DNS management.
+ *
+ * @example
+ * ```typescript
+ * const { cli, moduleId, apiToken, cleanup } = await dnsExternalModule({
+ *   generated: true,
+ *   provider: 'cloudflare'
+ * });
+ * ```
+ */
+export async function dnsExternalModule(
+  options: DnsExternalModuleOptions = {},
+): Promise<DnsExternalModuleFixture> {
+  const ctx = await setupIntegrationTest();
+  const cli = await CLIContext.create('src/cli/index.ts', {
+    CELILO_DB_PATH: ctx.dbPath,
+    CELILO_DATA_DIR: ctx.dataDir,
+  });
+
+  const moduleId = 'dns-external';
+  const apiToken = options.apiToken ?? 'test-token-123';
+
+  const config = {
+    hostname: 'dns-ext-test',
+    cores: 1,
+    memory: 512,
+    provider: options.provider ?? 'cloudflare',
+  };
+
+  (await cli.run(`module add ${moduleId}`)).expectSuccess();
+
+  for (const [key, value] of Object.entries(config)) {
+    (await cli.run(`module config set ${moduleId} ${key} "${value}"`)).expectSuccess();
+  }
+
+  // Set API token as secret
+  (await cli.run(`module secret set ${moduleId} api_token "${apiToken}"`)).expectSuccess();
+
+  // Generate if requested
+  if (options.generated) {
+    (await cli.run(`module generate ${moduleId}`)).expectSuccess();
+  }
+
+  const cleanup = async () => {
+    await cli.dispose();
+    await ctx.cleanup();
+  };
+
+  return {
+    cli,
+    moduleId,
+    apiToken,
+    config,
+    context: ctx,
+    cleanup,
+  };
+}
+
+/**
+ * Multi-module environment options
+ */
+interface MultiModuleOptions {
+  /** Module IDs to set up */
+  modules: string[];
+  /** Generate all modules (default: false) */
+  generateAll?: boolean;
+}
+
+/**
+ * Multi-module environment result
+ */
+interface MultiModuleFixture {
+  cli: CLIContext;
+  /** Map of module ID to configuration */
+  modules: Map<string, Record<string, unknown>>;
+  context: IntegrationTestContext;
+  cleanup: () => Promise<void>;
+}
+
+/**
+ * Multi-module environment fixture
+ *
+ * Sets up multiple modules with dependencies.
+ * Automatically resolves dependency order (e.g., caddy requires dns-external).
+ *
+ * @example
+ * ```typescript
+ * const { cli, modules, cleanup } = await multiModule({
+ *   modules: ['homebridge', 'caddy'],
+ *   generateAll: true
+ * });
+ *
+ * expect(modules.has('homebridge')).toBe(true);
+ * expect(modules.has('caddy')).toBe(true);
+ * expect(modules.has('dns-external')).toBe(true); // Auto-added dependency
+ * ```
+ */
+export async function multiModule(options: MultiModuleOptions): Promise<MultiModuleFixture> {
+  const ctx = await setupIntegrationTest();
+  const cli = await CLIContext.create('src/cli/index.ts', {
+    CELILO_DB_PATH: ctx.dbPath,
+    CELILO_DATA_DIR: ctx.dataDir,
+  });
+
+  const modules = new Map<string, Record<string, unknown>>();
+
+  // Resolve dependencies and setup modules
+  // TODO: Implement proper dependency resolution
+  // For now, manually handle known dependencies
+
+  for (const moduleId of options.modules) {
+    switch (moduleId) {
+      case 'homebridge': {
+        const fixture = await homebridgeModule({
+          generated: options.generateAll,
+        });
+        modules.set(moduleId, fixture.config);
+        // Don't cleanup sub-fixtures, we'll cleanup at the end
+        break;
+      }
+      case 'caddy': {
+        const fixture = await caddyModule({ generated: options.generateAll });
+        modules.set(moduleId, fixture.config);
+        modules.set('dns-external', {}); // Mark as added
+        break;
+      }
+      // Add more modules as needed
+      default:
+        throw new Error(`Unknown module: ${moduleId}`);
+    }
+  }
+
+  const cleanup = async () => {
+    await cli.dispose();
+    await ctx.cleanup();
+  };
+
+  return {
+    cli,
+    modules,
+    context: ctx,
+    cleanup,
+  };
+}
+
+/**
+ * Export all fixtures as namespace
+ */
+export const fixtures = {
+  homebridgeModule,
+  caddyModule,
+  dnsExternalModule,
+  multiModule,
+};

package/src/test-utils/modules.test.ts

@@ -0,0 +1,144 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { modules } from '../db/schema';
+import { cleanupTestDatabase, setupTestDatabase } from './database';
+import {
+  cleanupMultipleTestModules,
+  cleanupTestModule,
+  getModuleState,
+  importMultipleTestModules,
+  importTestModule,
+} from './modules';
+
+describe('Module Test Utilities', () => {
+  let db: Awaited<ReturnType<typeof setupTestDatabase>>;
+
+  beforeEach(async () => {
+    db = await setupTestDatabase();
+  });
+
+  afterEach(async () => {
+    await cleanupTestDatabase(db);
+  });
+
+  describe('importTestModule', () => {
+    test('imports module from fixture', async () => {
+      const moduleId = await importTestModule('./test-fixtures/modules/artifact-test', db);
+
+      expect(moduleId).toBe('artifact-test');
+
+      const result = await db.select().from(modules);
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('artifact-test');
+      expect(result[0].state).toBe('IMPORTED');
+    });
+
+    test('imports module with configuration', async () => {
+      const moduleId = await importTestModule('./test-fixtures/modules/artifact-test', db, {
+        config: {
+          vmid: '100',
+          hostname: 'test-host',
+        },
+      });
+
+      expect(moduleId).toBe('artifact-test');
+
+      // TODO: Add assertions for config when module config utilities are available
+    });
+
+    test('returns module ID', async () => {
+      const moduleId = await importTestModule('./test-fixtures/modules/artifact-test', db);
+
+      expect(typeof moduleId).toBe('string');
+      expect(moduleId.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('cleanupTestModule', () => {
+    test('removes module from database', async () => {
+      const moduleId = await importTestModule('./test-fixtures/modules/artifact-test', db);
+
+      const before = await db.select().from(modules);
+      expect(before).toHaveLength(1);
+
+      await cleanupTestModule(moduleId, db);
+
+      const after = await db.select().from(modules);
+      expect(after).toHaveLength(0);
+    });
+
+    test('handles non-existent module gracefully', async () => {
+      await expect(cleanupTestModule('non-existent-module', db)).resolves.toBeUndefined();
+    });
+  });
+
+  describe('importMultipleTestModules', () => {
+    test('imports multiple modules', async () => {
+      // Note: Using artifact-test twice to test multiple imports
+      // In real scenarios, these would be different modules
+      const moduleIds = await importMultipleTestModules(
+        [{ path: './test-fixtures/modules/artifact-test' }],
+        db,
+      );
+
+      expect(moduleIds).toHaveLength(1);
+      expect(moduleIds[0]).toBe('artifact-test');
+
+      const result = await db.select().from(modules);
+      expect(result).toHaveLength(1);
+    });
+
+    test('imports modules with configuration', async () => {
+      const moduleIds = await importMultipleTestModules(
+        [
+          {
+            path: './test-fixtures/modules/artifact-test',
+            options: { config: { vmid: '100' } },
+          },
+        ],
+        db,
+      );
+
+      expect(moduleIds).toHaveLength(1);
+    });
+
+    test('handles empty array', async () => {
+      const moduleIds = await importMultipleTestModules([], db);
+      expect(moduleIds).toHaveLength(0);
+    });
+  });
+
+  describe('cleanupMultipleTestModules', () => {
+    test('removes multiple modules', async () => {
+      const moduleIds = await importMultipleTestModules(
+        [{ path: './test-fixtures/modules/artifact-test' }],
+        db,
+      );
+
+      const before = await db.select().from(modules);
+      expect(before).toHaveLength(1);
+
+      await cleanupMultipleTestModules(moduleIds, db);
+
+      const after = await db.select().from(modules);
+      expect(after).toHaveLength(0);
+    });
+
+    test('handles empty array', async () => {
+      await expect(cleanupMultipleTestModules([], db)).resolves.toBeUndefined();
+    });
+  });
+
+  describe('getModuleState', () => {
+    test('returns module state', async () => {
+      const moduleId = await importTestModule('./test-fixtures/modules/artifact-test', db);
+
+      const state = await getModuleState(moduleId, db);
+      expect(state).toBe('IMPORTED');
+    });
+
+    test('returns null for non-existent module', async () => {
+      const state = await getModuleState('non-existent', db);
+      expect(state).toBeNull();
+    });
+  });
+});