@celilo/cli 0.1.0

package/src/test-utils/completion-harness.ts

@@ -0,0 +1,82 @@
+/**
+ * Completion Test Harness
+ *
+ * Provides utilities for testing CLI completion by invoking --get-completions directly.
+ * This bypasses shell complexity and tests the completion function itself.
+ */
+
+import { expect } from 'bun:test';
+import { runCli } from './cli';
+
+/**
+ * Test harness for CLI completion
+ */
+export class CompletionHarness {
+  constructor(private cli: string) {}
+
+  /**
+   * Get completions for a given set of words
+   *
+   * @param words - The command words (e.g., ['celilo', 'service'])
+   * @param partial - If true, complete the last word (for prefix matching). If false (default), complete after all words
+   * @returns Array of completion suggestions
+   */
+  async getCompletions(words: string[], partial = false): Promise<string[]> {
+    // If partial=true, we're completing the last word itself (prefix matching)
+    // If partial=false, we're completing the next word after all current words
+    const currentIndex = partial && words.length > 0 ? words.length - 1 : words.length;
+    try {
+      const result = runCli(this.cli, `--get-completions ${words.join(' ')} ${currentIndex}`);
+
+      // Parse completion output (one per line)
+      return result.split('\n').filter(Boolean);
+    } catch (_error) {
+      // Completion errors return empty array
+      return [];
+    }
+  }
+
+  /**
+   * Assert that completions include all expected values
+   *
+   * @param words - The command words
+   * @param expected - Expected completion values
+   */
+  async expectCompletionsInclude(words: string[], expected: string[]): Promise<void> {
+    const actual = await this.getCompletions(words);
+    for (const exp of expected) {
+      expect(actual).toContain(exp);
+    }
+  }
+
+  /**
+   * Assert that completions exactly match expected values (order-independent)
+   *
+   * @param words - The command words
+   * @param expected - Expected completion values
+   */
+  async expectCompletionsExact(words: string[], expected: string[]): Promise<void> {
+    const actual = await this.getCompletions(words);
+    expect(actual.sort()).toEqual(expected.sort());
+  }
+
+  /**
+   * Assert that no completions are returned
+   *
+   * @param words - The command words
+   */
+  async expectNoCompletions(words: string[]): Promise<void> {
+    const actual = await this.getCompletions(words);
+    expect(actual).toEqual([]);
+  }
+
+  /**
+   * Assert that at least one completion is returned
+   *
+   * @param words - The command words
+   */
+  async expectSomeCompletions(words: string[]): Promise<void> {
+    const actual = await this.getCompletions(words);
+    expect(actual.length).toBeGreaterThan(0);
+  }
+}

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

