Add unit tests for bash and create tools: validate execution, error handling, and output

Author: habedi

tests/agent/tools/definitions/bash.test.ts

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import bash from "@/agent/tools/definitions/bash";
+import { ToolError } from "@/agent/errors";
+import { ChildProcess, spawn } from "child_process";
+import { EventEmitter } from "events";
+
+vi.mock("child_process", () => ({
+    spawn: vi.fn(),
+}));
+
+describe("bash tool", () => {
+    let spawnMock: vi.MockedFunction<typeof spawn>;
+    let childProcessMock: ChildProcess;
+    let stdoutMock: EventEmitter;
+    let stderrMock: EventEmitter;
+
+    beforeEach(() => {
+        childProcessMock = new EventEmitter() as ChildProcess;
+        stdoutMock = new EventEmitter();
+        stderrMock = new EventEmitter();
+        // @ts-expect-error - Mocking properties for testing
+        childProcessMock.stdout = stdoutMock;
+        // @ts-expect-error - Mocking properties for testing
+        childProcessMock.stderr = stderrMock;
+
+        spawnMock = vi.mocked(spawn).mockReturnValue(childProcessMock);
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it("should resolve with output on successful execution and use default timeout", async () => {
+        const args = bash.schema.shape.arguments.parse({ cmd: "ls -l" });
+        const promise = bash.implementation(args);
+
+        stdoutMock.emit("data", "file1.txt");
+        stdoutMock.emit("data", "file2.txt");
+        childProcessMock.emit("close", 0);
+
+        await expect(promise).resolves.toBe("file1.txtfile2.txt");
+        expect(spawnMock).toHaveBeenCalledWith("ls -l", {
+            cwd: process.cwd(),
+            shell: "/bin/bash",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 30000,
+        });
+    });
+
+    it("should use provided timeout", async () => {
+        const args = bash.schema.shape.arguments.parse({ cmd: "sleep 5", timeout: 5000 });
+        const promise = bash.implementation(args);
+
+        childProcessMock.emit("close", 0);
+
+        await expect(promise).resolves.toBe("");
+        expect(spawnMock).toHaveBeenCalledWith("sleep 5", {
+            cwd: process.cwd(),
+            shell: "/bin/bash",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 5000,
+        });
+    });
+
+    it("should reject with ToolError on non-zero exit code", async () => {
+        const args = bash.schema.shape.arguments.parse({ cmd: "ls non_existent_dir" });
+        const promise = bash.implementation(args);
+
+        stderrMock.emit("data", "ls: cannot access 'non_existent_dir': No such file or directory");
+        childProcessMock.emit("close", 2);
+
+        await expect(promise).rejects.toThrow(ToolError);
+        await expect(promise).rejects.toThrow(
+            "Command exited with code: 2\nOutput:\nls: cannot access 'non_existent_dir': No such file or directory",
+        );
+    });
+
+    it("should reject with ToolError on command start error", async () => {
+        const error = new Error("spawn ENOENT");
+        const args = bash.schema.shape.arguments.parse({ cmd: "invalid_command" });
+        const promise = bash.implementation(args);
+
+        childProcessMock.emit("error", error);
+
+        await expect(promise).rejects.toThrow(ToolError);
+        await expect(promise).rejects.toThrow(`Command failed to start: ${error.message}`);
+    });
+
+    it("should handle stderr output correctly", async () => {
+        const args = bash.schema.shape.arguments.parse({ cmd: "some_command" });
+        const promise = bash.implementation(args);
+
+        stderrMock.emit("data", "some error");
+        childProcessMock.emit("close", 1);
+
+        await expect(promise).rejects.toThrow("Command exited with code: 1\nOutput:\nsome error");
+    });
+});

tests/agent/tools/definitions/create.test.ts

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import create from "@/agent/tools/definitions/create";
+import { fileTracker, FileExistsError } from "@/agent/file-tracker";
+
+vi.mock("@/agent/file-tracker", () => ({
+    fileTracker: {
+        assertCanCreate: vi.fn(),
+        write: vi.fn(),
+    },
+    FileExistsError: class FileExistsError extends Error {
+        constructor(message: string) {
+            super(message);
+            this.name = "FileExistsError";
+        }
+    },
+}));
+
+describe("create tool", () => {
+    const mockArgs = {
+        path: "test.txt",
+        content: "hello world",
+    };
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it("should return a success message on successful creation", async () => {
+        vi.mocked(fileTracker.assertCanCreate).mockResolvedValue(undefined);
+        vi.mocked(fileTracker.write).mockResolvedValue(undefined);
+
+        const result = await create.implementation(mockArgs);
+
+        expect(result).toBe(`Successfully created file at ${mockArgs.path}`);
+        expect(fileTracker.assertCanCreate).toHaveBeenCalledWith(mockArgs.path);
+        expect(fileTracker.write).toHaveBeenCalledWith(mockArgs.path, mockArgs.content);
+    });
+
+    it("should return an error message if the file already exists", async () => {
+        const error = new FileExistsError(`File already exists at path: ${mockArgs.path}`);
+        vi.mocked(fileTracker.assertCanCreate).mockRejectedValue(error);
+
+        const result = await create.implementation(mockArgs);
+
+        expect(result).toBe(`Error: ${error.message}`);
+        expect(fileTracker.write).not.toHaveBeenCalled();
+    });
+
+    it("should return a generic error message for other errors", async () => {
+        const error = new Error("Something went wrong");
+        vi.mocked(fileTracker.assertCanCreate).mockRejectedValue(error);
+
+        const result = await create.implementation(mockArgs);
+
+        expect(result).toBe(`Error creating file: ${error.message}`);
+        expect(fileTracker.write).not.toHaveBeenCalled();
+    });
+
+    it("should return a message for unknown errors", async () => {
+        vi.mocked(fileTracker.assertCanCreate).mockRejectedValue("an unknown error");
+
+        const result = await create.implementation(mockArgs);
+
+        expect(result).toBe("An unknown error occurred while creating the file.");
+        expect(fileTracker.write).not.toHaveBeenCalled();
+    });
+});