@sundaeswap/sprinkles 0.6.0 → 0.7.0

package/src/Sprinkle/__tests__/tui-helpers.test.ts

@@ -0,0 +1,325 @@
+import { describe, expect, test, mock, beforeEach } from "bun:test";
+import { Type } from "@sinclair/typebox";
+import { promptAndExecute } from "../actions/tui-helpers.js";
+import { UserCancelledError } from "../types.js";
+import type { IAction } from "../actions/types.js";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+// Minimal action used throughout these tests
+const greetAction: IAction<{ name: string }, { greeting: string }, any> = {
+  name: "greet",
+  description: "Greets someone",
+  inputSchema: Type.Object({ name: Type.String() }),
+  outputSchema: Type.Object({ greeting: Type.String() }),
+  execute: async (input: { name: string }) => ({
+    greeting: `Hello, ${input.name}!`,
+  }),
+};
+
+// Build a minimal Sprinkle-shaped mock.  promptAndExecute only calls:
+//   - sprinkle.FillInStruct(schema, defaults)
+//   - sprinkle.settings  (read once for context)
+// so we only need those two members.
+function makeMockSprinkle(fillInStructImpl: (schema: any, defaults?: any) => Promise<any>) {
+  return {
+    FillInStruct: mock(fillInStructImpl),
+    settings: { apiUrl: "https://example.com" },
+  } as any;
+}
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – success path
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – success path", () => {
+  test("returns success result when FillInStruct resolves", async () => {
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Alice" }));
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toEqual({ greeting: "Hello, Alice!" });
+    }
+  });
+
+  test("passes the schema from the action to FillInStruct", async () => {
+    let capturedSchema: any;
+    const sprinkle = makeMockSprinkle(async (schema: any) => {
+      capturedSchema = schema;
+      return { name: "Bob" };
+    });
+
+    await promptAndExecute(sprinkle, greetAction);
+
+    expect(capturedSchema).toBe(greetAction.inputSchema);
+  });
+
+  test("passes action execute function the validated input", async () => {
+    let capturedInput: any;
+    const action = {
+      ...greetAction,
+      execute: async (input: { name: string }) => {
+        capturedInput = input;
+        return { greeting: `Hi, ${input.name}!` };
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Charlie" }));
+
+    await promptAndExecute(sprinkle, action);
+
+    expect(capturedInput).toEqual({ name: "Charlie" });
+  });
+
+  test("provides the sprinkle instance via context to execute", async () => {
+    let capturedContext: any;
+    const action = {
+      ...greetAction,
+      execute: async (_input: any, ctx: any) => {
+        capturedContext = ctx;
+        return { greeting: "hi" };
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Dan" }));
+
+    await promptAndExecute(sprinkle, action);
+
+    // The context's sprinkle should refer to the same mock instance
+    expect(capturedContext).toBeDefined();
+    expect(capturedContext.sprinkle).toBe(sprinkle);
+  });
+
+  test("provides sprinkle.settings via context to execute", async () => {
+    let capturedSettings: any;
+    const action = {
+      ...greetAction,
+      execute: async (_input: any, ctx: any) => {
+        capturedSettings = ctx.settings;
+        return { greeting: "hi" };
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Eve" }));
+
+    await promptAndExecute(sprinkle, action);
+
+    expect(capturedSettings).toEqual({ apiUrl: "https://example.com" });
+  });
+
+  test("returns failure when execute throws an Error", async () => {
+    const action = {
+      ...greetAction,
+      execute: async () => {
+        throw new Error("execute failed");
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => ({ name: "Fail" }));
+
+    const result = await promptAndExecute(sprinkle, action);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("EXECUTION_ERROR");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – defaults parameter
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – defaults parameter", () => {
+  test("passes defaults to FillInStruct when provided", async () => {
+    let capturedDefaults: any;
+    const sprinkle = makeMockSprinkle(async (_schema: any, defaults: any) => {
+      capturedDefaults = defaults;
+      return { name: "Frank" };
+    });
+
+    await promptAndExecute(sprinkle, greetAction, { name: "Frank" });
+
+    expect(capturedDefaults).toEqual({ name: "Frank" });
+  });
+
+  test("passes undefined to FillInStruct when defaults are omitted", async () => {
+    let capturedDefaults: any = "sentinel";
+    const sprinkle = makeMockSprinkle(async (_schema: any, defaults: any) => {
+      capturedDefaults = defaults;
+      return { name: "Grace" };
+    });
+
+    await promptAndExecute(sprinkle, greetAction);
+
+    expect(capturedDefaults).toBeUndefined();
+  });
+
+  test("passes partial defaults to FillInStruct", async () => {
+    // Action with multiple fields so we can supply only some defaults
+    const multiAction: IAction<{ name: string; count: number }, { result: string }, any> = {
+      name: "multi",
+      description: "Takes multiple fields",
+      inputSchema: Type.Object({ name: Type.String(), count: Type.Number() }),
+      outputSchema: Type.Object({ result: Type.String() }),
+      execute: async (input) => ({ result: `${input.name}:${input.count}` }),
+    };
+
+    let capturedDefaults: any;
+    const sprinkle = makeMockSprinkle(async (_schema: any, defaults: any) => {
+      capturedDefaults = defaults;
+      return { name: "Henry", count: 42 };
+    });
+
+    await promptAndExecute(sprinkle, multiAction, { name: "Henry" });
+
+    expect(capturedDefaults).toEqual({ name: "Henry" });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – UserCancelledError handling
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – UserCancelledError handling", () => {
+  test("returns IActionFailure with code USER_CANCELLED when FillInStruct throws UserCancelledError", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new UserCancelledError("cancelled");
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("USER_CANCELLED");
+    }
+  });
+
+  test("does not throw when FillInStruct throws UserCancelledError", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new UserCancelledError();
+    });
+
+    // Should resolve (not reject)
+    await expect(promptAndExecute(sprinkle, greetAction)).resolves.toBeDefined();
+  });
+
+  test("USER_CANCELLED failure has a descriptive message", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new UserCancelledError("user pressed escape");
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(typeof result.error.message).toBe("string");
+      expect(result.error.message.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("USER_CANCELLED failure carries the original UserCancelledError as details", async () => {
+    const cancelled = new UserCancelledError("esc pressed");
+    const sprinkle = makeMockSprinkle(async () => {
+      throw cancelled;
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.details).toBe(cancelled);
+    }
+  });
+
+  test("does not call execute when FillInStruct throws UserCancelledError", async () => {
+    let executeCalled = false;
+    const action = {
+      ...greetAction,
+      execute: async (_input: any) => {
+        executeCalled = true;
+        return { greeting: "hi" };
+      },
+    };
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new UserCancelledError();
+    });
+
+    await promptAndExecute(sprinkle, action);
+
+    expect(executeCalled).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – unexpected FillInStruct errors
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – unexpected FillInStruct errors", () => {
+  test("returns IActionFailure with code PROMPT_ERROR when FillInStruct throws a non-UserCancelledError", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new Error("TTY not available");
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("PROMPT_ERROR");
+    }
+  });
+
+  test("PROMPT_ERROR message includes the original error message", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new Error("underlying prompt failure");
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.message).toContain("underlying prompt failure");
+    }
+  });
+
+  test("does not throw when FillInStruct throws an unexpected error", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      throw new Error("unexpected");
+    });
+
+    await expect(promptAndExecute(sprinkle, greetAction)).resolves.toBeDefined();
+  });
+
+  test("PROMPT_ERROR result includes non-Error thrown values in message", async () => {
+    const sprinkle = makeMockSprinkle(async () => {
+      // eslint-disable-next-line @typescript-eslint/only-throw-error
+      throw "some string error";
+    });
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("PROMPT_ERROR");
+      expect(result.error.message).toContain("some string error");
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// describe: promptAndExecute – input validation
+// ---------------------------------------------------------------------------
+
+describe("promptAndExecute – input validation", () => {
+  test("returns VALIDATION_ERROR when FillInStruct returns data that fails schema validation", async () => {
+    // FillInStruct returns a value that does not conform to the inputSchema
+    const sprinkle = makeMockSprinkle(async () => ({ name: 42 })); // name should be a string
+
+    const result = await promptAndExecute(sprinkle, greetAction);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.code).toBe("VALIDATION_ERROR");
+    }
+  });
+});