@aria-cli/tools 1.0.9 → 1.0.11

package/tests/registry-validation.test.ts

@@ -1,424 +0,0 @@
-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();
-  });
-});