@celilo/cli 1.8.0 → 1.9.1

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

@@ -8,6 +8,7 @@
  */
 
 import { CLIContext } from './cli-context';
+import { getModuleTestConfig } from './fixtures';
 import { type IntegrationTestContext, setupIntegrationTest } from './integration';
 
 /**
@@ -38,6 +39,52 @@ interface HomebridgeModuleOptions extends BaseFixtureOptions {
   withMockInfrastructure?: boolean;
 }
 
+/**
+ * A verified container service covering every allocatable zone, so a fixture
+ * can reach `module generate`.
+ *
+ * Extracted rather than copied: generation refuses without infrastructure, so
+ * every fixture that generates needs this, and a second inline copy would drift
+ * from the first the moment `containerServices` gains a column.
+ */
+async function insertMockContainerService(dbPath: string): Promise<void> {
+  const { getDb } = await import('../db/client');
+  const { containerServices } = await import('../db/schema');
+  const originalDbPath = process.env.CELILO_DB_PATH;
+  process.env.CELILO_DB_PATH = 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;
+    }
+  }
+}
+
 /**
  * Homebridge module fixture result
  */
@@ -83,41 +130,7 @@ export async function homebridgeModule(
 
   // 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;
-      }
-    }
+    await insertMockContainerService(ctx.dbPath);
   }
 
   // Create CLI context with integration test env
@@ -195,6 +208,105 @@ export async function homebridgeModule(
   };
 }
 
+/**
+ * `dnsmasq-dhcp` fixture, for the golden comparison.
+ *
+ * ⚠️ IMPORTS THE REAL MODULE, `../../modules/dnsmasq-dhcp`, and not a copy under
+ * `test-fixtures/modules/`. That is the whole point of it.
+ *
+ * `homebridgeModule` imports a copy, and the copy has drifted 29 lines in the
+ * manifest and 6 in the Terraform template. So the golden gate compares
+ * generated-from-a-copy against golden-from-the-same-copy: both sides move
+ * together, and the shipped module is on neither. Worse, the copy is frozen at
+ * `version: 1.0.0` with the container-infrastructure variables `required: true`
+ * — the pre-fix state of a real bug (marking them required made homebridge
+ * container-only). The gate still passes against that shape and cannot notice
+ * it returning. Tracked as celilo#1084.
+ *
+ * Pointing at the shipped module means this golden fails when the generator's
+ * output for the shipped module changes, which is the only version worth having.
+ */
+export interface DnsmasqDhcpModuleFixture {
+  cli: CLIContext;
+  moduleId: string;
+  config: Record<string, unknown>;
+  context: IntegrationTestContext;
+  cleanup: () => Promise<void>;
+}
+
+export interface DnsmasqDhcpModuleOptions extends BaseFixtureOptions {
+  /** Seed a container service, without which generation has no infrastructure. */
+  withMockInfrastructure?: boolean;
+  /** Set the `network.internal.*` system config the templates resolve against. */
+  withSystemConfig?: boolean;
+}
+
+export async function dnsmasqDhcpModule(
+  options: DnsmasqDhcpModuleOptions = {},
+): Promise<DnsmasqDhcpModuleFixture> {
+  const ctx = await setupIntegrationTest();
+
+  if (options.withMockInfrastructure) {
+    await insertMockContainerService(ctx.dbPath);
+  }
+
+  const cli = await CLIContext.create('src/cli/index.ts', {
+    CELILO_DB_PATH: ctx.dbPath,
+    CELILO_DATA_DIR: ctx.dataDir,
+  });
+
+  const moduleId = 'dnsmasq-dhcp';
+
+  if (options.withSystemConfig) {
+    // `internal` only — it is the single zone this module declares, and adding
+    // others would put values in the golden that nothing generated from.
+    (await cli.run('system config set network.bridge vmbr0')).expectSuccess();
+    (await cli.run('system config set network.internal.vlan 1')).expectSuccess();
+    (await cli.run('system config set network.internal.gateway 10.99.1.1')).expectSuccess();
+    (await cli.run('system config set network.internal.subnet 10.99.1.0/24')).expectSuccess();
+    (
+      await cli.run(
+        'system config set ssh.public_key ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC... test@celilo',
+      )
+    ).expectSuccess();
+  }
+
+  // Read from `test-fixtures/test-values.yml` rather than written out here, so
+  // that file's entry for this module is load-bearing rather than decorative. A
+  // golden generated from values nothing else references would drift from the
+  // canonical set with nothing noticing.
+  //
+  // That entry carries EVERY `required: true` variable, including the ones with
+  // defaults: celilo asks for a required variable whether or not it has one,
+  // and an unanswered ask has no headless answer, so the command blocks until
+  // its timeout naming no variable.
+  const config = await getModuleTestConfig(moduleId);
+  if (Object.keys(config).length === 0) {
+    throw new Error(
+      `test-values.yml carries no entry for '${moduleId}', so this fixture would generate from an empty config and the golden would record that. Add one.`,
+    );
+  }
+
+  (await cli.run(`module import ../../modules/${moduleId}`)).expectSuccess();
+
+  for (const [key, value] of Object.entries(config)) {
+    // An array has to reach the CLI as JSON; a scalar is quoted as-is.
+    const encoded = Array.isArray(value) ? `'${JSON.stringify(value)}'` : `"${value}"`;
+    (await cli.run(`module config set ${moduleId} ${key} ${encoded}`)).expectSuccess();
+  }
+
+  if (options.generated) {
+    (await cli.run(`module generate ${moduleId}`)).expectSuccess();
+  }
+
+  const cleanup = async () => {
+    await cli.dispose();
+    await ctx.cleanup();
+  };
+
+  return { cli, moduleId, config, context: ctx, cleanup };
+}
+
 /**
  * Caddy module fixture options
  */

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

@@ -1,80 +0,0 @@
-import { existsSync } from 'node:fs';
-import { unlink } from 'node:fs/promises';
-import { migrate } from 'drizzle-orm/bun-sqlite/migrator';
-import { type DbClient, createDbClient, findMigrationsFolder } from '../db/client';
-
-// `findMigrationsFolder` is imported from db/client rather than redefined here.
-// This file used to carry its own copy, and the copy had drifted: it listed
-// only CWD-RELATIVE candidates (`./drizzle`, `process.cwd()/drizzle`, …) and was
-// missing the `join(currentDir, '../../drizzle')` fallback that resolves
-// relative to the source file.
-//
-// The effect was invisible from `apps/celilo` and total from the repo root —
-// which is where CLAUDE.md says to run the gate. Every suite using
-// setupTestDatabase threw here, left `db` unassigned, and then failed again in
-// its own afterEach on `db.$client`, so one missing path candidate presented as
-// hundreds of unrelated-looking assertion failures (celilo: 668 across the
-// repo, 341 in apps/celilo/src alone).
-
-/**
- * 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`;
-}