test(tests): run tests concurrently

xesrevinu · Git Agent · xesrevinu · commit 43a2bd16c2ce · 2026-03-27T13:49:32.000+08:00
- Enable cli smoke tests to run concurrently
- Add new test suites for commit and scope services

Adjust test suite to run concurrently where supported and add new tests
for commit and scope services to cover additional behavior.

Co-Authored-By: Git Agent &lt;noreply@git-agent.dev&gt;
diff --git a/tests/cli-smoke.test.ts b/tests/cli-smoke.test.ts
@@ -41,7 +41,7 @@ afterEach(() => {
   }
 });
 
-describe("cli smoke", () => {
+describe.concurrent("cli smoke", () => {
   it("prints the package version", () => {
     const result = runCli(["version"]);
 
diff --git a/tests/commit-message-service.test.ts b/tests/commit-message-service.test.ts
@@ -0,0 +1,106 @@
+import { describe, expect, layer } from "@effect/vitest";
+import { Effect, Fiber, Layer } from "effect";
+import { TestClock } from "effect/testing";
+import { emptyProjectConfig } from "../src/domain/project.ts";
+import {
+  CommitMessageService,
+  CommitMessageServiceLive,
+  type GenerateCommitMessageInput,
+} from "../src/services/commit-service.ts";
+import { LlmClient } from "../src/services/openai-client.ts";
+
+const makeInput = (
+  overrides: Partial<GenerateCommitMessageInput> = {},
+): GenerateCommitMessageInput => ({
+  provider: {
+    apiKey: "test-key",
+    baseUrl: "https://example.test/v1",
+    model: "test-model",
+    noGitAgentCoAuthor: false,
+    noModelCoAuthor: false,
+  },
+  diff: {
+    files: ["src/app.ts"],
+    content: "diff --git a/src/app.ts b/src/app.ts\n+export const value = 1;\n",
+    lines: 2,
+  },
+  intent: undefined,
+  config: emptyProjectConfig(),
+  hookFeedback: undefined,
+  previousMessage: undefined,
+  ...overrides,
+});
+
+describe.concurrent("CommitMessageService", () => {
+  layer(Layer.empty)((it) => {
+    it.effect(
+      "retries invalid model output and parses the next valid response",
+      Effect.fn(function* () {
+        let callCount = 0;
+
+        const llmLayer = Layer.mock(LlmClient, {
+          call: () =>
+            Effect.sync(() => {
+              callCount += 1;
+              return callCount === 1
+                ? "not-json"
+                : JSON.stringify({
+                    title: "feat(core): add flow",
+                    bullets: ["Add flow"],
+                    explanation: "Adds flow.",
+                  });
+            }),
+        });
+
+        const messageFiber = yield* Effect.gen(function* () {
+          const service = yield* CommitMessageService;
+          return yield* service.generate(makeInput());
+        }).pipe(
+          Effect.provide(CommitMessageServiceLive.pipe(Layer.provide(llmLayer))),
+          Effect.forkChild,
+        );
+
+        yield* TestClock.adjust("10 seconds");
+
+        const message = yield* Fiber.join(messageFiber);
+
+        expect(callCount).toBe(2);
+        expect(message.title).toBe("feat(core): add flow");
+        expect(message.bullets).toEqual(["Add flow"]);
+      }),
+    );
+
+    it.effect(
+      "switches to hook-fix prompting when previous message and hook feedback exist",
+      Effect.fn(function* () {
+        const prompts: Array<string> = [];
+
+        const llmLayer = Layer.mock(LlmClient, {
+          call: (input) =>
+            Effect.sync(() => {
+              prompts.push(input.userPrompt);
+              return JSON.stringify({
+                title: "fix(core): satisfy hook",
+                bullets: ["Fix hook issue"],
+                explanation: "Keeps the original meaning.",
+              });
+            }),
+        });
+
+        yield* Effect.gen(function* () {
+          const service = yield* CommitMessageService;
+          return yield* service.generate(
+            makeInput({
+              hookFeedback: "scope is required",
+              previousMessage: "fix: old title",
+            }),
+          );
+        }).pipe(Effect.provide(CommitMessageServiceLive.pipe(Layer.provide(llmLayer))));
+
+        expect(prompts).toHaveLength(1);
+        expect(prompts[0]).toContain("Fix the following commit message");
+        expect(prompts[0]).toContain("scope is required");
+      }),
+    );
+  });
+});
diff --git a/tests/commit-planner-service.test.ts b/tests/commit-planner-service.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, layer } from "@effect/vitest";
+import { Effect, Layer } from "effect";
+import { emptyProjectConfig } from "../src/domain/project.ts";
+import {
+  CommitPlannerService,
+  CommitPlannerServiceLive,
+  type PlanCommitsInput,
+} from "../src/services/commit-service.ts";
+import { LlmClient } from "../src/services/openai-client.ts";
+
+const makeInput = (overrides: Partial<PlanCommitsInput> = {}): PlanCommitsInput => ({
+  provider: {
+    apiKey: "test-key",
+    baseUrl: "https://example.test/v1",
+    model: "test-model",
+    noGitAgentCoAuthor: false,
+    noModelCoAuthor: false,
+  },
+  stagedFiles: ["src/staged.ts"],
+  unstagedFiles: ["src/unstaged.ts"],
+  intent: undefined,
+  config: emptyProjectConfig(),
+  ...overrides,
+});
+
+describe("CommitPlannerService", () => {
+  layer(Layer.empty)((it) => {
+    it.effect(
+      "includes staged and unstaged files in the prompt and decodes grouped output",
+      Effect.fn(function* () {
+        const prompts: Array<string> = [];
+
+        const llmLayer = Layer.succeed(LlmClient, {
+          call: (input) =>
+            Effect.sync(() => {
+              prompts.push(input.userPrompt);
+              return JSON.stringify({
+                groups: [
+                  {
+                    files: ["src/staged.ts"],
+                    title: "feat(core): stage first",
+                    bullets: ["Keep staged work together"],
+                    explanation: "Uses the user-selected staged file.",
+                  },
+                  {
+                    files: ["src/unstaged.ts"],
+                    title: "feat(core): handle rest",
+                    bullets: ["Handle unstaged work"],
+                    explanation: "Adds the unstaged change separately.",
+                  },
+                ],
+              });
+            }),
+        });
+
+        const plan = yield* Effect.gen(function* () {
+          const service = yield* CommitPlannerService;
+          return yield* service.plan(makeInput());
+        }).pipe(Effect.provide(CommitPlannerServiceLive.pipe(Layer.provide(llmLayer))));
+
+        expect(prompts).toHaveLength(1);
+        expect(prompts[0]).toContain("Staged files");
+        expect(prompts[0]).toContain("src/staged.ts");
+        expect(prompts[0]).toContain("src/unstaged.ts");
+        expect(plan.groups).toHaveLength(2);
+        expect(plan.groups[0]?.message?.title).toBe("feat(core): stage first");
+      }),
+    );
+  });
+});
diff --git a/tests/commit-service.test.ts b/tests/commit-service.test.ts
@@ -1,5 +1,6 @@
-import { Effect } from "effect";
-import { describe, expect, it } from "vitest";
+import { describe, expect, layer } from "@effect/vitest";
+import { Effect, Layer } from "effect";
+import { it } from "vitest";
 import type { CommitGroup } from "../src/domain/commit.ts";
 import type { CommitRequest } from "../src/services/commit-service.ts";
 import {
@@ -28,27 +29,30 @@ const group = (files: ReadonlyArray<string>) =>
   }) satisfies CommitGroup;
 
 describe("ensureJjWorkingCopyMatchesPlan", () => {
-  it("succeeds when the working copy still matches the remaining groups", async () => {
-    await expect(
-      Effect.runPromise(
-        ensureJjWorkingCopyMatchesPlan(makeRequest(["src/feature.ts"]), [
+  layer(Layer.empty)((it) => {
+    it.effect(
+      "succeeds when the working copy still matches the remaining groups",
+      Effect.fn(function* () {
+        yield* ensureJjWorkingCopyMatchesPlan(makeRequest(["src/feature.ts"]), [
           group(["src/feature.ts"]),
-        ]) as Effect.Effect<void, unknown, never>,
-      ),
-    ).resolves.toBeUndefined();
-  });
+        ]);
+      }),
+    );
 
-  it("fails when unexpected files appear in the jj working copy", async () => {
-    await expect(
-      Effect.runPromise(
-        ensureJjWorkingCopyMatchesPlan(makeRequest(["src/feature.ts", "src/unexpected.ts"]), [
-          group(["src/feature.ts"]),
-        ]) as Effect.Effect<void, unknown, never>,
-      ),
-    ).rejects.toMatchObject({
-      message:
-        "jj working copy drifted after commit; expected remaining files: src/feature.ts; actual remaining files: src/feature.ts, src/unexpected.ts",
-    });
+    it.effect(
+      "fails when unexpected files appear in the jj working copy",
+      Effect.fn(function* () {
+        const error = yield* Effect.flip(
+          ensureJjWorkingCopyMatchesPlan(makeRequest(["src/feature.ts", "src/unexpected.ts"]), [
+            group(["src/feature.ts"]),
+          ]),
+        );
+
+        expect(error.message).toBe(
+          "jj working copy drifted after commit; expected remaining files: src/feature.ts; actual remaining files: src/feature.ts, src/unexpected.ts",
+        );
+      }),
+    );
   });
 });
 
diff --git a/tests/hooks.test.ts b/tests/hooks.test.ts
@@ -1,13 +1,11 @@
 import { NodeServices } from "@effect/platform-node";
-import { Effect } from "effect";
+import { describe, expect, layer } from "@effect/vitest";
+import { Effect, Layer } from "effect";
 import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { executeHooks, type HookInput } from "../src/services/hooks.ts";
-
-const runEffect = <A>(effect: Effect.Effect<A, unknown, any>) =>
-  Effect.runPromise(Effect.provide(effect, NodeServices.layer) as Effect.Effect<A, unknown, never>);
+import { afterEach } from "vitest";
+import { HookService, HookServiceLive, type HookInput } from "../src/services/hooks.ts";
 
 const hookInput: HookInput = {
   diff: "",
@@ -35,26 +33,36 @@ afterEach(() => {
   }
 });
 
-describe("executeHooks", () => {
-  it("fails when a configured shell hook is missing", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "git-agent-hooks-"));
-    tempDirs.push(dir);
-    const hookPath = join(dir, "missing-hook.sh");
+describe("HookService", () => {
+  layer(HookServiceLive.pipe(Layer.provide(NodeServices.layer)))((it) => {
+    it.effect(
+      "fails when a configured shell hook is missing",
+      Effect.fn(function* () {
+        const dir = mkdtempSync(join(tmpdir(), "git-agent-hooks-"));
+        tempDirs.push(dir);
+        const hookPath = join(dir, "missing-hook.sh");
+        const hookService = yield* HookService;
 
-    await expect(runEffect(executeHooks([hookPath], hookInput))).rejects.toMatchObject({
-      message: expect.stringContaining(`failed to read hook "${hookPath}"`),
-    });
-  });
+        const error = yield* Effect.flip(hookService.execute([hookPath], hookInput));
+
+        expect(error.message).toContain(`failed to read hook "${hookPath}"`);
+      }),
+    );
+
+    it.effect(
+      "fails for non-executable hook files",
+      Effect.fn(function* () {
+        const dir = mkdtempSync(join(tmpdir(), "git-agent-hooks-"));
+        tempDirs.push(dir);
+        const hookPath = join(dir, "hook.sh");
+        writeFileSync(hookPath, "#!/bin/sh\nexit 0\n");
+        chmodSync(hookPath, 0o644);
+        const hookService = yield* HookService;
 
-  it("fails for non-executable hook files", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "git-agent-hooks-"));
-    tempDirs.push(dir);
-    const hookPath = join(dir, "hook.sh");
-    writeFileSync(hookPath, "#!/bin/sh\nexit 0\n");
-    chmodSync(hookPath, 0o644);
+        const error = yield* Effect.flip(hookService.execute([hookPath], hookInput));
 
-    await expect(runEffect(executeHooks([hookPath], hookInput))).rejects.toMatchObject({
-      message: `hook is not executable: ${hookPath}`,
-    });
+        expect(error.message).toBe(`hook is not executable: ${hookPath}`);
+      }),
+    );
   });
 });
diff --git a/tests/scope-service.test.ts b/tests/scope-service.test.ts
@@ -0,0 +1,68 @@
+import { describe, expect, layer } from "@effect/vitest";
+import { Effect, Layer } from "effect";
+import type { ProviderConfig } from "../src/config/provider.ts";
+import { LlmClient } from "../src/services/openai-client.ts";
+import { ScopeService, ScopeServiceLive } from "../src/services/scope-service.ts";
+import type { VcsClient } from "../src/services/vcs.ts";
+
+const provider: ProviderConfig = {
+  apiKey: "test-key",
+  baseUrl: "https://example.test/v1",
+  model: "test-model",
+  noGitAgentCoAuthor: false,
+  noModelCoAuthor: false,
+};
+
+const vcs: VcsClient = {
+  kind: "git",
+  supportsStaging: true,
+  isRepo: () => Effect.succeed(true),
+  initRepo: () => Effect.succeed(""),
+  repoRoot: () => Effect.succeed("/repo"),
+  stagedDiff: () => Effect.die("not used"),
+  unstagedDiff: () => Effect.die("not used"),
+  diffForFiles: () => Effect.die("not used"),
+  addAll: () => Effect.die("not used"),
+  stageFiles: () => Effect.die("not used"),
+  unstageAll: () => Effect.die("not used"),
+  commit: () => Effect.die("not used"),
+  amendCommit: () => Effect.die("not used"),
+  lastCommitDiff: () => Effect.die("not used"),
+  formatTrailers: () => Effect.die("not used"),
+  commitLog: () => Effect.succeed(["feat(api): add route"]),
+  topLevelDirs: () => Effect.succeed(["api", "web"]),
+  projectFiles: () => Effect.succeed(["api/routes.ts", "web/page.tsx"]),
+};
+
+describe("ScopeService", () => {
+  layer(Layer.empty)((it) => {
+    it.effect(
+      "filters out conventional commit types from generated scopes",
+      Effect.fn(function* () {
+        const llmLayer = Layer.succeed(LlmClient, {
+          call: () =>
+            Effect.succeed(
+              JSON.stringify({
+                scopes: [
+                  { name: "feat", description: "Should be filtered" },
+                  { name: "api", description: "Backend API handlers" },
+                ],
+              }),
+            ),
+        });
+
+        const scopes = yield* Effect.gen(function* () {
+          const service = yield* ScopeService;
+          return yield* service.generateProjectScopes({
+            provider,
+            vcs,
+            cwd: "/repo",
+            maxCommits: 10,
+          });
+        }).pipe(Effect.provide(ScopeServiceLive.pipe(Layer.provide(llmLayer))));
+
+        expect(scopes).toEqual([{ name: "api", description: "Backend API handlers" }]);
+      }),
+    );
+  });
+});
diff --git a/tests/vcs.test.ts b/tests/vcs.test.ts

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ afterEach(() => {`
`41`	`41`	`}`
`42`	`42`	`});`
`43`	`43`
`44`		`-describe("cli smoke", () => {`
	`44`	`+describe.concurrent("cli smoke", () => {`
`45`	`45`	`it("prints the package version", () => {`
`46`	`46`	`const result = runCli(["version"]);`
`47`	`47`