@@ -0,0 +1,182 @@
+import { describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { modules } from '../db/schema';
+import {
+  cleanupMultipleTestDatabases,
+  cleanupTestDatabase,
+  setupMultipleTestDatabases,
+  setupTestDatabase,
+  setupTestDatabaseFile,
+} from './database';
+
+describe('Database Test Utilities', () => {
+  describe('setupTestDatabase', () => {
+    test('creates in-memory database', async () => {
+      const db = await setupTestDatabase();
+      expect(db).toBeDefined();
+      await cleanupTestDatabase(db);
+    });
+
+    test('applies migrations', async () => {
+      const db = await setupTestDatabase();
+
+      // Should be able to query modules table
+      const result = await db.select().from(modules);
+      expect(result).toEqual([]);
+
+      await cleanupTestDatabase(db);
+    });
+
+    test('creates isolated databases', async () => {
+      const db1 = await setupTestDatabase();
+      const db2 = await setupTestDatabase();
+
+      // Insert into db1
+      await db1.insert(modules).values({
+        id: 'test-module',
+        name: 'Test Module',
+        version: '1.0.0',
+        state: 'IMPORTED',
+        manifestData: {},
+        sourcePath: '/tmp/test',
+        importedAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      // db2 should be empty
+      const result1 = await db1.select().from(modules);
+      const result2 = await db2.select().from(modules);
+
+      expect(result1).toHaveLength(1);
+      expect(result2).toHaveLength(0);
+
+      await cleanupTestDatabase(db1);
+      await cleanupTestDatabase(db2);
+    });
+  });
+
+  describe('setupTestDatabaseFile', () => {
+    test('creates file-based database', async () => {
+      const { db, path: dbPath, cleanup } = await setupTestDatabaseFile();
+
+      expect(db).toBeDefined();
+      expect(dbPath).toBeTruthy();
+      expect(existsSync(dbPath)).toBe(true);
+
+      await cleanup();
+    });
+
+    test('applies migrations', async () => {
+      const { db, cleanup } = await setupTestDatabaseFile();
+
+      // Should be able to query modules table
+      const result = await db.select().from(modules);
+      expect(result).toEqual([]);
+
+      await cleanup();
+    });
+
+    test('cleanup removes database file', async () => {
+      const { path: dbPath, cleanup } = await setupTestDatabaseFile();
+
+      expect(existsSync(dbPath)).toBe(true);
+
+      await cleanup();
+
+      // Database file should be gone
+      expect(existsSync(dbPath)).toBe(false);
+    });
+
+    test('database path can be used by CLI', async () => {
+      const { db, path: dbPath, cleanup } = await setupTestDatabaseFile();
+
+      // Path should be a valid file path
+      expect(dbPath).toMatch(/\/celilo-test-.*\/test\.db$/);
+
+      // Insert some data
+      await db.insert(modules).values({
+        id: 'cli-test',
+        name: 'CLI Test',
+        version: '1.0.0',
+        state: 'IMPORTED',
+        manifestData: {},
+        sourcePath: '/tmp/cli',
+        importedAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      // Data should be persisted (can be accessed by CLI)
+      const result = await db.select().from(modules);
+      expect(result).toHaveLength(1);
+
+      await cleanup();
+    });
+  });
+
+  describe('setupMultipleTestDatabases', () => {
+    test('creates multiple databases', async () => {
+      const databases = await setupMultipleTestDatabases(3);
+
+      expect(databases).toHaveLength(3);
+      expect(databases[0]).toBeDefined();
+      expect(databases[1]).toBeDefined();
+      expect(databases[2]).toBeDefined();
+
+      await cleanupMultipleTestDatabases(databases);
+    });
+
+    test('databases are isolated', async () => {
+      const [db1, db2, db3] = await setupMultipleTestDatabases(3);
+
+      // Insert different data in each
+      await db1.insert(modules).values({
+        id: 'module-1',
+        name: 'Module 1',
+        version: '1.0.0',
+        state: 'IMPORTED',
+        manifestData: {},
+        sourcePath: '/tmp/1',
+        importedAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      await db2.insert(modules).values({
+        id: 'module-2',
+        name: 'Module 2',
+        version: '1.0.0',
+        state: 'IMPORTED',
+        manifestData: {},
+        sourcePath: '/tmp/2',
+        importedAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      // Verify isolation
+      const result1 = await db1.select().from(modules);
+      const result2 = await db2.select().from(modules);
+      const result3 = await db3.select().from(modules);
+
+      expect(result1).toHaveLength(1);
+      expect(result1[0].id).toBe('module-1');
+
+      expect(result2).toHaveLength(1);
+      expect(result2[0].id).toBe('module-2');
+
+      expect(result3).toHaveLength(0);
+
+      await cleanupMultipleTestDatabases([db1, db2, db3]);
+    });
+  });
+
+  describe('cleanupTestDatabase', () => {
+    test('closes database', async () => {
+      const db = await setupTestDatabase();
+
+      await cleanupTestDatabase(db);
+
+      // Database should be closed (attempting to use it should fail)
+      // Note: Testing database closure is difficult with Drizzle's lazy query builders
+      expect(db).toBeDefined();
+    });
+  });
+});

package/src/test-utils/database.ts

@@ -0,0 +1,126 @@
+/**
+ * Database Test Utilities
+ *
+ * Provides functions for creating and managing isolated test databases.
+ * Each test gets its own database to prevent state leakage.
+ */
+
+import { Database } from 'bun:sqlite';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { drizzle } from 'drizzle-orm/bun-sqlite';
+import { migrate } from 'drizzle-orm/bun-sqlite/migrator';
+import { type DbClient, findMigrationsFolder } from '../db/client';
+import * as schema from '../db/schema';
+
+/**
+ * Create isolated test database (in-memory)
+ *
+ * Use for fast tests that don't need CLI interaction.
+ * Database is destroyed when closed.
+ *
+ * @returns In-memory SQLite database with migrations applied
+ *
+ * @example
+ * ```typescript
+ * const db = await setupTestDatabase();
+ * // Use db...
+ * await cleanupTestDatabase(db);
+ * ```
+ */
+export async function setupTestDatabase(): Promise<DbClient> {
+  const sqlite = new Database(':memory:');
+  const db = drizzle(sqlite, { schema });
+  const migrationsFolder = findMigrationsFolder();
+  await migrate(db, { migrationsFolder });
+  return db;
+}
+
+/**
+ * Create isolated test database (temporary file)
+ *
+ * Use for tests that need CLI to access database.
+ * Database is in a temporary directory that's cleaned up.
+ *
+ * @returns Object with database, path, and cleanup function
+ *
+ * @example
+ * ```typescript
+ * const { db, path: dbPath, cleanup } = await setupTestDatabaseFile();
+ * // Use db and dbPath...
+ * await cleanup();
+ * ```
+ */
+export async function setupTestDatabaseFile(): Promise<{
+  db: DbClient;
+  path: string;
+  cleanup: () => Promise<void>;
+}> {
+  const tempDir = await mkdtemp(join(tmpdir(), 'celilo-test-'));
+  const dbPath = join(tempDir, 'test.db');
+  const sqlite = new Database(dbPath);
+  const db = drizzle(sqlite, { schema });
+  const migrationsFolder = findMigrationsFolder();
+  await migrate(db, { migrationsFolder });
+
+  const cleanup = async () => {
+    sqlite.close();
+    await rm(tempDir, { recursive: true, force: true });
+  };
+
+  return { db, path: dbPath, cleanup };
+}
+
+/**
+ * Clean up test database
+ *
+ * Closes the database connection.
+ * For in-memory databases, this destroys all data.
+ *
+ * @param db - Database to close
+ *
+ * @example
+ * ```typescript
+ * const db = await setupTestDatabase();
+ * // ... tests ...
+ * await cleanupTestDatabase(db);
+ * ```
+ */
+export async function cleanupTestDatabase(db: DbClient): Promise<void> {
+  db.$client.close();
+}
+
+/**
+ * Create multiple isolated databases
+ *
+ * Useful for tests that need multiple independent databases.
+ *
+ * @param count - Number of databases to create
+ * @returns Array of in-memory databases
+ *
+ * @example
+ * ```typescript
+ * const [db1, db2] = await setupMultipleTestDatabases(2);
+ * // Use db1 and db2 independently...
+ * await cleanupMultipleTestDatabases([db1, db2]);
+ * ```
+ */
+export async function setupMultipleTestDatabases(count: number): Promise<DbClient[]> {
+  const databases: DbClient[] = [];
+  for (let i = 0; i < count; i++) {
+    databases.push(await setupTestDatabase());
+  }
+  return databases;
+}
+
+/**
+ * Clean up multiple test databases
+ *
+ * @param databases - Array of databases to close
+ */
+export async function cleanupMultipleTestDatabases(databases: DbClient[]): Promise<void> {
+  for (const db of databases) {
+    await cleanupTestDatabase(db);
+  }
+}

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

@@ -0,0 +1,208 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import {
+  copyFixture,
+  createMultipleTempDirectories,
+  createTempDirectory,
+  createTempDirectoryWithCleanup,
+  removeMultipleTempDirectories,
+  removeTempDirectory,
+} from './filesystem';
+
+describe('Filesystem Test Utilities', () => {
+  const createdDirs: string[] = [];
+
+  afterEach(async () => {
+    // Cleanup any directories that weren't cleaned up in test
+    for (const dir of createdDirs) {
+      try {
+        if (existsSync(dir)) {
+          await removeTempDirectory(dir);
+        }
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+    createdDirs.length = 0;
+  });
+
+  describe('createTempDirectory', () => {
+    test('creates unique temporary directory', async () => {
+      const dir = await createTempDirectory();
+      createdDirs.push(dir);
+
+      expect(existsSync(dir)).toBe(true);
+      expect(dir).toMatch(/celilo-test-/);
+    });
+
+    test('creates different directories on multiple calls', async () => {
+      const dir1 = await createTempDirectory();
+      const dir2 = await createTempDirectory();
+      createdDirs.push(dir1, dir2);
+
+      expect(dir1).not.toBe(dir2);
+      expect(existsSync(dir1)).toBe(true);
+      expect(existsSync(dir2)).toBe(true);
+    });
+
+    test('directory is writable', async () => {
+      const dir = await createTempDirectory();
+      createdDirs.push(dir);
+
+      const testFile = join(dir, 'test.txt');
+      await writeFile(testFile, 'test content');
+
+      expect(existsSync(testFile)).toBe(true);
+      const content = await readFile(testFile, 'utf-8');
+      expect(content).toBe('test content');
+    });
+  });
+
+  describe('removeTempDirectory', () => {
+    test('removes empty directory', async () => {
+      const dir = await createTempDirectory();
+      expect(existsSync(dir)).toBe(true);
+
+      await removeTempDirectory(dir);
+      expect(existsSync(dir)).toBe(false);
+    });
+
+    test('removes directory with files', async () => {
+      const dir = await createTempDirectory();
+      await writeFile(join(dir, 'test.txt'), 'content');
+
+      expect(existsSync(dir)).toBe(true);
+
+      await removeTempDirectory(dir);
+      expect(existsSync(dir)).toBe(false);
+    });
+
+    test('removes directory with subdirectories', async () => {
+      const dir = await createTempDirectory();
+      const subdir = join(dir, 'subdir');
+      await writeFile(join(dir, 'test.txt'), 'content');
+
+      // Create subdirectory with file
+      const { mkdir } = await import('node:fs/promises');
+      await mkdir(subdir);
+      await writeFile(join(subdir, 'nested.txt'), 'nested');
+
+      expect(existsSync(dir)).toBe(true);
+      expect(existsSync(subdir)).toBe(true);
+
+      await removeTempDirectory(dir);
+      expect(existsSync(dir)).toBe(false);
+    });
+
+    test('handles non-existent directory gracefully', async () => {
+      // Should not throw
+      await expect(removeTempDirectory('/tmp/does-not-exist-12345')).resolves.toBeUndefined();
+    });
+  });
+
+  describe('copyFixture', () => {
+    test('copies fixture to destination', async () => {
+      const tempDir = await createTempDirectory();
+      createdDirs.push(tempDir);
+
+      const destPath = join(tempDir, 'artifact-test');
+      await copyFixture('./test-fixtures/modules/artifact-test', destPath);
+
+      expect(existsSync(destPath)).toBe(true);
+      expect(existsSync(join(destPath, 'manifest.yml'))).toBe(true);
+      expect(existsSync(join(destPath, 'terraform'))).toBe(true);
+    });
+
+    test('preserves directory structure', async () => {
+      const tempDir = await createTempDirectory();
+      createdDirs.push(tempDir);
+
+      const destPath = join(tempDir, 'artifact-test');
+      await copyFixture('./test-fixtures/modules/artifact-test', destPath);
+
+      expect(existsSync(join(destPath, 'terraform', 'main.tf'))).toBe(true);
+      expect(existsSync(join(destPath, 'build', 'build.sh'))).toBe(true);
+    });
+
+    test('preserves file contents', async () => {
+      const tempDir = await createTempDirectory();
+      createdDirs.push(tempDir);
+
+      const destPath = join(tempDir, 'artifact-test');
+      await copyFixture('./test-fixtures/modules/artifact-test', destPath);
+
+      const manifest = await readFile(join(destPath, 'manifest.yml'), 'utf-8');
+      expect(manifest).toContain('id: artifact-test');
+    });
+  });
+
+  describe('createMultipleTempDirectories', () => {
+    test('creates multiple directories', async () => {
+      const dirs = await createMultipleTempDirectories(3);
+      createdDirs.push(...dirs);
+
+      expect(dirs).toHaveLength(3);
+      expect(existsSync(dirs[0])).toBe(true);
+      expect(existsSync(dirs[1])).toBe(true);
+      expect(existsSync(dirs[2])).toBe(true);
+    });
+
+    test('directories are unique', async () => {
+      const dirs = await createMultipleTempDirectories(3);
+      createdDirs.push(...dirs);
+
+      expect(dirs[0]).not.toBe(dirs[1]);
+      expect(dirs[1]).not.toBe(dirs[2]);
+      expect(dirs[0]).not.toBe(dirs[2]);
+    });
+
+    test('creates zero directories', async () => {
+      const dirs = await createMultipleTempDirectories(0);
+      expect(dirs).toHaveLength(0);
+    });
+  });
+
+  describe('removeMultipleTempDirectories', () => {
+    test('removes multiple directories', async () => {
+      const dirs = await createMultipleTempDirectories(3);
+
+      expect(existsSync(dirs[0])).toBe(true);
+      expect(existsSync(dirs[1])).toBe(true);
+      expect(existsSync(dirs[2])).toBe(true);
+
+      await removeMultipleTempDirectories(dirs);
+
+      expect(existsSync(dirs[0])).toBe(false);
+      expect(existsSync(dirs[1])).toBe(false);
+      expect(existsSync(dirs[2])).toBe(false);
+    });
+
+    test('handles empty array', async () => {
+      await expect(removeMultipleTempDirectories([])).resolves.toBeUndefined();
+    });
+  });
+
+  describe('createTempDirectoryWithCleanup', () => {
+    test('creates directory and cleanup function', async () => {
+      const { path: dir, cleanup } = await createTempDirectoryWithCleanup();
+
+      expect(existsSync(dir)).toBe(true);
+      expect(typeof cleanup).toBe('function');
+
+      await cleanup();
+      expect(existsSync(dir)).toBe(false);
+    });
+
+    test('cleanup removes directory', async () => {
+      const { path: dir, cleanup } = await createTempDirectoryWithCleanup();
+      await writeFile(join(dir, 'test.txt'), 'content');
+
+      expect(existsSync(dir)).toBe(true);
+
+      await cleanup();
+      expect(existsSync(dir)).toBe(false);
+    });
+  });
+});