@aria-cli/tools 1.0.0

package/tests/registry-validation.test.ts

@@ -0,0 +1,424 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { ToolRegistry, validateToolInput } from "../src/registry/index.js";
+import type { Tool, ToolContext, ToolResult } from "../src/types.js";
+
+// --------------------------------------------------------------------------
+// Helpers
+// --------------------------------------------------------------------------
+
+/** Minimal ToolContext for tests */
+const createTestContext = (): ToolContext => ({
+  workingDir: "/tmp/test",
+  env: { NODE_ENV: "test" },
+  confirm: async () => true,
+});
+
+/** Create a mock tool with a given JSON Schema for its parameters */
+const createMockTool = (
+  name: string,
+  parameters: Record<string, unknown>,
+  executeFn?: Tool["execute"],
+): Tool => ({
+  name,
+  description: `Mock tool: ${name}`,
+  category: "meta",
+  parameters: parameters as Tool["parameters"],
+  riskLevel: "safe",
+  execute:
+    executeFn ??
+    (async (input: unknown): Promise<ToolResult> => ({
+      success: true,
+      message: "executed",
+      data: input,
+    })),
+});
+
+// --------------------------------------------------------------------------
+// Unit tests for validateToolInput (standalone function)
+// --------------------------------------------------------------------------
+
+describe("validateToolInput", () => {
+  it("returns null for non-object schema types (skip validation)", () => {
+    expect(validateToolInput("anything", { type: "string" })).toBeNull();
+    expect(validateToolInput(42, { type: "number" })).toBeNull();
+  });
+
+  it("returns null for valid input with no required properties", () => {
+    const schema = {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+      },
+    };
+    expect(validateToolInput({ name: "Alice" }, schema)).toBeNull();
+    expect(validateToolInput({}, schema)).toBeNull();
+  });
+
+  it("returns error for missing required properties", () => {
+    const schema = {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        content: { type: "string" },
+      },
+      required: ["path", "content"],
+    };
+
+    const error = validateToolInput({ path: "/tmp" }, schema);
+    expect(error).not.toBeNull();
+    expect(error).toContain("content");
+    expect(error).toContain("Missing required");
+  });
+
+  it("returns error when input is not an object", () => {
+    const schema = {
+      type: "object",
+      properties: {},
+    };
+
+    expect(validateToolInput("hello", schema)).toContain("Expected an object");
+    expect(validateToolInput(42, schema)).toContain("Expected an object");
+    expect(validateToolInput([1, 2], schema)).toContain("Expected an object");
+    expect(validateToolInput(true, schema)).toContain("Expected an object");
+  });
+
+  it("returns error when null/undefined input has required fields", () => {
+    const schema = {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"],
+    };
+
+    expect(validateToolInput(null, schema)).toContain("got null");
+    expect(validateToolInput(undefined, schema)).toContain("got undefined");
+  });
+
+  it("allows null/undefined input when no required fields", () => {
+    const schema = {
+      type: "object",
+      properties: { id: { type: "string" } },
+    };
+
+    expect(validateToolInput(null, schema)).toBeNull();
+    expect(validateToolInput(undefined, schema)).toBeNull();
+  });
+
+  describe("type checking", () => {
+    const schema = {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        count: { type: "number" },
+        active: { type: "boolean" },
+        tags: { type: "array" },
+        meta: { type: "object" },
+        index: { type: "integer" },
+      },
+    };
+
+    it("accepts correct types", () => {
+      expect(
+        validateToolInput(
+          {
+            name: "Alice",
+            count: 42,
+            active: true,
+            tags: ["a", "b"],
+            meta: { x: 1 },
+            index: 5,
+          },
+          schema,
+        ),
+      ).toBeNull();
+    });
+
+    it("rejects string where number expected", () => {
+      const err = validateToolInput({ count: "not-a-number" }, schema);
+      expect(err).toContain("count");
+      expect(err).toContain("number");
+      expect(err).toContain("string");
+    });
+
+    it("rejects number where string expected", () => {
+      const err = validateToolInput({ name: 123 }, schema);
+      expect(err).toContain("name");
+      expect(err).toContain("string");
+      expect(err).toContain("number");
+    });
+
+    it("rejects string where boolean expected", () => {
+      const err = validateToolInput({ active: "yes" }, schema);
+      expect(err).toContain("active");
+      expect(err).toContain("boolean");
+    });
+
+    it("rejects object where array expected", () => {
+      const err = validateToolInput({ tags: { a: 1 } }, schema);
+      expect(err).toContain("tags");
+      expect(err).toContain("array");
+      expect(err).toContain("object");
+    });
+
+    it("rejects array where object expected", () => {
+      const err = validateToolInput({ meta: [1, 2] }, schema);
+      expect(err).toContain("meta");
+      expect(err).toContain("object");
+      expect(err).toContain("array");
+    });
+
+    it("rejects float where integer expected", () => {
+      const err = validateToolInput({ index: 3.14 }, schema);
+      expect(err).toContain("index");
+      expect(err).toContain("integer");
+    });
+
+    it("accepts integer for integer type", () => {
+      expect(validateToolInput({ index: 5 }, schema)).toBeNull();
+    });
+
+    it("handles union types (e.g., ['string', 'null'])", () => {
+      const unionSchema = {
+        type: "object",
+        properties: {
+          value: { type: ["string", "null"] },
+        },
+      };
+      expect(validateToolInput({ value: "hello" }, unionSchema)).toBeNull();
+      expect(validateToolInput({ value: null }, unionSchema)).toBeNull();
+      const err = validateToolInput({ value: 42 }, unionSchema);
+      expect(err).toContain("value");
+      expect(err).toContain("string | null");
+    });
+  });
+
+  describe("additionalProperties: false", () => {
+    it("rejects unknown properties when additionalProperties is false", () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+        },
+        additionalProperties: false,
+      };
+
+      const err = validateToolInput({ name: "Alice", extra: true }, schema);
+      expect(err).toContain("Unknown properties");
+      expect(err).toContain("extra");
+    });
+
+    it("allows unknown properties when additionalProperties is not false", () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+        },
+      };
+
+      expect(validateToolInput({ name: "Alice", extra: true }, schema)).toBeNull();
+    });
+
+    it("allows unknown properties when additionalProperties is true", () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+        },
+        additionalProperties: true,
+      };
+
+      expect(validateToolInput({ name: "Alice", extra: true }, schema)).toBeNull();
+    });
+  });
+
+  it("skips properties without a type annotation", () => {
+    const schema = {
+      type: "object",
+      properties: {
+        anything: {},
+      },
+    };
+    // no type on the property, so any value should pass
+    expect(validateToolInput({ anything: 42 }, schema)).toBeNull();
+    expect(validateToolInput({ anything: "hello" }, schema)).toBeNull();
+  });
+});
+
+// --------------------------------------------------------------------------
+// Integration tests for ToolRegistry.execute()
+// --------------------------------------------------------------------------
+
+describe("ToolRegistry.execute()", () => {
+  let registry: ToolRegistry;
+  const ctx = createTestContext();
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+  });
+
+  it("returns error for unregistered tool", async () => {
+    const result = await registry.execute("nonexistent", {}, ctx);
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("not registered");
+  });
+
+  it("passes valid input through to executor", async () => {
+    const executeSpy = vi.fn(async () => ({
+      success: true as const,
+      message: "ok",
+      data: "result",
+    }));
+
+    registry.register(
+      createMockTool(
+        "test_tool",
+        {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+          },
+          required: ["path"],
+        },
+        executeSpy,
+      ),
+    );
+
+    const result = await registry.execute("test_tool", { path: "/tmp" }, ctx);
+    expect(result.success).toBe(true);
+    expect(executeSpy).toHaveBeenCalledWith({ path: "/tmp" }, ctx);
+  });
+
+  it("returns structured error for missing required param", async () => {
+    const executeSpy = vi.fn(async () => ({
+      success: true as const,
+      message: "should not be called",
+    }));
+
+    registry.register(
+      createMockTool(
+        "write_file",
+        {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+            content: { type: "string" },
+          },
+          required: ["path", "content"],
+        },
+        executeSpy,
+      ),
+    );
+
+    const result = await registry.execute("write_file", { path: "/tmp" }, ctx);
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("Invalid input");
+    expect(result.message).toContain("content");
+    // Executor should NOT have been called
+    expect(executeSpy).not.toHaveBeenCalled();
+  });
+
+  it("returns structured error for wrong type", async () => {
+    const executeSpy = vi.fn(async () => ({
+      success: true as const,
+      message: "should not be called",
+    }));
+
+    registry.register(
+      createMockTool(
+        "count_tool",
+        {
+          type: "object",
+          properties: {
+            count: { type: "number" },
+          },
+        },
+        executeSpy,
+      ),
+    );
+
+    const result = await registry.execute("count_tool", { count: "not-a-number" }, ctx);
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("Invalid input");
+    expect(result.message).toContain("count");
+    expect(executeSpy).not.toHaveBeenCalled();
+  });
+
+  it("skips validation for tools without parameters schema", async () => {
+    // Tool with an empty/minimal parameters object (not type: "object")
+    const executeSpy = vi.fn(async () => ({
+      success: true as const,
+      message: "ok",
+    }));
+
+    const tool = createMockTool("no_schema_tool", {}, executeSpy);
+    registry.register(tool);
+
+    const result = await registry.execute("no_schema_tool", "anything", ctx);
+    expect(result.success).toBe(true);
+    expect(executeSpy).toHaveBeenCalledWith("anything", ctx);
+  });
+
+  it("skips validation for non-object schema types", async () => {
+    const executeSpy = vi.fn(async () => ({
+      success: true as const,
+      message: "ok",
+    }));
+
+    const tool = createMockTool("string_schema", { type: "string" }, executeSpy);
+    registry.register(tool);
+
+    const result = await registry.execute("string_schema", "hello", ctx);
+    expect(result.success).toBe(true);
+    expect(executeSpy).toHaveBeenCalledWith("hello", ctx);
+  });
+
+  it("rejects unknown properties when additionalProperties is false", async () => {
+    const executeSpy = vi.fn(async () => ({
+      success: true as const,
+      message: "should not be called",
+    }));
+
+    registry.register(
+      createMockTool(
+        "strict_tool",
+        {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+          },
+          additionalProperties: false,
+        },
+        executeSpy,
+      ),
+    );
+
+    const result = await registry.execute("strict_tool", { name: "ok", rogue: true }, ctx);
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("Unknown properties");
+    expect(result.message).toContain("rogue");
+    expect(executeSpy).not.toHaveBeenCalled();
+  });
+
+  it("allows extra properties when additionalProperties is not false", async () => {
+    const executeSpy = vi.fn(async () => ({
+      success: true as const,
+      message: "ok",
+    }));
+
+    registry.register(
+      createMockTool(
+        "lenient_tool",
+        {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+          },
+        },
+        executeSpy,
+      ),
+    );
+
+    const result = await registry.execute("lenient_tool", { name: "ok", extra: 42 }, ctx);
+    expect(result.success).toBe(true);
+    expect(executeSpy).toHaveBeenCalled();
+  });
+});