@celilo/cli 0.1.0

package/src/variables/resolver.test.ts

@@ -0,0 +1,458 @@
+import { describe, expect, test } from 'bun:test';
+import { resolveTemplate, resolveVariable } from './resolver';
+import type { ResolutionContext, VariableReference } from './types';
+
+// Mock database for tests (capability secrets not tested here - see integration tests)
+const mockDb = {
+  $client: {
+    prepare: (_query: string) => ({
+      get: () => {
+        // Return null for capability/module lookups (non-secret in unit tests)
+        // This makes isCapabilityFieldSecret() return false
+        return null;
+      },
+      all: () => [],
+      run: () => ({ changes: 0 }),
+    }),
+  },
+  select: () => ({
+    from: () => ({
+      where: () => ({
+        get: () => null,
+        all: () => [],
+      }),
+    }),
+  }),
+  // biome-ignore lint/suspicious/noExplicitAny: mock database for testing, full type not needed
+} as any;
+
+const createContext = (overrides?: Partial<ResolutionContext>): ResolutionContext => ({
+  moduleId: 'test-module',
+  selfConfig: {
+    container_ip: '192.168.0.50',
+    hostname: 'homebridge',
+    cores: '2',
+    'resources.machine.cpu': '2',
+    'resources.machine.memory': '2048',
+    'resources.machine.disk': '20',
+    'resources.machine.zone': 'app',
+    // Auto-derived inventory variables
+    'inventory.ansible_host': '192.168.0.50',
+    'inventory.ansible_user': 'root',
+    'inventory.groups': 'homebridge',
+  },
+  systemConfig: {
+    'management.ip': '192.168.0.10',
+    'network.domain': 'homelab.local',
+  },
+  systemSecrets: {},
+  secrets: {
+    api_key: 'secret123',
+    db_password: 'pass456',
+  },
+  capabilities: {
+    dns_external: {
+      nameserver: 'ns1.example.com',
+      zone: 'example.com',
+      config: {
+        port: 53,
+      },
+    },
+    idp: {
+      issuer: 'https://auth.example.com',
+    },
+  },
+  ...overrides,
+});
+
+describe('resolveVariable', () => {
+  test('should resolve self variable', async () => {
+    const variable: VariableReference = {
+      type: 'self',
+      path: 'container_ip',
+      raw: '$self:container_ip',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.value).toBe('192.168.0.50');
+    }
+  });
+
+  test('should resolve system variable', async () => {
+    const variable: VariableReference = {
+      type: 'system',
+      path: 'management.ip',
+      raw: '$system:management.ip',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.value).toBe('192.168.0.10');
+    }
+  });
+
+  test('should resolve secret variable', async () => {
+    const variable: VariableReference = {
+      type: 'secret',
+      path: 'api_key',
+      raw: '$secret:api_key',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.value).toBe('secret123');
+    }
+  });
+
+  test('should resolve capability variable', async () => {
+    const variable: VariableReference = {
+      type: 'capability',
+      path: 'dns_external.nameserver',
+      raw: '$capability:dns_external.nameserver',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.value).toBe('ns1.example.com');
+    }
+  });
+
+  test('should resolve nested capability variable', async () => {
+    const variable: VariableReference = {
+      type: 'capability',
+      path: 'dns_external.config.port',
+      raw: '$capability:dns_external.config.port',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.value).toBe('53');
+    }
+  });
+
+  test('should return error for missing self variable', async () => {
+    const variable: VariableReference = {
+      type: 'self',
+      path: 'missing_var',
+      raw: '$self:missing_var',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain('not found in module configuration');
+    }
+  });
+
+  test('should return error for missing system variable', async () => {
+    const variable: VariableReference = {
+      type: 'system',
+      path: 'missing.var',
+      raw: '$system:missing.var',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain('not found');
+    }
+  });
+
+  test('should return error for missing secret', async () => {
+    const variable: VariableReference = {
+      type: 'secret',
+      path: 'missing_secret',
+      raw: '$secret:missing_secret',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain('not found');
+    }
+  });
+
+  test('should return error for missing capability', async () => {
+    const variable: VariableReference = {
+      type: 'capability',
+      path: 'missing_capability.value',
+      raw: '$capability:missing_capability.value',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain('not found or not registered');
+    }
+  });
+
+  test('should return error for capability variable without path', async () => {
+    const variable: VariableReference = {
+      type: 'capability',
+      path: 'dns_external',
+      raw: '$capability:dns_external',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain('must specify data path');
+    }
+  });
+
+  test('should return error for missing capability data path', async () => {
+    const variable: VariableReference = {
+      type: 'capability',
+      path: 'dns_external.missing_field',
+      raw: '$capability:dns_external.missing_field',
+    };
+    const context = createContext();
+
+    const result = await resolveVariable(variable, context, mockDb);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain('not found in');
+    }
+  });
+});
+
+describe('resolveTemplate', () => {
+  test('should resolve template with single variable', async () => {
+    const template = 'ip: $self:container_ip';
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toBe('ip: 192.168.0.50');
+    }
+  });
+
+  test('should resolve template with multiple variables', async () => {
+    const template = `
+hostname: $self:hostname
+ip: $self:container_ip
+domain: $system:network.domain
+`;
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toContain('hostname: homebridge');
+      expect(result.content).toContain('ip: 192.168.0.50');
+      expect(result.content).toContain('domain: homelab.local');
+    }
+  });
+
+  test('should resolve template with mixed variable types', async () => {
+    const template = `
+container_ip: $self:container_ip
+management_ip: $system:management.ip
+dns_server: $capability:dns_external.nameserver
+api_key: $secret:api_key
+`;
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toContain('container_ip: 192.168.0.50');
+      expect(result.content).toContain('management_ip: 192.168.0.10');
+      expect(result.content).toContain('dns_server: ns1.example.com');
+      expect(result.content).toContain('api_key: secret123');
+    }
+  });
+
+  test('should resolve VM resource variables from manifest', async () => {
+    const template = `
+resource "proxmox_lxc" "grafana" {
+  cores  = $self:resources.machine.cpu
+  memory = $self:resources.machine.memory
+  rootfs {
+    size    = "$self:resources.machine.disk"
+    storage = "$self:resources.machine.zone"
+  }
+}
+`;
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toContain('cores  = 2');
+      expect(result.content).toContain('memory = 2048');
+      expect(result.content).toContain('size    = "20"');
+      expect(result.content).toContain('storage = "app"');
+    }
+  });
+
+  test('should resolve template with variables in complex structure', async () => {
+    const template = `
+resource "proxmox_lxc" "container" {
+  hostname = "$self:hostname"
+  cores    = $self:cores
+  network {
+    ip = "$self:container_ip/24"
+    gateway = "$system:management.ip"
+  }
+  environment = {
+    DNS_SERVER = "$capability:dns_external.nameserver"
+    API_KEY = "$secret:api_key"
+  }
+}
+`;
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toContain('hostname = "homebridge"');
+      expect(result.content).toContain('cores    = 2');
+      expect(result.content).toContain('ip = "192.168.0.50/24"');
+      expect(result.content).toContain('gateway = "192.168.0.10"');
+      expect(result.content).toContain('DNS_SERVER = "ns1.example.com"');
+      expect(result.content).toContain('API_KEY = "secret123"');
+    }
+  });
+
+  test('should return template unchanged if no variables', async () => {
+    const template = 'no variables here';
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toBe(template);
+    }
+  });
+
+  test('should return errors for missing variables', async () => {
+    const template = `
+ip: $self:container_ip
+missing: $self:missing_var
+another_missing: $secret:missing_secret
+`;
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.errors).toHaveLength(2);
+      expect(result.errors[0]?.variable).toBe('$self:missing_var');
+      expect(result.errors[1]?.variable).toBe('$secret:missing_secret');
+    }
+  });
+
+  test('should handle repeated variables', async () => {
+    const template = `
+ip1: $self:container_ip
+ip2: $self:container_ip
+ip3: $self:container_ip
+`;
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toContain('ip1: 192.168.0.50');
+      expect(result.content).toContain('ip2: 192.168.0.50');
+      expect(result.content).toContain('ip3: 192.168.0.50');
+      expect(result.content).not.toContain('$self:container_ip');
+    }
+  });
+
+  test('should resolve auto-derived inventory variables', async () => {
+    const template = `
+[all]
+$self:hostname ansible_host=$self:inventory.ansible_host ansible_user=$self:inventory.ansible_user
+
+[homebridge]
+$self:hostname
+`;
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toContain('homebridge ansible_host=192.168.0.50 ansible_user=root');
+      expect(result.content).toContain('[homebridge]');
+    }
+  });
+
+  test('should use stripped IP in ansible_host', async () => {
+    const template = 'ansible_host: $self:inventory.ansible_host';
+    const context = createContext({
+      selfConfig: {
+        container_ip: '10.0.10.10/24',
+        'inventory.ansible_host': '10.0.10.10', // Auto-derived (CIDR stripped)
+        'inventory.ansible_user': 'root',
+        'inventory.groups': 'test',
+      },
+    });
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toContain('ansible_host: 10.0.10.10');
+      expect(result.content).not.toContain('/24');
+    }
+  });
+
+  test('should resolve inventory.groups from module ID', async () => {
+    const template = `
+---
+all:
+  children:
+    $self:inventory.groups:
+      hosts:
+        $self:hostname:
+`;
+    const context = createContext();
+
+    const result = await resolveTemplate(template, context, mockDb);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.content).toContain('homebridge:');
+      expect(result.content).toContain('hosts:');
+    }
+  });
+});