@celilo/cli 0.3.16 → 0.3.17

package/src/system/prereqs.test.ts

@@ -0,0 +1,374 @@
+/**
+ * Tests for the prerequisite-detection module.
+ *
+ * Coverage:
+ *   - Version regex parses real-world output for each tool in the table
+ *   - compareVersions handles MAJOR.MINOR.PATCH (and MAJOR.MINOR) edge cases
+ *   - getInstallHint returns the right string per tool/pm combination,
+ *     including fallback paths for tools without a native package
+ *   - checkPrerequisite returns the documented shape for present + missing
+ *     binaries, and exercises the "binary present but version unparseable"
+ *     edge case
+ *   - PREREQUISITES table is internally consistent (no duplicate names,
+ *     every entry has the fields the type requires)
+ */
+
+import { describe, expect, test } from 'bun:test';
+import {
+  PREREQUISITES,
+  checkPrerequisite,
+  compareVersions,
+  detectPackageManager,
+  failingPrerequisites,
+  getInstallHint,
+} from './prereqs';
+
+// ── PREREQUISITES table consistency ───────────────────────────────────
+
+describe('PREREQUISITES table', () => {
+  test('has no duplicate tool names', () => {
+    const names = PREREQUISITES.map((p) => p.name);
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  test('every entry has the required fields', () => {
+    for (const spec of PREREQUISITES) {
+      expect(spec.name).toBeTruthy();
+      expect(spec.description).toBeTruthy();
+      expect(spec.versionFlag).toBeTruthy();
+      expect(spec.versionRegex).toBeInstanceOf(RegExp);
+      // minVersion may be null; just check the property exists
+      expect('minVersion' in spec).toBe(true);
+    }
+  });
+
+  test('contains the tools the design doc requires', () => {
+    const names = PREREQUISITES.map((p) => p.name);
+    expect(names).toContain('bun');
+    expect(names).toContain('ansible');
+    expect(names).toContain('ansible-galaxy');
+    expect(names).toContain('terraform');
+    expect(names).toContain('ssh');
+    expect(names).toContain('git');
+    expect(names).toContain('curl');
+    expect(names).toContain('unzip');
+  });
+});
+
+// ── Version regex per tool ────────────────────────────────────────────
+
+describe('version regex', () => {
+  function probe(toolName: string, sampleOutput: string): string | null {
+    const spec = PREREQUISITES.find((p) => p.name === toolName);
+    if (!spec) throw new Error(`No spec for ${toolName}`);
+    const match = sampleOutput.match(spec.versionRegex);
+    return match?.[1] ?? null;
+  }
+
+  test('bun --version', () => {
+    expect(probe('bun', '1.3.3')).toBe('1.3.3');
+    expect(probe('bun', '1.3.3\n')).toBe('1.3.3');
+  });
+
+  test('ansible --version (modern, "core 2.16.3")', () => {
+    expect(
+      probe(
+        'ansible',
+        'ansible [core 2.16.3]\n  config file = None\n  configured module search path = ...',
+      ),
+    ).toBe('2.16.3');
+  });
+
+  test('ansible --version (legacy, "ansible 2.9.27")', () => {
+    expect(probe('ansible', 'ansible 2.9.27\n  config file = None')).toBe('2.9.27');
+  });
+
+  test('ansible-galaxy --version', () => {
+    expect(probe('ansible-galaxy', 'ansible-galaxy [core 2.16.3]\n  python version = 3.11.4')).toBe(
+      '2.16.3',
+    );
+  });
+
+  test('terraform version', () => {
+    expect(
+      probe(
+        'terraform',
+        'Terraform v1.6.6\non darwin_arm64\n\nYour version of Terraform is out of date!',
+      ),
+    ).toBe('1.6.6');
+  });
+
+  test('ssh -V (writes to stderr)', () => {
+    expect(probe('ssh', 'OpenSSH_9.6p1, LibreSSL 3.3.6')).toBe('9.6');
+    // Older OpenSSH formats with space rather than underscore
+    expect(probe('ssh', 'OpenSSH 8.2p1 Ubuntu-4ubuntu0.11')).toBe('8.2');
+  });
+
+  test('git --version', () => {
+    expect(probe('git', 'git version 2.45.2')).toBe('2.45.2');
+  });
+
+  test('curl --version (multi-line, version is on first line)', () => {
+    expect(
+      probe(
+        'curl',
+        'curl 8.6.0 (x86_64-pc-linux-gnu) libcurl/8.6.0 OpenSSL/3.1.4\nRelease-Date: 2024-01-31',
+      ),
+    ).toBe('8.6.0');
+  });
+
+  test('unzip -v', () => {
+    expect(
+      probe(
+        'unzip',
+        'UnZip 6.00 of 20 April 2009, by Debian. Original by Info-ZIP.\n\nLatest sources...',
+      ),
+    ).toBe('6.00');
+  });
+
+  test('returns null when output is unrecognized', () => {
+    const spec = PREREQUISITES.find((p) => p.name === 'terraform');
+    expect(spec?.versionRegex.exec('completely unrelated output')?.[1]).toBeUndefined();
+  });
+});
+
+// ── compareVersions ───────────────────────────────────────────────────
+
+describe('compareVersions', () => {
+  test('equal triples → 0', () => {
+    expect(compareVersions('2.16.3', '2.16.3')).toBe(0);
+  });
+
+  test('strictly less → -1', () => {
+    expect(compareVersions('2.15.0', '2.16.0')).toBe(-1);
+    expect(compareVersions('2.16.2', '2.16.3')).toBe(-1);
+    expect(compareVersions('1.6.5', '2.0.0')).toBe(-1);
+  });
+
+  test('strictly greater → 1', () => {
+    expect(compareVersions('2.17.0', '2.16.0')).toBe(1);
+    expect(compareVersions('2.16.4', '2.16.3')).toBe(1);
+    expect(compareVersions('3.0.0', '2.16.99')).toBe(1);
+  });
+
+  test('handles missing components (treats as 0)', () => {
+    expect(compareVersions('2.16', '2.16.0')).toBe(0);
+    expect(compareVersions('2.16', '2.16.1')).toBe(-1);
+    expect(compareVersions('2.16.1', '2.16')).toBe(1);
+  });
+
+  test('handles non-numeric segments by treating as 0', () => {
+    // We don't try to parse pre-release tags. "2.16.3-rc1" and "2.16.3"
+    // compare equal — that's intentional. Ansible's pre-releases are
+    // rare in operator-installed boxes.
+    expect(compareVersions('2.16.3-rc1', '2.16.3')).toBe(0);
+  });
+
+  test('realistic ansible version comparison (2.16.3 satisfies 2.15.0 minimum)', () => {
+    expect(compareVersions('2.16.3', '2.15.0')).toBe(1);
+  });
+
+  test('realistic terraform version comparison (1.5.7 below 1.6.0 minimum)', () => {
+    expect(compareVersions('1.5.7', '1.6.0')).toBe(-1);
+  });
+});
+
+// ── getInstallHint ────────────────────────────────────────────────────
+
+describe('getInstallHint', () => {
+  test('apt: standard tools resolve to "sudo apt-get install <pkg>"', () => {
+    expect(getInstallHint('ansible', 'apt')).toBe('sudo apt-get install ansible');
+    expect(getInstallHint('git', 'apt')).toBe('sudo apt-get install git');
+    expect(getInstallHint('curl', 'apt')).toBe('sudo apt-get install curl');
+    expect(getInstallHint('unzip', 'apt')).toBe('sudo apt-get install unzip');
+  });
+
+  test('apt: ssh maps to openssh-client (Debian package name differs)', () => {
+    expect(getInstallHint('ssh', 'apt')).toBe('sudo apt-get install openssh-client');
+  });
+
+  test('apt: terraform falls through to HashiCorp docs link', () => {
+    expect(getInstallHint('terraform', 'apt')).toBe(
+      'See https://developer.hashicorp.com/terraform/install',
+    );
+  });
+
+  test('apt: bun has no native package — falls through to docs', () => {
+    expect(getInstallHint('bun', 'apt')).toBe('See https://bun.sh/install');
+  });
+
+  test('apt: ansible-galaxy points the operator at ansible', () => {
+    expect(getInstallHint('ansible-galaxy', 'apt')).toContain('install ansible');
+  });
+
+  test('brew: tools available via brew', () => {
+    expect(getInstallHint('ansible', 'brew')).toBe('brew install ansible');
+    expect(getInstallHint('terraform', 'brew')).toBe('brew install terraform');
+    expect(getInstallHint('bun', 'brew')).toBe('brew install oven-sh/bun/bun');
+  });
+
+  test('brew: ssh/curl/unzip fall through (built into macOS)', () => {
+    expect(getInstallHint('ssh', 'brew')).toBe("Install 'ssh' via your package manager");
+    expect(getInstallHint('curl', 'brew')).toBe("Install 'curl' via your package manager");
+    expect(getInstallHint('unzip', 'brew')).toBe("Install 'unzip' via your package manager");
+  });
+
+  test('pacman: terraform IS available via pacman (unlike apt)', () => {
+    expect(getInstallHint('terraform', 'pacman')).toBe('sudo pacman -S terraform');
+  });
+
+  test('apk: ssh maps to openssh-client', () => {
+    expect(getInstallHint('ssh', 'apk')).toBe('sudo apk add openssh-client');
+  });
+
+  test('none: unrecognized package manager falls back to generic guidance', () => {
+    expect(getInstallHint('ansible', 'none')).toBe("Install 'ansible' via your package manager");
+    // bun and terraform have docs links that work regardless of pm
+    expect(getInstallHint('bun', 'none')).toBe('See https://bun.sh/install');
+    expect(getInstallHint('terraform', 'none')).toBe(
+      'See https://developer.hashicorp.com/terraform/install',
+    );
+  });
+
+  test('unknown tool name: generic fallback', () => {
+    expect(getInstallHint('totally-fictional-tool', 'apt')).toBe(
+      "Install 'totally-fictional-tool' via your package manager",
+    );
+  });
+});
+
+// ── checkPrerequisite ─────────────────────────────────────────────────
+
+describe('checkPrerequisite', () => {
+  test('present binary returns present:true with a path', () => {
+    // bun is the celilo runtime; if these tests are running, bun is there.
+    const spec = PREREQUISITES.find((p) => p.name === 'bun');
+    if (!spec) throw new Error('bun spec missing');
+    const result = checkPrerequisite(spec);
+    expect(result.present).toBe(true);
+    expect(result.binaryPath).toBeTruthy();
+    expect(result.version).toMatch(/^\d+\.\d+\.\d+$/);
+    expect(result.meetsMinimum).toBe(true);
+  });
+
+  test('missing binary returns present:false with installHint populated', () => {
+    const spec = {
+      name: 'definitely-not-installed-aaaaaa',
+      description: 'fictional',
+      versionFlag: '--version',
+      versionRegex: /(\d+\.\d+\.\d+)/,
+      minVersion: null,
+    };
+    const result = checkPrerequisite(spec);
+    expect(result.present).toBe(false);
+    expect(result.binaryPath).toBeNull();
+    expect(result.version).toBeNull();
+    expect(result.meetsMinimum).toBe(false);
+    expect(result.installHint).toBeTruthy(); // generic fallback at minimum
+  });
+
+  test('present binary with minVersion → meetsMinimum reflects comparison', () => {
+    // Synthesize a spec that demands an impossibly-high bun version
+    const spec = {
+      name: 'bun',
+      description: 'celilo runtime',
+      versionFlag: '--version',
+      versionRegex: /(\d+\.\d+\.\d+)/,
+      minVersion: '999.0.0',
+    };
+    const result = checkPrerequisite(spec);
+    expect(result.present).toBe(true);
+    expect(result.version).toMatch(/^\d+\.\d+\.\d+$/);
+    expect(result.meetsMinimum).toBe(false);
+  });
+
+  test('present binary with parse-fail leaves version null', () => {
+    // Force a regex that won't match bun's version output
+    const spec = {
+      name: 'bun',
+      description: 'celilo runtime',
+      versionFlag: '--version',
+      versionRegex: /THIS_WILL_NEVER_MATCH_(\w+)/,
+      minVersion: null,
+    };
+    const result = checkPrerequisite(spec);
+    expect(result.present).toBe(true);
+    expect(result.version).toBeNull();
+    // No minimum, parse-fail still passes
+    expect(result.meetsMinimum).toBe(true);
+  });
+
+  test('present binary with parse-fail AND minimum → meetsMinimum:false', () => {
+    const spec = {
+      name: 'bun',
+      description: 'celilo runtime',
+      versionFlag: '--version',
+      versionRegex: /THIS_WILL_NEVER_MATCH_(\w+)/,
+      minVersion: '1.0.0',
+    };
+    const result = checkPrerequisite(spec);
+    expect(result.present).toBe(true);
+    expect(result.version).toBeNull();
+    expect(result.meetsMinimum).toBe(false);
+  });
+});
+
+// ── failingPrerequisites ──────────────────────────────────────────────
+
+describe('failingPrerequisites', () => {
+  test('returns only entries that are missing or below-minimum', () => {
+    const checks = [
+      {
+        name: 'a',
+        description: '',
+        present: true,
+        binaryPath: '/bin/a',
+        version: '1.0.0',
+        meetsMinimum: true,
+        installHint: '',
+      },
+      {
+        name: 'b',
+        description: '',
+        present: false,
+        binaryPath: null,
+        version: null,
+        meetsMinimum: false,
+        installHint: '',
+      },
+      {
+        name: 'c',
+        description: '',
+        present: true,
+        binaryPath: '/bin/c',
+        version: '0.5.0',
+        meetsMinimum: false,
+        installHint: '',
+      },
+      {
+        name: 'd',
+        description: '',
+        present: true,
+        binaryPath: '/bin/d',
+        version: null,
+        meetsMinimum: true,
+        installHint: '',
+      },
+    ];
+    const failing = failingPrerequisites(checks);
+    expect(failing.map((c) => c.name)).toEqual(['b', 'c']);
+  });
+
+  test('empty input → empty result', () => {
+    expect(failingPrerequisites([])).toEqual([]);
+  });
+});
+
+// ── detectPackageManager (smoke test only) ───────────────────────────
+
+describe('detectPackageManager', () => {
+  test('returns one of the known PackageManager values', () => {
+    const pm = detectPackageManager();
+    expect(['apt', 'dnf', 'yum', 'pacman', 'apk', 'brew', 'none']).toContain(pm);
+  });
+});