gitforest 0.1.0 → 1.1.0

package/test/unit/operations/commands.test.ts

@@ -1,550 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { executeCommand, findCommandByKey, batchExecuteCommand } from "../../../src/operations/commands.ts";
-import type { CommandConfig } from "../../../src/types/index.ts";
-import { mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-
-describe("commands", () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), "gitforest-test-"));
-  });
-
-  afterEach(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  describe("executeCommand", () => {
-    test("executes a simple command successfully", async () => {
-      const command: CommandConfig = {
-        name: "Echo Test",
-        key: "e",
-        command: "echo 'hello world'",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("hello world");
-      expect(result.command).toBe("Echo Test");
-      expect(result.projectPath).toBe(tempDir);
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-
-    test("executes command in the correct directory", async () => {
-      const command: CommandConfig = {
-        name: "PWD Test",
-        key: "p",
-        command: "pwd",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe(tempDir);
-    });
-
-    test("handles command failure", async () => {
-      const command: CommandConfig = {
-        name: "Fail Test",
-        key: "f",
-        command: "exit 1",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    test("handles non-existent command", async () => {
-      const command: CommandConfig = {
-        name: "Bad Command",
-        key: "b",
-        command: "nonexistent_command_xyz",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    test("expands environment variables", async () => {
-      process.env.TEST_VAR = "test_value";
-      
-      const command: CommandConfig = {
-        name: "Env Test",
-        key: "v",
-        command: "echo $TEST_VAR",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("test_value");
-      
-      delete process.env.TEST_VAR;
-    });
-
-    test("handles background execution", async () => {
-      const command: CommandConfig = {
-        name: "Background Test",
-        key: "g",
-        command: "sleep 0.1",
-        confirm: false,
-        background: true,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("Started in background");
-      expect(result.duration).toBeLessThan(100); // Should return immediately
-    });
-
-    test("returns success: false on command failure", async () => {
-      const command: CommandConfig = {
-        name: "Fail Command",
-        key: "f",
-        command: "exit 1",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-      expect(result.error).toContain("Command exited with code 1");
-    });
-
-    test("handles command that exits with non-zero code", async () => {
-      const command: CommandConfig = {
-        name: "Non-zero Exit",
-        key: "n",
-        command: "test -f nonexistent.txt",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    test("expands $PWD to project path", async () => {
-      const command: CommandConfig = {
-        name: "PWD Expansion Test",
-        key: "p",
-        command: "echo $PWD",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe(tempDir);
-    });
-
-    test("expands other environment variables", async () => {
-      process.env.CUSTOM_VAR = "custom_value";
-      
-      const command: CommandConfig = {
-        name: "Custom Env Var Test",
-        key: "v",
-        command: "echo $CUSTOM_VAR",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("custom_value");
-      
-      delete process.env.CUSTOM_VAR;
-    });
-
-    test("handles ${VAR} syntax", async () => {
-      process.env.BRACKET_VAR = "bracket_value";
-      
-      const command: CommandConfig = {
-        name: "Bracket Syntax Test",
-        key: "b",
-        command: "echo ${BRACKET_VAR}",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("bracket_value");
-      
-      delete process.env.BRACKET_VAR;
-    });
-
-    test("handles mixed environment variables", async () => {
-      process.env.MIXED_VAR = "mixed";
-      
-      const command: CommandConfig = {
-        name: "Mixed Env Test",
-        key: "m",
-        command: "echo $MIXED_VAR-${PWD}-end",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe(`mixed-${tempDir}-end`);
-      
-      delete process.env.MIXED_VAR;
-    });
-
-    test("handles background mode option override", async () => {
-      const command: CommandConfig = {
-        name: "Background Override Test",
-        key: "o",
-        command: "sleep 0.1",
-        confirm: false,
-        background: false, // Command says not background
-      };
-
-      // But override to background
-      const result = await executeCommand(command, tempDir, { background: true });
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("Started in background");
-    });
-
-    test("handles command exceptions", async () => {
-      const command: CommandConfig = {
-        name: "Exception Test",
-        key: "x",
-        command: "echo 'test' > /root/cannot_write_here.txt",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    test("measures duration correctly", async () => {
-      const command: CommandConfig = {
-        name: "Duration Test",
-        key: "d",
-        command: "sleep 0.2",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, tempDir);
-
-      expect(result.success).toBe(true);
-      expect(result.duration).toBeGreaterThanOrEqual(200);
-      expect(result.duration).toBeLessThan(300);
-    });
-
-    test("uses correct working directory", async () => {
-      // Create a subdirectory
-      const subDir = join(tempDir, "subdir");
-      await Bun.$`mkdir -p ${subDir}`;
-      
-      const command: CommandConfig = {
-        name: "Working Dir Test",
-        key: "w",
-        command: "pwd",
-        confirm: false,
-        background: false,
-      };
-
-      const result = await executeCommand(command, subDir);
-
-      expect(result.success).toBe(true);
-      expect(result.output).toBe(subDir);
-    });
-  });
-
-  describe("findCommandByKey", () => {
-    const commands: CommandConfig[] = [
-      { name: "Open Editor", key: "e", command: "code .", confirm: false, background: false },
-      { name: "Run Tests", key: "t", command: "bun test", confirm: false, background: false },
-      { name: "Build", key: "b", command: "bun run build", confirm: false, background: false },
-    ];
-
-    test("finds command by key", () => {
-      const result = findCommandByKey(commands, "t");
-      
-      expect(result).toBeDefined();
-      expect(result?.name).toBe("Run Tests");
-      expect(result?.command).toBe("bun test");
-    });
-
-    test("returns undefined for non-existent key", () => {
-      const result = findCommandByKey(commands, "z");
-      
-      expect(result).toBeUndefined();
-    });
-
-    test("handles empty commands array", () => {
-      const result = findCommandByKey([], "e");
-      
-      expect(result).toBeUndefined();
-    });
-
-    test("returns first match if duplicates exist", () => {
-      const commands: CommandConfig[] = [
-        { name: "First Command", key: "d", command: "echo first", confirm: false, background: false },
-        { name: "Duplicate Command", key: "d", command: "echo duplicate", confirm: false, background: false },
-        { name: "Third Command", key: "t", command: "echo third", confirm: false, background: false },
-      ];
-
-      const result = findCommandByKey(commands, "d");
-      
-      expect(result).toBeDefined();
-      expect(result?.name).toBe("First Command");
-      expect(result?.command).toBe("echo first");
-    });
-
-    test("handles undefined commands array", () => {
-      const result = findCommandByKey(undefined as any, "e");
-      
-      expect(result).toBeUndefined();
-    });
-
-    test("handles null commands array", () => {
-      const result = findCommandByKey(null as any, "e");
-      
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe("batchExecuteCommand", () => {
-    test("executes command on multiple projects", async () => {
-      // Create multiple temp directories
-      const dir1 = await mkdtemp(join(tmpdir(), "gitforest-batch-1-"));
-      const dir2 = await mkdtemp(join(tmpdir(), "gitforest-batch-2-"));
-
-      const command: CommandConfig = {
-        name: "Batch Echo",
-        key: "e",
-        command: "echo 'batch test'",
-        confirm: false,
-        background: false,
-      };
-
-      const results = await batchExecuteCommand(command, [dir1, dir2]);
-
-      expect(results).toHaveLength(2);
-      expect(results[0]!.success).toBe(true);
-      expect(results[1]!.success).toBe(true);
-      expect(results[0]!.output).toBe("batch test");
-      expect(results[1]!.output).toBe("batch test");
-
-      // Cleanup
-      await rm(dir1, { recursive: true, force: true });
-      await rm(dir2, { recursive: true, force: true });
-    });
-
-    test("reports progress", async () => {
-      const dir1 = await mkdtemp(join(tmpdir(), "gitforest-progress-1-"));
-      const dir2 = await mkdtemp(join(tmpdir(), "gitforest-progress-2-"));
-
-      const command: CommandConfig = {
-        name: "Progress Test",
-        key: "p",
-        command: "echo 'progress'",
-        confirm: false,
-        background: false,
-      };
-
-      const progressCalls: { current: number; total: number }[] = [];
-
-      await batchExecuteCommand(command, [dir1, dir2], {
-        concurrency: 1,
-        onProgress: (current, total) => {
-          progressCalls.push({ current, total });
-        },
-      });
-
-      expect(progressCalls.length).toBeGreaterThan(0);
-      expect(progressCalls[progressCalls.length - 1]!.current).toBe(2);
-      expect(progressCalls[progressCalls.length - 1]!.total).toBe(2);
-
-      // Cleanup
-      await rm(dir1, { recursive: true, force: true });
-      await rm(dir2, { recursive: true, force: true });
-    });
-
-    test("respects concurrency option", async () => {
-      const dirs = await Promise.all(
-        Array.from({ length: 5 }, (_, i) => mkdtemp(join(tmpdir(), `gitforest-concurrency-${i}-`)))
-      );
-
-      const command: CommandConfig = {
-        name: "Concurrency Test",
-        key: "c",
-        command: "sleep 0.1",
-        confirm: false,
-        background: false,
-      };
-
-      const startTime = Date.now();
-      const results = await batchExecuteCommand(command, dirs, { concurrency: 2 });
-      const duration = Date.now() - startTime;
-
-      expect(results).toHaveLength(5);
-      expect(results.every(r => r.success)).toBe(true);
-      // With concurrency 2, should take at least 300ms (3 batches of 2, 2, 1)
-      expect(duration).toBeGreaterThanOrEqual(250);
-
-      // Cleanup
-      await Promise.all(dirs.map(dir => rm(dir, { recursive: true, force: true })));
-    });
-
-    test("returns results for all projects", async () => {
-      const dirs = await Promise.all(
-        Array.from({ length: 3 }, (_, i) => mkdtemp(join(tmpdir(), `gitforest-results-${i}-`)))
-      );
-
-      const command: CommandConfig = {
-        name: "Results Test",
-        key: "r",
-        command: "pwd",
-        confirm: false,
-        background: false,
-      };
-
-      const results = await batchExecuteCommand(command, dirs);
-
-      expect(results).toHaveLength(3);
-      for (let i = 0; i < results.length; i++) {
-        const result = results[i]!;
-        const dir = dirs[i]!;
-        expect(result.success).toBe(true);
-        expect(result.projectPath).toBe(dir);
-        // Check that output is defined (pwd command should output the directory path)
-        const output = result.output;
-        expect(output).toBeDefined();
-        expect(typeof output).toBe('string');
-      }
-
-      // Cleanup
-      await Promise.all(dirs.map(dir => rm(dir, { recursive: true, force: true })));
-    });
-
-    test("handles mixed success/failure", async () => {
-      const dir1 = await mkdtemp(join(tmpdir(), "gitforest-mixed-1-"));
-      const dir2 = await mkdtemp(join(tmpdir(), "gitforest-mixed-2-"));
-
-      const command: CommandConfig = {
-        name: "Mixed Results Test",
-        key: "m",
-        command: "test -d subdir",
-        confirm: false,
-        background: false,
-      };
-
-      // Create subdir in only one of the directories
-      await Bun.$`mkdir -p ${join(dir1, "subdir")}`;
-
-      const results = await batchExecuteCommand(command, [dir1, dir2]);
-
-      expect(results).toHaveLength(2);
-      expect(results[0]!.success).toBe(true); // dir1 has subdir
-      expect(results[1]!.success).toBe(false); // dir2 doesn't have subdir
-
-      // Cleanup
-      await rm(dir1, { recursive: true, force: true });
-      await rm(dir2, { recursive: true, force: true });
-    });
-
-    test("handles empty project paths array", async () => {
-      const command: CommandConfig = {
-        name: "Empty Test",
-        key: "e",
-        command: "echo 'test'",
-        confirm: false,
-        background: false,
-      };
-
-      const results = await batchExecuteCommand(command, []);
-
-      expect(results).toHaveLength(0);
-    });
-
-    test("handles single project", async () => {
-      const dir = await mkdtemp(join(tmpdir(), "gitforest-single-"));
-
-      const command: CommandConfig = {
-        name: "Single Test",
-        key: "s",
-        command: "echo 'single'",
-        confirm: false,
-        background: false,
-      };
-
-      const results = await batchExecuteCommand(command, [dir]);
-
-      expect(results).toHaveLength(1);
-      expect(results[0]!.success).toBe(true);
-      expect(results[0]!.output).toBe("single");
-
-      // Cleanup
-      await rm(dir, { recursive: true, force: true });
-    });
-
-    test("calls onProgress for each batch", async () => {
-      const dirs = await Promise.all(
-        Array.from({ length: 7 }, (_, i) => mkdtemp(join(tmpdir(), `gitforest-progress-batch-${i}-`)))
-      );
-
-      const command: CommandConfig = {
-        name: "Progress Batch Test",
-        key: "p",
-        command: "echo 'progress'",
-        confirm: false,
-        background: false,
-      };
-
-      const progressCalls: { current: number; total: number }[] = [];
-
-      await batchExecuteCommand(command, dirs, {
-        concurrency: 3,
-        onProgress: (current, total) => {
-          progressCalls.push({ current, total });
-        },
-      });
-
-      // Should have 3 progress calls (batches of 3, 3, 1)
-      expect(progressCalls).toHaveLength(3);
-      expect(progressCalls[0]!.current).toBe(3);
-      expect(progressCalls[1]!.current).toBe(6);
-      expect(progressCalls[2]!.current).toBe(7);
-      expect(progressCalls.every(call => call.total === 7)).toBe(true);
-
-      // Cleanup
-      await Promise.all(dirs.map(dir => rm(dir, { recursive: true, force: true })));
-    });
-  });
-});