@celilo/cli 0.1.0

package/src/module/import.test.ts

@@ -0,0 +1,355 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { existsSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { eq } from 'drizzle-orm';
+import { type DbClient, createDbClient } from '../db/client';
+import { modules } from '../db/schema';
+import type { ModuleManifest } from '../manifest/schema';
+import {
+  copyModuleFiles,
+  importModule,
+  insertModuleToDb,
+  moduleExists,
+  readModuleManifest,
+  validateModuleDirectory,
+} from './import';
+
+const TEST_FIXTURES_DIR = './test-fixtures-temp'; // Temporary fixtures for this test (not the real golden files)
+const TEST_TARGET_DIR = './test-modules-target';
+const TEST_DB_PATH = './test-import.db';
+
+describe('Module Import', () => {
+  let db: DbClient;
+
+  beforeEach(async () => {
+    // Create test database
+    db = createDbClient({ path: TEST_DB_PATH });
+
+    // Create tables
+    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
+      )
+    `);
+
+    // Clean up test directories
+    if (existsSync(TEST_FIXTURES_DIR)) {
+      await rm(TEST_FIXTURES_DIR, { recursive: true });
+    }
+    if (existsSync(TEST_TARGET_DIR)) {
+      await rm(TEST_TARGET_DIR, { recursive: true });
+    }
+
+    await mkdir(TEST_FIXTURES_DIR, { recursive: true });
+    await mkdir(TEST_TARGET_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    db.$client.close();
+
+    // Clean up
+    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_FIXTURES_DIR)) {
+      await rm(TEST_FIXTURES_DIR, { recursive: true });
+    }
+    if (existsSync(TEST_TARGET_DIR)) {
+      await rm(TEST_TARGET_DIR, { recursive: true });
+    }
+  });
+
+  describe('validateModuleDirectory', () => {
+    test('should return null for valid module directory', async () => {
+      const moduleDir = join(TEST_FIXTURES_DIR, 'valid-module');
+      await mkdir(moduleDir, { recursive: true });
+      await writeFile(join(moduleDir, 'manifest.yml'), 'id: test');
+
+      const result = validateModuleDirectory(moduleDir);
+
+      expect(result).toBeNull();
+    });
+
+    test('should return error for non-existent directory', () => {
+      const result = validateModuleDirectory('./does-not-exist');
+
+      expect(result).toContain('does not exist');
+    });
+
+    test('should return error for file instead of directory', async () => {
+      const filePath = join(TEST_FIXTURES_DIR, 'not-a-dir');
+      await writeFile(filePath, 'content');
+
+      const result = validateModuleDirectory(filePath);
+
+      expect(result).toContain('not a directory');
+    });
+
+    test('should return error if manifest.yml missing', async () => {
+      const moduleDir = join(TEST_FIXTURES_DIR, 'no-manifest');
+      await mkdir(moduleDir, { recursive: true });
+
+      const result = validateModuleDirectory(moduleDir);
+
+      expect(result).toContain('manifest.yml not found');
+    });
+  });
+
+  describe('readModuleManifest', () => {
+    test('should read and validate valid manifest', async () => {
+      const moduleDir = join(TEST_FIXTURES_DIR, 'homebridge');
+      await mkdir(moduleDir, { recursive: true });
+      await writeFile(
+        join(moduleDir, 'manifest.yml'),
+        `
+celilo_contract: "1.0"
+id: homebridge
+name: Homebridge
+version: 1.0.0
+description: HomeKit bridge
+`,
+      );
+
+      const result = await readModuleManifest(moduleDir);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.manifest.id).toBe('homebridge');
+        expect(result.manifest.name).toBe('Homebridge');
+        expect(result.manifest.version).toBe('1.0.0');
+      }
+    });
+
+    test('should return error for invalid manifest', async () => {
+      const moduleDir = join(TEST_FIXTURES_DIR, 'invalid');
+      await mkdir(moduleDir, { recursive: true });
+      await writeFile(
+        join(moduleDir, 'manifest.yml'),
+        `
+id: Invalid_ID
+name: Test
+version: 1.0.0
+`,
+      );
+
+      const result = await readModuleManifest(moduleDir);
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('validation failed');
+      }
+    });
+
+    test('should return error for missing manifest file', async () => {
+      const moduleDir = join(TEST_FIXTURES_DIR, 'no-file');
+      await mkdir(moduleDir, { recursive: true });
+
+      const result = await readModuleManifest(moduleDir);
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('Failed to read');
+      }
+    });
+  });
+
+  describe('copyModuleFiles', () => {
+    test('should copy all files from source to target', async () => {
+      const sourceDir = join(TEST_FIXTURES_DIR, 'source');
+      const targetDir = join(TEST_TARGET_DIR, 'target');
+
+      await mkdir(sourceDir, { recursive: true });
+      await writeFile(join(sourceDir, 'manifest.yml'), 'content1');
+      await writeFile(join(sourceDir, 'README.md'), 'content2');
+      await mkdir(join(sourceDir, 'terraform'), { recursive: true });
+      await writeFile(join(sourceDir, 'terraform', 'main.tf'), 'terraform content');
+
+      await copyModuleFiles(sourceDir, targetDir);
+
+      expect(existsSync(join(targetDir, 'manifest.yml'))).toBe(true);
+      expect(existsSync(join(targetDir, 'README.md'))).toBe(true);
+      expect(existsSync(join(targetDir, 'terraform', 'main.tf'))).toBe(true);
+    });
+
+    test('should create target directory if it does not exist', async () => {
+      const sourceDir = join(TEST_FIXTURES_DIR, 'source2');
+      const targetDir = join(TEST_TARGET_DIR, 'nested', 'deep', 'target');
+
+      await mkdir(sourceDir, { recursive: true });
+      await writeFile(join(sourceDir, 'file.txt'), 'content');
+
+      await copyModuleFiles(sourceDir, targetDir);
+
+      expect(existsSync(targetDir)).toBe(true);
+      expect(existsSync(join(targetDir, 'file.txt'))).toBe(true);
+    });
+  });
+
+  describe('insertModuleToDb', () => {
+    test('should insert module record into database', async () => {
+      const manifest: ModuleManifest = {
+        celilo_contract: '1.0',
+        id: 'test-module',
+        name: 'Test Module',
+        version: '1.0.0',
+        requires: { capabilities: [] },
+        provides: { capabilities: [] },
+        variables: { owns: [], imports: [] },
+      };
+
+      await insertModuleToDb(manifest, '/target/path', db);
+
+      const result = db.select().from(modules).where(eq(modules.id, 'test-module')).get();
+
+      expect(result).toBeDefined();
+      expect(result?.name).toBe('Test Module');
+      expect(result?.version).toBe('1.0.0');
+      expect(result?.state).toBe('IMPORTED');
+      expect(result?.sourcePath).toBe('/target/path');
+    });
+  });
+
+  describe('moduleExists', () => {
+    test('should return true for existing module', () => {
+      db.insert(modules)
+        .values({
+          id: 'existing',
+          name: 'Existing',
+          version: '1.0.0',
+          sourcePath: '/path',
+          manifestData: {},
+        })
+        .run();
+
+      const result = moduleExists('existing', db);
+
+      expect(result).toBe(true);
+    });
+
+    test('should return false for non-existent module', () => {
+      const result = moduleExists('does-not-exist', db);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('importModule', () => {
+    test('should successfully import valid module', async () => {
+      const moduleDir = join(TEST_FIXTURES_DIR, 'homebridge');
+      await mkdir(moduleDir, { recursive: true });
+      await mkdir(join(moduleDir, 'terraform'), { recursive: true });
+      await writeFile(
+        join(moduleDir, 'manifest.yml'),
+        `
+celilo_contract: "1.0"
+id: homebridge
+name: Homebridge
+version: 1.0.0
+`,
+      );
+      await writeFile(join(moduleDir, 'README.md'), '# Homebridge');
+      await writeFile(join(moduleDir, 'terraform', 'main.tf'), 'resource "test" {}');
+
+      const result = await importModule({
+        sourcePath: moduleDir,
+        targetBasePath: TEST_TARGET_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.moduleId).toBe('homebridge');
+        expect(existsSync(result.targetPath)).toBe(true);
+        expect(existsSync(join(result.targetPath, 'manifest.yml'))).toBe(true);
+        expect(existsSync(join(result.targetPath, 'terraform', 'main.tf'))).toBe(true);
+      }
+
+      // Verify database
+      const dbRecord = db.select().from(modules).where(eq(modules.id, 'homebridge')).get();
+      expect(dbRecord).toBeDefined();
+      expect(dbRecord?.name).toBe('Homebridge');
+    });
+
+    test('should reject import if directory does not exist', async () => {
+      const result = await importModule({
+        sourcePath: './does-not-exist',
+        targetBasePath: TEST_TARGET_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('does not exist');
+      }
+    });
+
+    test('should reject import if manifest is invalid', async () => {
+      const moduleDir = join(TEST_FIXTURES_DIR, 'invalid');
+      await mkdir(moduleDir, { recursive: true });
+      await writeFile(
+        join(moduleDir, 'manifest.yml'),
+        'id: Invalid_ID\nname: Test\nversion: 1.0.0',
+      );
+
+      const result = await importModule({
+        sourcePath: moduleDir,
+        targetBasePath: TEST_TARGET_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('validation failed');
+      }
+    });
+
+    test('should reject import if module already exists', async () => {
+      // Insert existing module
+      db.insert(modules)
+        .values({
+          id: 'existing',
+          name: 'Existing',
+          version: '1.0.0',
+          sourcePath: '/path',
+          manifestData: {},
+        })
+        .run();
+
+      const moduleDir = join(TEST_FIXTURES_DIR, 'existing');
+      await mkdir(moduleDir, { recursive: true });
+      await writeFile(
+        join(moduleDir, 'manifest.yml'),
+        'celilo_contract: "1.0"\nid: existing\nname: Existing\nversion: 2.0.0',
+      );
+
+      const result = await importModule({
+        sourcePath: moduleDir,
+        targetBasePath: TEST_TARGET_DIR,
+        db,
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain('already exists');
+      }
+    });
+  });
+});