@celilo/cli 0.1.0

package/src/templates/generator.test.ts

@@ -0,0 +1,645 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { type DbClient, createDbClient } from '../db/client';
+import { capabilities, moduleConfigs } from '../db/schema';
+import {
+  discoverTemplateFiles,
+  generateTemplates,
+  getOutputFilename,
+  isTemplateFile,
+  readTemplateFiles,
+  writeGeneratedFiles,
+} from './generator';
+import type { GeneratedFile } from './types';
+
+const TEST_MODULE_DIR = './test-module-templates';
+const TEST_OUTPUT_DIR = './test-generated';
+const TEST_DB_PATH = './test-templates.db';
+
+describe('Template Generator', () => {
+  let db: DbClient;
+
+  beforeEach(async () => {
+    // Create test database
+    db = createDbClient({ path: TEST_DB_PATH });
+
+    db.$client.run(`
+      CREATE TABLE IF NOT EXISTS modules (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        version TEXT NOT NULL,
+        description TEXT,
+        state TEXT NOT NULL DEFAULT 'IMPORTED',
+        manifest_data TEXT NOT NULL,
+        source_path TEXT NOT NULL,
+        imported_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        error_message TEXT
+      )
+    `);
+
+    db.$client.run(`
+      CREATE TABLE IF NOT EXISTS module_configs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        module_id TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        value_json TEXT,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        FOREIGN KEY (module_id) REFERENCES modules(id) ON DELETE CASCADE
+      )
+    `);
+
+    db.$client.run(`
+      CREATE TABLE IF NOT EXISTS capabilities (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        module_id TEXT NOT NULL,
+        capability_name TEXT NOT NULL,
+        version TEXT NOT NULL,
+        data TEXT NOT NULL,
+        registered_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        FOREIGN KEY (module_id) REFERENCES modules(id) ON DELETE CASCADE
+      )
+    `);
+
+    db.$client.run(`
+      CREATE TABLE IF NOT EXISTS secrets (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        module_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        encrypted_value TEXT NOT NULL,
+        iv TEXT NOT NULL,
+        auth_tag TEXT NOT NULL,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        FOREIGN KEY (module_id) REFERENCES modules(id) ON DELETE CASCADE
+      )
+    `);
+
+    db.$client.run(`
+      CREATE TABLE IF NOT EXISTS system_config (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        key TEXT NOT NULL UNIQUE,
+        value TEXT NOT NULL,
+        description TEXT,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+      )
+    `);
+
+    db.$client.run(`
+      CREATE TABLE IF NOT EXISTS machines (
+        id TEXT PRIMARY KEY,
+        hostname TEXT NOT NULL,
+        zone TEXT NOT NULL,
+        ip_address TEXT NOT NULL,
+        ssh_user TEXT NOT NULL,
+        ssh_key_encrypted TEXT NOT NULL,
+        hardware TEXT NOT NULL,
+        assigned_module_ids TEXT DEFAULT '[]' NOT NULL,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+      )
+    `);
+
+    db.$client.run(`
+      CREATE TABLE IF NOT EXISTS container_services (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        provider_name TEXT NOT NULL,
+        zones TEXT NOT NULL,
+        api_credentials_encrypted TEXT NOT NULL,
+        provider_config TEXT NOT NULL,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+      )
+    `);
+
+    db.$client.run(`
+      CREATE TABLE IF NOT EXISTS module_infrastructure (
+        id TEXT PRIMARY KEY,
+        module_id TEXT NOT NULL,
+        infrastructure_type TEXT NOT NULL,
+        machine_id TEXT,
+        service_id TEXT,
+        container_metadata TEXT,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        FOREIGN KEY (module_id) REFERENCES modules(id) ON DELETE CASCADE,
+        FOREIGN KEY (machine_id) REFERENCES machines(id),
+        FOREIGN KEY (service_id) REFERENCES container_services(id)
+      )
+    `);
+
+    // Clean up test directories
+    if (existsSync(TEST_MODULE_DIR)) {
+      await rm(TEST_MODULE_DIR, { recursive: true });
+    }
+    if (existsSync(TEST_OUTPUT_DIR)) {
+      await rm(TEST_OUTPUT_DIR, { recursive: true });
+    }
+
+    await mkdir(TEST_MODULE_DIR, { recursive: true });
+    await mkdir(TEST_OUTPUT_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    db.$client.close();
+
+    if (existsSync(TEST_DB_PATH)) {
+      await rm(TEST_DB_PATH);
+    }
+    const walPath = `${TEST_DB_PATH}-wal`;
+    const shmPath = `${TEST_DB_PATH}-shm`;
+    if (existsSync(walPath)) {
+      await rm(walPath);
+    }
+    if (existsSync(shmPath)) {
+      await rm(shmPath);
+    }
+
+    if (existsSync(TEST_MODULE_DIR)) {
+      await rm(TEST_MODULE_DIR, { recursive: true });
+    }
+    if (existsSync(TEST_OUTPUT_DIR)) {
+      await rm(TEST_OUTPUT_DIR, { recursive: true });
+    }
+  });
+
+  describe('isTemplateFile', () => {
+    test('should identify .tpl files', () => {
+      expect(isTemplateFile('main.tf.tpl')).toBe(true);
+      expect(isTemplateFile('playbook.yml.tpl')).toBe(true);
+    });
+
+    test('should identify .j2 files', () => {
+      expect(isTemplateFile('config.json.j2')).toBe(true);
+      expect(isTemplateFile('template.yaml.j2')).toBe(true);
+    });
+
+    test('should reject non-template files', () => {
+      expect(isTemplateFile('main.tf')).toBe(false);
+      expect(isTemplateFile('playbook.yml')).toBe(false);
+      expect(isTemplateFile('README.md')).toBe(false);
+    });
+  });
+
+  describe('getOutputFilename', () => {
+    test('should remove .tpl extension', () => {
+      expect(getOutputFilename('main.tf.tpl')).toBe('main.tf');
+      expect(getOutputFilename('variables.tf.tpl')).toBe('variables.tf');
+    });
+
+    test('should keep .j2 extension (Ansible Jinja2 templates)', () => {
+      expect(getOutputFilename('config.json.j2')).toBe('config.json.j2');
+      expect(getOutputFilename('playbook.yml.j2')).toBe('playbook.yml.j2');
+      expect(getOutputFilename('knot.conf.j2')).toBe('knot.conf.j2');
+    });
+
+    test('should return original if no template extension', () => {
+      expect(getOutputFilename('main.tf')).toBe('main.tf');
+      expect(getOutputFilename('README.md')).toBe('README.md');
+    });
+
+    test('should strip prefix before ansible/ directory', () => {
+      expect(getOutputFilename('celilo/ansible/playbook.yml.tpl')).toBe('ansible/playbook.yml');
+      expect(getOutputFilename('celilo/ansible/roles/app/tasks/main.yml.tpl')).toBe(
+        'ansible/roles/app/tasks/main.yml',
+      );
+    });
+
+    test('should strip prefix before terraform/ directory', () => {
+      expect(getOutputFilename('celilo/terraform/main.tf.tpl')).toBe('terraform/main.tf');
+      expect(getOutputFilename('celilo/terraform/variables.tf.tpl')).toBe('terraform/variables.tf');
+    });
+
+    test('should not strip ansible/terraform at root level', () => {
+      expect(getOutputFilename('ansible/playbook.yml.tpl')).toBe('ansible/playbook.yml');
+      expect(getOutputFilename('terraform/main.tf.tpl')).toBe('terraform/main.tf');
+    });
+  });
+
+  describe('discoverTemplateFiles', () => {
+    test('should find template files in directory', async () => {
+      const dir = join(TEST_MODULE_DIR, 'terraform');
+      await mkdir(dir, { recursive: true });
+      await writeFile(join(dir, 'main.tf.tpl'), 'content');
+      await writeFile(join(dir, 'variables.tf.tpl'), 'content');
+      await writeFile(join(dir, 'README.md'), 'not a template');
+
+      const templates = await discoverTemplateFiles(dir);
+
+      expect(templates).toHaveLength(2);
+      expect(templates).toContain('main.tf.tpl');
+      expect(templates).toContain('variables.tf.tpl');
+      expect(templates).not.toContain('README.md');
+    });
+
+    test('should find templates recursively', async () => {
+      const dir = join(TEST_MODULE_DIR, 'ansible');
+      await mkdir(join(dir, 'roles', 'app', 'tasks'), { recursive: true });
+      await writeFile(join(dir, 'playbook.yml.tpl'), 'content');
+      await writeFile(join(dir, 'roles', 'app', 'tasks', 'main.yml.tpl'), 'content');
+
+      const templates = await discoverTemplateFiles(dir);
+
+      expect(templates).toHaveLength(2);
+      expect(templates).toContain('playbook.yml.tpl');
+      expect(templates).toContain(join('roles', 'app', 'tasks', 'main.yml.tpl'));
+    });
+
+    test('should return empty array for non-existent directory', async () => {
+      const templates = await discoverTemplateFiles('./nonexistent');
+
+      expect(templates).toHaveLength(0);
+    });
+
+    test('should handle empty directory', async () => {
+      const dir = join(TEST_MODULE_DIR, 'empty');
+      await mkdir(dir, { recursive: true });
+
+      const templates = await discoverTemplateFiles(dir);
+
+      expect(templates).toHaveLength(0);
+    });
+  });
+
+  describe('readTemplateFiles', () => {
+    test('should read template files with content', async () => {
+      const dir = join(TEST_MODULE_DIR, 'terraform');
+      await mkdir(dir, { recursive: true });
+      await writeFile(join(dir, 'main.tf.tpl'), 'resource "test" {}');
+      await writeFile(join(dir, 'variables.tf.tpl'), 'variable "test" {}');
+
+      const templates = await readTemplateFiles(TEST_MODULE_DIR, [
+        'terraform/main.tf.tpl',
+        'terraform/variables.tf.tpl',
+      ]);
+
+      expect(templates).toHaveLength(2);
+      expect(templates[0]?.content).toBe('resource "test" {}');
+      expect(templates[0]?.targetPath).toBe('terraform/main.tf');
+      expect(templates[1]?.content).toBe('variable "test" {}');
+      expect(templates[1]?.targetPath).toBe('terraform/variables.tf');
+    });
+  });
+
+  describe('writeGeneratedFiles', () => {
+    test('should write files to output directory', async () => {
+      const files: GeneratedFile[] = [
+        { path: 'terraform/main.tf', content: 'resource "test" {}' },
+        { path: 'ansible/playbook.yml', content: 'tasks: []' },
+      ];
+
+      await writeGeneratedFiles(TEST_OUTPUT_DIR, files);
+
+      expect(existsSync(join(TEST_OUTPUT_DIR, 'terraform', 'main.tf'))).toBe(true);
+      expect(existsSync(join(TEST_OUTPUT_DIR, 'ansible', 'playbook.yml'))).toBe(true);
+    });
+
+    test('should create nested directories', async () => {
+      const files: GeneratedFile[] = [
+        { path: 'ansible/roles/app/tasks/main.yml', content: 'tasks: []' },
+      ];
+
+      await writeGeneratedFiles(TEST_OUTPUT_DIR, files);
+
+      expect(
+        existsSync(join(TEST_OUTPUT_DIR, 'ansible', 'roles', 'app', 'tasks', 'main.yml')),
+      ).toBe(true);
+    });
+  });
+
+  describe('generateTemplates', () => {
+    test('should generate templates with variable resolution', async () => {
+      // Setup module
+      db.$client.run(
+        `INSERT INTO modules (id, name, version, source_path, manifest_data) VALUES ('test-module', 'Test', '1.0.0', '/path', '{}')`,
+      );
+
+      db.insert(moduleConfigs)
+        .values([
+          { moduleId: 'test-module', key: 'container_ip', value: '192.168.0.50' },
+          { moduleId: 'test-module', key: 'hostname', value: 'test' },
+        ])
+        .run();
+
+      // Insert system config
+      db.$client.run(
+        `INSERT INTO system_config (key, value) VALUES ('management.ip', '192.168.0.10')`,
+      );
+
+      // Create template files
+      const terraformDir = join(TEST_MODULE_DIR, 'terraform');
+      await mkdir(terraformDir, { recursive: true });
+      await writeFile(
+        join(terraformDir, 'main.tf.tpl'),
+        `
+resource "proxmox_lxc" "container" {
+  hostname = "$self:hostname"
+  network {
+    ip = "$self:container_ip/24"
+    gateway = "$system:management.ip"
+  }
+}
+`,
+      );
+
+      // Generate
+      const result = await generateTemplates({
+        moduleId: 'test-module',
+        modulePath: TEST_MODULE_DIR,
+        outputPath: TEST_OUTPUT_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        // Should include terraform template + inventory files (hosts.ini, host_vars, group_vars)
+        expect(result.files.length).toBeGreaterThanOrEqual(1);
+
+        const terraformFile = result.files.find((f) => f.path === 'terraform/main.tf');
+        expect(terraformFile).toBeDefined();
+        expect(terraformFile?.content).toContain('hostname = "test"');
+        expect(terraformFile?.content).toContain('ip = "192.168.0.50/24"');
+        expect(terraformFile?.content).toContain('gateway = "192.168.0.10"');
+
+        // Verify file was written
+        expect(existsSync(join(TEST_OUTPUT_DIR, 'terraform', 'main.tf'))).toBe(true);
+      }
+    });
+
+    test('should handle both terraform and ansible templates', async () => {
+      db.$client.run(
+        `INSERT INTO modules (id, name, version, source_path, manifest_data) VALUES ('test-module', 'Test', '1.0.0', '/path', '{}')`,
+      );
+      db.insert(moduleConfigs)
+        .values({ moduleId: 'test-module', key: 'name', value: 'test' })
+        .run();
+
+      // Create templates
+      await mkdir(join(TEST_MODULE_DIR, 'terraform'), { recursive: true });
+      await mkdir(join(TEST_MODULE_DIR, 'ansible'), { recursive: true });
+      await writeFile(join(TEST_MODULE_DIR, 'terraform', 'main.tf.tpl'), 'name = "$self:name"');
+      await writeFile(join(TEST_MODULE_DIR, 'ansible', 'playbook.yml.tpl'), 'name: $self:name');
+
+      const result = await generateTemplates({
+        moduleId: 'test-module',
+        modulePath: TEST_MODULE_DIR,
+        outputPath: TEST_OUTPUT_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.files).toHaveLength(2);
+        expect(result.files.some((f) => f.path.includes('terraform'))).toBe(true);
+        expect(result.files.some((f) => f.path.includes('ansible'))).toBe(true);
+      }
+    });
+
+    test('should fail if module path does not exist', async () => {
+      const result = await generateTemplates({
+        moduleId: 'test-module',
+        modulePath: './nonexistent',
+        outputPath: TEST_OUTPUT_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('does not exist');
+      }
+    });
+
+    test('should succeed with empty files for config-only modules', async () => {
+      db.$client.run(
+        `INSERT INTO modules (id, name, version, source_path, manifest_data) VALUES ('test-module', 'Test', '1.0.0', '/path', '{}')`,
+      );
+
+      const result = await generateTemplates({
+        moduleId: 'test-module',
+        modulePath: TEST_MODULE_DIR,
+        outputPath: TEST_OUTPUT_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.files).toEqual([]);
+      }
+    });
+
+    test('should fail if variable resolution fails', async () => {
+      db.$client.run(
+        `INSERT INTO modules (id, name, version, source_path, manifest_data) VALUES ('test-module', 'Test', '1.0.0', '/path', '{}')`,
+      );
+
+      await mkdir(join(TEST_MODULE_DIR, 'terraform'), { recursive: true });
+      await writeFile(
+        join(TEST_MODULE_DIR, 'terraform', 'main.tf.tpl'),
+        'missing = "$self:missing_var"',
+      );
+
+      const result = await generateTemplates({
+        moduleId: 'test-module',
+        modulePath: TEST_MODULE_DIR,
+        outputPath: TEST_OUTPUT_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('Failed to resolve variables');
+        expect(result.error).toContain('missing_var');
+      }
+    });
+
+    test('should resolve capability variables', async () => {
+      db.$client.run(
+        `INSERT INTO modules (id, name, version, source_path, manifest_data) VALUES ('test-module', 'Test', '1.0.0', '/path', '{}')`,
+      );
+      db.$client.run(
+        `INSERT INTO modules (id, name, version, source_path, manifest_data) VALUES ('dns-module', 'DNS', '1.0.0', '/path', '{}')`,
+      );
+
+      db.insert(capabilities)
+        .values({
+          moduleId: 'dns-module',
+          capabilityName: 'dns_external',
+          version: '1.0.0',
+          data: { nameserver: 'ns1.example.com' },
+        })
+        .run();
+
+      await mkdir(join(TEST_MODULE_DIR, 'terraform'), { recursive: true });
+      await writeFile(
+        join(TEST_MODULE_DIR, 'terraform', 'main.tf.tpl'),
+        'dns = "$capability:dns_external.nameserver"',
+      );
+
+      const result = await generateTemplates({
+        moduleId: 'test-module',
+        modulePath: TEST_MODULE_DIR,
+        outputPath: TEST_OUTPUT_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.files[0]?.content).toContain('dns = "ns1.example.com"');
+      }
+    });
+
+    test('should skip terraform generation for machine infrastructure', async () => {
+      // Setup module with machine infrastructure
+      const manifestWithResources = JSON.stringify({
+        provides: { capabilities: [] },
+        requires: {
+          capabilities: [],
+          machine: {
+            cpu: 1,
+            memory: 1024,
+            disk: 10,
+            zone: 'internal',
+          },
+        },
+      });
+      db.$client.run(
+        `INSERT INTO modules (id, name, version, source_path, manifest_data) VALUES ('test-module', 'Test', '1.0.0', '/path', ?)`,
+        [manifestWithResources],
+      );
+      db.insert(moduleConfigs)
+        .values({ moduleId: 'test-module', key: 'name', value: 'test' })
+        .run();
+
+      // Insert dummy machine (required for foreign key)
+      db.$client.run(
+        `INSERT INTO machines (id, hostname, zone, ip_address, ssh_user, ssh_key_encrypted, hardware) VALUES ('machine-1', 'test-machine', 'internal', '192.168.0.100', 'root', 'encrypted', '{}')`,
+      );
+
+      // Insert infrastructure selection for machine
+      db.$client.run(
+        `INSERT INTO module_infrastructure (id, module_id, infrastructure_type, machine_id) VALUES ('test-infra-1', 'test-module', 'machine', 'machine-1')`,
+      );
+
+      // Create both terraform and ansible templates
+      await mkdir(join(TEST_MODULE_DIR, 'terraform'), { recursive: true });
+      await mkdir(join(TEST_MODULE_DIR, 'ansible'), { recursive: true });
+      await writeFile(join(TEST_MODULE_DIR, 'terraform', 'main.tf.tpl'), 'name = "$self:name"');
+      await writeFile(join(TEST_MODULE_DIR, 'ansible', 'playbook.yml.tpl'), 'name: $self:name');
+
+      const result = await generateTemplates({
+        moduleId: 'test-module',
+        modulePath: TEST_MODULE_DIR,
+        outputPath: TEST_OUTPUT_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        // Debug: print generated files
+        console.log(
+          'Generated files:',
+          result.files.map((f) => f.path),
+        );
+
+        // Should have ansible files, but NO terraform files
+        expect(result.files.length).toBeGreaterThanOrEqual(1);
+        const terraformFiles = result.files.filter((f) => f.path.includes('terraform'));
+        expect(terraformFiles).toEqual([]);
+        expect(result.files.some((f) => f.path.includes('ansible'))).toBe(true);
+
+        // Verify terraform file was NOT written
+        expect(existsSync(join(TEST_OUTPUT_DIR, 'terraform', 'main.tf'))).toBe(false);
+        // Verify ansible file WAS written
+        expect(existsSync(join(TEST_OUTPUT_DIR, 'ansible', 'playbook.yml'))).toBe(true);
+
+        expect(existsSync(join(TEST_OUTPUT_DIR, 'ansible', 'inventory', 'hosts.ini'))).toBe(true);
+        const hostsIni = await readFile(
+          join(TEST_OUTPUT_DIR, 'ansible', 'inventory', 'hosts.ini'),
+          'utf-8',
+        );
+        expect(hostsIni).toContain('ansible_host=192.168.0.100'); // Machine IP
+        expect(hostsIni).toContain('ansible_user=root'); // Machine SSH user
+        expect(hostsIni).toContain('ansible_ssh_private_key_file='); // SSH key path
+        expect(hostsIni).toContain('/tmp/ansible-keys/machine-machine-1.key'); // Key filename
+      }
+    });
+
+    test('should generate terraform for container service infrastructure', async () => {
+      // Setup system config for IPAM (internal zone network)
+      db.$client.run(
+        `INSERT INTO system_config (key, value) VALUES ('network.internal.subnet', '192.168.100.0/24')`,
+      );
+      db.$client.run(
+        `INSERT INTO system_config (key, value) VALUES ('network.internal.gateway', '192.168.100.1')`,
+      );
+      db.$client.run(
+        `INSERT INTO system_config (key, value) VALUES ('network.internal.vlan', '100')`,
+      );
+
+      // Setup module with container service infrastructure
+      const manifestWithResources = JSON.stringify({
+        provides: { capabilities: [] },
+        requires: { capabilities: [] },
+        resources: {
+          machine: {
+            cpu: 1,
+            memory: 1024,
+            disk: 10,
+            zone: 'internal',
+          },
+        },
+      });
+      db.$client.run(
+        `INSERT INTO modules (id, name, version, source_path, manifest_data) VALUES ('test-module', 'Test', '1.0.0', '/path', ?)`,
+        [manifestWithResources],
+      );
+      db.insert(moduleConfigs)
+        .values({ moduleId: 'test-module', key: 'name', value: 'test' })
+        .run();
+
+      // Insert dummy container service (required for foreign key)
+      db.$client.run(
+        `INSERT INTO container_services (id, service_id, name, provider_name, zones, api_credentials_encrypted, provider_config, verified, created_at, updated_at) VALUES ('service-1', 'test-service', 'test-service', 'proxmox', '["app"]', '{}', '{"default_target_node":"pve","lxc_template":"local:vztmpl/ubuntu.tar.zst","storage":"local-lvm"}', 1, ${Date.now()}, ${Date.now()})`,
+      );
+
+      // Insert infrastructure selection for container service
+      db.$client.run(
+        `INSERT INTO module_infrastructure (id, module_id, infrastructure_type, service_id) VALUES ('test-infra-1', 'test-module', 'container_service', 'service-1')`,
+      );
+
+      // Create both terraform and ansible templates
+      await mkdir(join(TEST_MODULE_DIR, 'terraform'), { recursive: true });
+      await mkdir(join(TEST_MODULE_DIR, 'ansible'), { recursive: true });
+      await writeFile(join(TEST_MODULE_DIR, 'terraform', 'main.tf.tpl'), 'name = "$self:name"');
+      await writeFile(join(TEST_MODULE_DIR, 'ansible', 'playbook.yml.tpl'), 'name: $self:name');
+
+      const result = await generateTemplates({
+        moduleId: 'test-module',
+        modulePath: TEST_MODULE_DIR,
+        outputPath: TEST_OUTPUT_DIR,
+        db,
+      });
+
+      if (!result.success) {
+        console.error('Generation failed:', result.error);
+        if (result.details) console.error('Details:', result.details);
+      }
+      expect(result.success).toBe(true);
+      if (result.success) {
+        // Should have both terraform and ansible files
+        expect(result.files.length).toBe(2);
+        expect(result.files.some((f) => f.path.includes('terraform'))).toBe(true);
+        expect(result.files.some((f) => f.path.includes('ansible'))).toBe(true);
+
+        // Verify both files were written
+        expect(existsSync(join(TEST_OUTPUT_DIR, 'terraform', 'main.tf'))).toBe(true);
+        expect(existsSync(join(TEST_OUTPUT_DIR, 'ansible', 'playbook.yml'))).toBe(true);
+      }
+    });
+  });
+});