@stigmer/react 3.5.2 → 3.6.0

package/src/schedule/__tests__/scheduleCreation.test.tsx

@@ -0,0 +1,340 @@
+import { describe, it, expect, vi, beforeAll, afterEach, beforeEach } from "vitest";
+import {
+  render,
+  screen,
+  cleanup,
+  fireEvent,
+  waitFor,
+} from "@testing-library/react";
+import { renderHook, act } from "@testing-library/react";
+import { useState, type ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import { ScheduleSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { useCreateSchedule } from "../useCreateSchedule";
+import { CadenceField } from "../CadenceField";
+import { ScheduleForm } from "../ScheduleForm";
+import type { CadencePreset } from "../cadence";
+
+// Without a StigmerProvider the portal container is null, and Base UI's
+// Portal renders nothing — pin it to document.body so the agent-picker
+// popover mounts.
+vi.mock("../../portal-container", () => ({
+  useStigmerPortalContainer: () => document.body,
+}));
+
+// Base UI's Popover positioner observes its anchor; happy-dom lacks
+// ResizeObserver, so provide a no-op shim.
+beforeAll(() => {
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver =
+      class {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+      };
+  }
+});
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+const CREATED = create(ScheduleSchema, {
+  metadata: {
+    id: "sch_01new",
+    name: "daily-fee-reminders",
+    slug: "daily-fee-reminders",
+    org: "isc",
+  },
+  spec: { cron: "0 9 * * *", timeZone: "Asia/Kolkata", enabled: false },
+});
+
+const AGENT_RESULT = {
+  id: "agt_01example",
+  org: "isc",
+  slug: "fee-reminder",
+  name: "Fee Reminder",
+  description: "Sends fee reminders.",
+};
+
+beforeEach(() => vi.clearAllMocks());
+afterEach(cleanup);
+
+// ---------------------------------------------------------------------------
+// useCreateSchedule
+// ---------------------------------------------------------------------------
+
+describe("useCreateSchedule", () => {
+  it("applies the input and returns the created schedule", async () => {
+    const apply = vi.fn().mockResolvedValue(CREATED);
+    const client = { schedule: { apply } };
+
+    const { result } = renderHook(() => useCreateSchedule(), {
+      wrapper: wrapper(client),
+    });
+
+    const input = {
+      name: "daily-fee-reminders",
+      org: "isc",
+      cron: "0 9 * * *",
+      timeZone: "Asia/Kolkata",
+      enabled: false,
+      agent: {
+        agentRef: { org: "isc", slug: "fee-reminder" },
+        message: "Send today's reminders.",
+      },
+    };
+
+    let returned: unknown;
+    await act(async () => {
+      returned = await result.current.create(input);
+    });
+
+    expect(apply).toHaveBeenCalledWith(input);
+    expect(returned).toBe(CREATED);
+    expect(result.current.isCreating).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("captures the error, rethrows, and clears via clearError", async () => {
+    const failure = new Error("agent 'isc/fee-reminder' not found");
+    const apply = vi.fn().mockRejectedValue(failure);
+    const client = { schedule: { apply } };
+
+    const { result } = renderHook(() => useCreateSchedule(), {
+      wrapper: wrapper(client),
+    });
+
+    await act(async () => {
+      await expect(
+        result.current.create({ name: "x", org: "isc" }),
+      ).rejects.toThrow(failure);
+    });
+
+    expect(result.current.error).toBe(failure);
+
+    act(() => result.current.clearError());
+    expect(result.current.error).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// CadenceField
+// ---------------------------------------------------------------------------
+
+function ControlledCadenceField({ initial }: { initial: CadencePreset }) {
+  const [value, setValue] = useState<CadencePreset>(initial);
+  return <CadenceField value={value} onChange={setValue} timeZone="UTC" />;
+}
+
+describe("CadenceField", () => {
+  it("summarizes the selected preset in plain English", () => {
+    render(
+      <ControlledCadenceField initial={{ kind: "daily", hour: 9, minute: 0 }} />,
+    );
+    expect(screen.getByTestId("cadence-summary").textContent).toBe(
+      "Every day at 09:00 (UTC)",
+    );
+  });
+
+  it("carries the time of day across preset switches", () => {
+    render(
+      <ControlledCadenceField initial={{ kind: "daily", hour: 9, minute: 30 }} />,
+    );
+    fireEvent.click(screen.getByRole("radio", { name: "Weekly" }));
+    expect(screen.getByTestId("cadence-summary").textContent).toBe(
+      "Every Monday at 09:30 (UTC)",
+    );
+  });
+
+  it("prefills the custom escape hatch with the generated cron", () => {
+    render(
+      <ControlledCadenceField initial={{ kind: "daily", hour: 9, minute: 0 }} />,
+    );
+    fireEvent.click(screen.getByRole("radio", { name: "Custom cron" }));
+    expect(
+      (screen.getByRole("textbox", { name: "Cron expression" }) as HTMLInputElement)
+        .value,
+    ).toBe("0 9 * * *");
+  });
+
+  it("rejects invalid custom cron with the server's wording", () => {
+    render(
+      <ControlledCadenceField initial={{ kind: "custom", cron: "@every 30s" }} />,
+    );
+    expect(screen.getByRole("alert").textContent).toBe(
+      "spec.cron must be a calendar expression — @every intervals are not supported",
+    );
+    expect(screen.queryByTestId("cadence-summary")).toBeNull();
+  });
+
+  it("keeps the last selected weekly day locked", () => {
+    render(
+      <ControlledCadenceField
+        initial={{ kind: "weekly", days: [1], hour: 9, minute: 0 }}
+      />,
+    );
+    const monday = screen.getByRole("button", { name: "Monday" });
+    expect((monday as HTMLButtonElement).disabled).toBe(true);
+
+    fireEvent.click(screen.getByRole("button", { name: "Friday" }));
+    expect(
+      (screen.getByRole("button", { name: "Monday" }) as HTMLButtonElement)
+        .disabled,
+    ).toBe(false);
+  });
+
+  it("warns that days 29-31 skip shorter months", () => {
+    render(
+      <ControlledCadenceField
+        initial={{ kind: "monthly", day: 31, hour: 9, minute: 0 }}
+      />,
+    );
+    expect(screen.getByText(/Months without day 31 are skipped/)).toBeTruthy();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// ScheduleForm
+// ---------------------------------------------------------------------------
+
+function createClient(overrides?: {
+  apply?: ReturnType<typeof vi.fn>;
+  list?: ReturnType<typeof vi.fn>;
+}) {
+  return {
+    schedule: { apply: overrides?.apply ?? vi.fn().mockResolvedValue(CREATED) },
+    agent: {
+      list:
+        overrides?.list ?? vi.fn().mockResolvedValue({ entries: [AGENT_RESULT] }),
+    },
+  };
+}
+
+async function pickAgent() {
+  fireEvent.click(screen.getByText("Choose an agent…"));
+  const result = await screen.findByRole("option", { name: /Fee Reminder/ });
+  fireEvent.click(result);
+}
+
+describe("ScheduleForm", () => {
+  it("disables submit until name, agent, and message are provided", async () => {
+    const client = createClient();
+    render(<ScheduleForm org="isc" />, { wrapper: wrapper(client) });
+
+    const submit = screen.getByRole("button", { name: "Create schedule" });
+    expect((submit as HTMLButtonElement).disabled).toBe(true);
+
+    fireEvent.change(screen.getByLabelText("Name"), {
+      target: { value: "daily-fee-reminders" },
+    });
+    fireEvent.change(screen.getByLabelText("Message"), {
+      target: { value: "Send today's reminders." },
+    });
+    expect((submit as HTMLButtonElement).disabled).toBe(true);
+
+    await pickAgent();
+    expect((submit as HTMLButtonElement).disabled).toBe(false);
+  });
+
+  it("locks the agent picker to org scope (no Org/All toggle)", async () => {
+    const client = createClient();
+    render(<ScheduleForm org="isc" />, { wrapper: wrapper(client) });
+
+    fireEvent.click(screen.getByText("Choose an agent…"));
+    await screen.findByRole("option", { name: /Fee Reminder/ });
+
+    expect(
+      screen.queryByRole("radiogroup", { name: "Resource scope" }),
+    ).toBeNull();
+  });
+
+  it("submits the generated cron, browser time zone, and staged-disabled default", async () => {
+    const apply = vi.fn().mockResolvedValue(CREATED);
+    const client = createClient({ apply });
+    const onComplete = vi.fn();
+
+    render(<ScheduleForm org="isc" onComplete={onComplete} />, {
+      wrapper: wrapper(client),
+    });
+
+    fireEvent.change(screen.getByLabelText("Name"), {
+      target: { value: "daily-fee-reminders" },
+    });
+    fireEvent.change(screen.getByLabelText("Message"), {
+      target: { value: "  Send today's reminders.  " },
+    });
+    await pickAgent();
+
+    fireEvent.click(screen.getByRole("button", { name: "Create schedule" }));
+
+    await waitFor(() => expect(onComplete).toHaveBeenCalledWith(CREATED));
+    expect(apply).toHaveBeenCalledWith({
+      name: "daily-fee-reminders",
+      org: "isc",
+      // The default cadence: daily at 09:00.
+      cron: "0 9 * * *",
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+      // Staged-disabled by default — validate with Run now, then enable.
+      enabled: false,
+      agent: {
+        agentRef: { org: "isc", slug: "fee-reminder", kind: 40 },
+        message: "Send today's reminders.",
+      },
+    });
+  });
+
+  it("surfaces the server error verbatim and stays editable", async () => {
+    const apply = vi
+      .fn()
+      .mockRejectedValue(
+        new Error(
+          "spec.cron must be a calendar expression — @every intervals are not supported",
+        ),
+      );
+    const client = createClient({ apply });
+    const onComplete = vi.fn();
+
+    render(<ScheduleForm org="isc" onComplete={onComplete} />, {
+      wrapper: wrapper(client),
+    });
+
+    fireEvent.change(screen.getByLabelText("Name"), {
+      target: { value: "daily-fee-reminders" },
+    });
+    fireEvent.change(screen.getByLabelText("Message"), {
+      target: { value: "Send today's reminders." },
+    });
+    await pickAgent();
+    fireEvent.click(screen.getByRole("button", { name: "Create schedule" }));
+
+    const alert = await screen.findByRole("alert");
+    expect(alert.textContent).toContain("@every intervals are not supported");
+    expect(onComplete).not.toHaveBeenCalled();
+    expect(
+      (screen.getByRole("button", { name: "Create schedule" }) as HTMLButtonElement)
+        .disabled,
+    ).toBe(false);
+  });
+
+  it("fires onCancel", () => {
+    const client = createClient();
+    const onCancel = vi.fn();
+    render(<ScheduleForm org="isc" onCancel={onCancel} />, {
+      wrapper: wrapper(client),
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
+    expect(onCancel).toHaveBeenCalled();
+  });
+});

package/src/schedule/__tests__/scheduleHooks.test.tsx

@@ -0,0 +1,312 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { clone, create, equals } from "@bufbuild/protobuf";
+import { ScheduleSchema, type Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { ScheduleListSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/io_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { StigmerError } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { useSchedule } from "../useSchedule";
+import { useScheduleList } from "../useScheduleList";
+import { useScheduleCount } from "../useScheduleCount";
+import { useResumeSchedule } from "../useResumeSchedule";
+import { useTriggerSchedule } from "../useTriggerSchedule";
+import { useSetScheduleEnabled } from "../useSetScheduleEnabled";
+
+vi.mock("../../feedback/toast", () => ({
+  toast: Object.assign(vi.fn(), { success: vi.fn(), error: vi.fn() }),
+}));
+
+import { toast } from "../../feedback/toast";
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+// Shaped like a server-returned schedule, including metadata the curated
+// ScheduleInput cannot express (tags) — the round-trip canary.
+const SCHEDULE = create(ScheduleSchema, {
+  apiVersion: "agentic.stigmer.ai/v1",
+  kind: "Schedule",
+  metadata: {
+    id: "sch_01example",
+    name: "daily-fee-reminders",
+    slug: "daily-fee-reminders",
+    org: "isc",
+    tags: ["billing"],
+    labels: { team: "ops" },
+  },
+  spec: {
+    cron: "0 9 * * *",
+    timeZone: "Asia/Kolkata",
+    enabled: true,
+    target: {
+      case: "agent",
+      value: {
+        agentRef: { kind: ApiResourceKind.agent, org: "isc", slug: "fee-reminder" },
+        message: "Send today's fee reminders.",
+      },
+    },
+  },
+  status: { consecutiveFailures: 2 },
+});
+
+beforeEach(() => vi.clearAllMocks());
+
+// ---------------------------------------------------------------------------
+// Data hooks
+// ---------------------------------------------------------------------------
+
+describe("useSchedule", () => {
+  it("fetches a schedule by org/slug reference", async () => {
+    const getByReference = vi.fn().mockResolvedValue(SCHEDULE);
+    const client = { schedule: { getByReference } };
+
+    const { result } = renderHook(() => useSchedule("isc", "daily-fee-reminders"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.schedule).toBe(SCHEDULE);
+    expect(result.current.error).toBeNull();
+    expect(getByReference).toHaveBeenCalledWith({
+      org: "isc",
+      slug: "daily-fee-reminders",
+    });
+  });
+
+  it("treats NOT_FOUND as null, not an error", async () => {
+    // Positional ctor: (code, message, connectCode) — 5 is Connect NotFound.
+    const notFound = new StigmerError("not-found", "Schedule 'x' not found", 5);
+    const client = {
+      schedule: { getByReference: vi.fn().mockRejectedValue(notFound) },
+    };
+
+    const { result } = renderHook(() => useSchedule("isc", "x"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.schedule).toBeNull();
+    expect(result.current.error).toBeNull();
+  });
+
+  it("skips fetching when org or slug is null", () => {
+    const getByReference = vi.fn();
+    const client = { schedule: { getByReference } };
+
+    const { result } = renderHook(() => useSchedule(null, "x"), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(getByReference).not.toHaveBeenCalled();
+  });
+});
+
+describe("useScheduleList", () => {
+  it("fetches a page of full Schedule protos", async () => {
+    const list = vi.fn().mockResolvedValue(
+      create(ScheduleListSchema, { items: [SCHEDULE], totalCount: 1 }),
+    );
+    const client = { schedule: { list } };
+
+    const { result } = renderHook(() => useScheduleList("isc"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.schedules).toHaveLength(1);
+    expect(result.current.schedules[0].spec?.cron).toBe("0 9 * * *");
+    expect(result.current.totalCount).toBe(1);
+    expect(result.current.totalPages).toBe(1);
+  });
+
+  it("skips fetching when org is null", () => {
+    const list = vi.fn();
+    const client = { schedule: { list } };
+
+    const { result } = renderHook(() => useScheduleList(null), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.schedules).toEqual([]);
+    expect(list).not.toHaveBeenCalled();
+  });
+});
+
+describe("useScheduleCount", () => {
+  it("reads only the total count", async () => {
+    const list = vi.fn().mockResolvedValue(
+      create(ScheduleListSchema, { items: [SCHEDULE], totalCount: 7 }),
+    );
+    const client = { schedule: { list } };
+
+    const { result } = renderHook(() => useScheduleCount("isc"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.count).toBe(7);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Behavior hooks
+// ---------------------------------------------------------------------------
+
+describe("useResumeSchedule", () => {
+  it("resumes by id and toasts success", async () => {
+    const resume = vi.fn().mockResolvedValue(SCHEDULE);
+    const client = { schedule: { resume } };
+
+    const { result } = renderHook(() => useResumeSchedule(), {
+      wrapper: wrapper(client),
+    });
+
+    const resumed = await result.current.resumeSchedule("sch_01example");
+
+    expect(resumed).toBe(SCHEDULE);
+    expect(resume).toHaveBeenCalledWith("sch_01example");
+    expect(toast.success).toHaveBeenCalledWith("Schedule resumed");
+  });
+
+  it("relays a failure and sets error state", async () => {
+    const failure = new Error("boom");
+    const client = { schedule: { resume: vi.fn().mockRejectedValue(failure) } };
+
+    const { result } = renderHook(() => useResumeSchedule(), {
+      wrapper: wrapper(client),
+    });
+
+    await expect(result.current.resumeSchedule("sch_x")).rejects.toThrow("boom");
+    await waitFor(() => expect(result.current.error?.message).toBe("boom"));
+    expect(toast.error).toHaveBeenCalled();
+  });
+});
+
+describe("useTriggerSchedule", () => {
+  it("triggers by id and toasts success", async () => {
+    const trigger = vi.fn().mockResolvedValue(SCHEDULE);
+    const client = { schedule: { trigger } };
+
+    const { result } = renderHook(() => useTriggerSchedule(), {
+      wrapper: wrapper(client),
+    });
+
+    await result.current.triggerSchedule("sch_01example");
+
+    expect(trigger).toHaveBeenCalledWith("sch_01example");
+    expect(toast.success).toHaveBeenCalledWith("Run started");
+  });
+
+  it("relays the server's refusal copy verbatim", async () => {
+    // The backend's refusal matrix copy is byte-identical across editions
+    // and names the remedy — the UI must not paraphrase it.
+    const refusal = new StigmerError(
+      "failed-precondition",
+      "schedule is disabled (spec.enabled=false) — enable it before triggering",
+      9, // Connect FailedPrecondition
+    );
+    const client = { schedule: { trigger: vi.fn().mockRejectedValue(refusal) } };
+
+    const { result } = renderHook(() => useTriggerSchedule(), {
+      wrapper: wrapper(client),
+    });
+
+    await expect(result.current.triggerSchedule("sch_x")).rejects.toThrow();
+    expect(toast.error).toHaveBeenCalledWith(
+      "schedule is disabled (spec.enabled=false) — enable it before triggering",
+    );
+  });
+});
+
+describe("useSetScheduleEnabled", () => {
+  it("re-applies the full proto with only spec.enabled flipped", async () => {
+    const apply = vi.fn(async (doc: { message: unknown }) => ({
+      yamlKind: "Schedule",
+      displayName: "Schedule",
+      name: "daily-fee-reminders",
+      slug: "daily-fee-reminders",
+      org: "isc",
+      id: "sch_01example",
+      message: doc.message,
+    }));
+    const client = { manifest: { apply } };
+
+    const { result } = renderHook(() => useSetScheduleEnabled(), {
+      wrapper: wrapper(client),
+    });
+
+    const applied = await result.current.setEnabled(SCHEDULE, false);
+
+    // The apply went through the manifest engine with a real
+    // ManifestDocument (registry handler resolved from the proto type).
+    expect(apply).toHaveBeenCalledOnce();
+    const doc = apply.mock.calls[0][0] as {
+      handler: { yamlKind: string };
+      message: Schedule;
+    };
+    expect(doc.handler.yamlKind).toBe("Schedule");
+
+    // Round-trip field preservation: everything survives except the
+    // flipped flag. In particular metadata.tags — the field the curated
+    // ScheduleInput path would have silently wiped.
+    const expected = clone(ScheduleSchema, SCHEDULE);
+    expected.spec!.enabled = false;
+    expect(equals(ScheduleSchema, doc.message, expected)).toBe(true);
+    expect(doc.message.metadata?.tags).toEqual(["billing"]);
+
+    // The caller's copy is never mutated.
+    expect(SCHEDULE.spec?.enabled).toBe(true);
+
+    expect((applied as Schedule).spec?.enabled).toBe(false);
+    expect(toast.success).toHaveBeenCalledWith("Schedule disabled");
+  });
+
+  it("toasts 'enabled' when turning the schedule on", async () => {
+    const disabled = clone(ScheduleSchema, SCHEDULE);
+    disabled.spec!.enabled = false;
+    const apply = vi.fn(async (doc: { message: unknown }) => ({
+      yamlKind: "Schedule",
+      displayName: "Schedule",
+      name: "daily-fee-reminders",
+      slug: "daily-fee-reminders",
+      org: "isc",
+      id: "sch_01example",
+      message: doc.message,
+    }));
+    const client = { manifest: { apply } };
+
+    const { result } = renderHook(() => useSetScheduleEnabled(), {
+      wrapper: wrapper(client),
+    });
+
+    await result.current.setEnabled(disabled, true);
+    expect(toast.success).toHaveBeenCalledWith("Schedule enabled");
+  });
+
+  it("rejects a schedule without a spec", async () => {
+    const bare = create(ScheduleSchema, {
+      metadata: { name: "x", org: "isc" },
+    });
+    const client = { manifest: { apply: vi.fn() } };
+
+    const { result } = renderHook(() => useSetScheduleEnabled(), {
+      wrapper: wrapper(client),
+    });
+
+    await expect(result.current.setEnabled(bare, true)).rejects.toThrow(/no spec/);
+    expect(client.manifest.apply).not.toHaveBeenCalled();
+  });
+});