alepha 0.14.2 → 0.14.3

package/src/cli/services/GitMessageParser.ts

@@ -3,7 +3,7 @@ import {
   type ChangelogOptions,
   DEFAULT_IGNORE,
 } from "../atoms/changelogOptions.ts";
-import type { Commit } from "../commands/changelog.ts";
+import type { Commit } from "../commands/gen/changelog.ts";
 
 /**
  * Service for parsing git commit messages into structured format.

package/src/command/helpers/Asker.spec.ts

@@ -0,0 +1,127 @@
+import { Alepha, AlephaError, t } from "alepha";
+import {
+  LogDestinationProvider,
+  MemoryDestinationProvider,
+} from "alepha/logger";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { Asker } from "../index.ts";
+
+describe("Asker", () => {
+  let alepha: Alepha;
+  let asker: Asker;
+  let mockLogger: MemoryDestinationProvider;
+
+  const mockPromptInterface = (answers: string[]) => {
+    const question = vi.fn();
+    for (const answer of answers) {
+      question.mockResolvedValueOnce(answer);
+    }
+    const close = vi.fn();
+
+    vi.spyOn(
+      asker as unknown as { createPromptInterface: () => any },
+      "createPromptInterface",
+    ).mockReturnValue({
+      question,
+      close,
+    });
+
+    return { question, close };
+  };
+
+  beforeEach(() => {
+    alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "info",
+      },
+    })
+      .with({
+        provide: LogDestinationProvider,
+        use: MemoryDestinationProvider,
+      })
+      .with(Asker);
+
+    asker = alepha.inject(Asker);
+    mockLogger = alepha.inject(MemoryDestinationProvider);
+    mockLogger.clear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("returns trimmed string when no schema is provided", async () => {
+    const { question, close } = mockPromptInterface(["  hello world  "]);
+
+    const result = await asker.ask("What is your name?");
+
+    expect(result).toBe("hello world");
+    expect(question).toHaveBeenCalledTimes(1);
+    expect(question).toHaveBeenCalledWith("What is your name?\n> ");
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  test("retries until schema validation passes", async () => {
+    const { question, close } = mockPromptInterface(["abc", "41"]);
+
+    const result = await asker.ask("Enter a number", {
+      schema: t.number(),
+    });
+
+    expect(result).toBe(41);
+    expect(question).toHaveBeenCalledTimes(2);
+    expect(close).toHaveBeenCalledTimes(1);
+    expect(mockLogger.logs.some((log) => log.level === "ERROR")).toBe(true);
+  });
+
+  test("uses schema defaults when the user provides an empty answer", async () => {
+    const { question, close } = mockPromptInterface([""]);
+
+    const result = await asker.ask("What is your favorite color?", {
+      schema: t.text({ default: "blue" }),
+    });
+
+    expect(result).toBe("blue");
+    expect(question).toHaveBeenCalledTimes(1);
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  test("retries when custom validation throws an AlephaError", async () => {
+    const { question, close } = mockPromptInterface(["wrong", "right"]);
+
+    const result = await asker.ask("Provide the secret", {
+      schema: t.text(),
+      validate: (value) => {
+        if (value !== "right") {
+          throw new AlephaError("Invalid secret");
+        }
+      },
+    });
+
+    expect(result).toBe("right");
+    expect(question).toHaveBeenCalledTimes(2);
+    expect(close).toHaveBeenCalledTimes(1);
+
+    const errorLogs = mockLogger.logs.filter((log) => log.level === "ERROR");
+    expect(errorLogs).toHaveLength(1);
+    expect(errorLogs[0].message).toContain("Invalid secret");
+  });
+
+  test("propagates unexpected errors without logging", async () => {
+    const { question, close } = mockPromptInterface(["value"]);
+    const unexpectedError = new Error("boom");
+
+    await expect(
+      asker.ask("Trigger failure", {
+        schema: t.text(),
+        validate: () => {
+          throw unexpectedError;
+        },
+      }),
+    ).rejects.toBe(unexpectedError);
+
+    expect(question).toHaveBeenCalledTimes(1);
+    expect(close).toHaveBeenCalledTimes(1);
+    expect(mockLogger.logs.some((log) => log.level === "ERROR")).toBe(false);
+  });
+});

package/src/command/helpers/Runner.spec.ts

@@ -0,0 +1,126 @@
+import { Alepha } from "alepha";
+import {
+  LogDestinationProvider,
+  MemoryDestinationProvider,
+} from "alepha/logger";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { Runner } from "../index.ts";
+
+describe("Runner", () => {
+  let mockLogger: MemoryDestinationProvider;
+  let runner: Runner;
+
+  beforeEach(async () => {
+    const alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "info",
+      },
+    }).with({
+      provide: LogDestinationProvider,
+      use: MemoryDestinationProvider,
+    });
+    // Create a new MockLogger and Runner for each test to ensure isolation
+    runner = alepha.inject(Runner);
+    mockLogger = alepha.inject(MemoryDestinationProvider);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("should execute a single shell command via run.sh", async () => {
+    await runner.run(`echo "hello"`);
+
+    expect(mockLogger.logs).toHaveLength(2);
+    const startLog = mockLogger.logs[0];
+    const finishLog = mockLogger.logs[1];
+
+    expect(startLog.message).toBe("Starting 'echo \"hello\"' ...");
+    expect(startLog.level).toBe("INFO");
+
+    expect(finishLog.message).toMatch(
+      /^Finished 'echo "hello"' after \d+\.\ds$/,
+    );
+    expect(finishLog.level).toBe("INFO");
+
+    const timers = (runner as any).timers;
+    expect(timers).toHaveLength(1);
+    expect(timers[0].name).toBe('echo "hello"');
+    expect(timers[0].duration).toMatch(/^\d+\.\ds$/);
+  });
+
+  test("should execute a single shell command via run(sh`...`)", async () => {
+    await runner.run(`echo "world"`);
+    expect(mockLogger.logs[0].message).toBe("Starting 'echo \"world\"' ...");
+    expect(mockLogger.logs).toHaveLength(2);
+  });
+
+  test("should execute a single function task via run.fn", async () => {
+    const mockFn = vi.fn();
+    await runner.run("my-test-function", mockFn);
+
+    expect(mockFn).toHaveBeenCalledOnce();
+    expect(mockLogger.logs).toHaveLength(2);
+    expect(mockLogger.logs[0].message).toBe("Starting 'my-test-function' ...");
+    expect(mockLogger.logs[1].message).toMatch(
+      /^Finished 'my-test-function' after \d+\.\ds$/,
+    );
+  });
+
+  test("should execute a single function task via run(fn(...))", async () => {
+    const mockFn = vi.fn();
+    await runner.run("another-function", mockFn);
+    expect(mockFn).toHaveBeenCalledOnce();
+    expect(mockLogger.logs).toHaveLength(2);
+  });
+
+  test("should execute an array of tasks in parallel", async () => {
+    const fn1 = vi.fn(() => new Promise((res) => setTimeout(res, 20)));
+    const fn2 = vi.fn(() => new Promise((res) => setTimeout(res, 20)));
+
+    await runner.run([
+      `echo "parallel sh"`,
+      { name: "parallel fn 1", handler: fn1 },
+      { name: "parallel fn 2", handler: fn2 },
+    ]);
+
+    expect(fn1).toHaveBeenCalledOnce();
+    expect(fn2).toHaveBeenCalledOnce();
+    expect(mockLogger.logs).toHaveLength(6); // 3 start, 3 finish logs
+    expect((runner as any).timers).toHaveLength(3);
+  });
+
+  test("should throw and log an error for a failing shell command", async () => {
+    await expect(runner.run(`exit 1`)).rejects.toThrow("Task 'exit 1' failed");
+  });
+
+  test("should throw and log an error for a failing function task", async () => {
+    const error = new Error("Function failed!");
+    const failingFn = () => {
+      throw error;
+    };
+
+    await expect(runner.run("failing-task", failingFn)).rejects.toThrow(
+      "Task 'failing-task' failed",
+    );
+  });
+
+  test("summary() should print a formatted table of executed tasks", async () => {
+    await runner.run(`echo "Task 1"`);
+    await runner.run("A slightly longer task name", () => {});
+
+    runner.summary();
+
+    const logs = mockLogger.logs
+      .slice(4)
+      .map((l) => l.message)
+      .join("\n");
+  });
+
+  test("summary() should not print a table if no tasks were run", () => {
+    runner.summary();
+
+    const logs = mockLogger.logs.map((l) => l.message);
+    expect(logs.length).toBe(0);
+  });
+});