@stigmer/react 3.5.3 → 3.7.0

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

@@ -0,0 +1,399 @@
+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,
+  ScheduleTriggerResultSchema,
+  ScheduleRunListSchema,
+  ScheduleRunSchema,
+  ScheduleRunOutcome,
+  ScheduleRunOrigin,
+} 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 { useScheduleRuns } from "../useScheduleRuns";
+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("resolves a STARTED result and toasts success", async () => {
+    const started = create(ScheduleTriggerResultSchema, {
+      outcome: ScheduleRunOutcome.STARTED,
+      executionId: "aex_01run",
+      schedule: SCHEDULE,
+    });
+    const trigger = vi.fn().mockResolvedValue(started);
+    const client = { schedule: { trigger } };
+
+    const { result } = renderHook(() => useTriggerSchedule(), {
+      wrapper: wrapper(client),
+    });
+
+    const res = await result.current.triggerSchedule("sch_01example");
+
+    expect(trigger).toHaveBeenCalledWith("sch_01example");
+    expect(res.outcome).toBe(ScheduleRunOutcome.STARTED);
+    expect(res.executionId).toBe("aex_01run");
+    expect(toast.success).toHaveBeenCalledWith("Run started");
+  });
+
+  it("resolves a REFUSED result and toasts the gate's reason verbatim", async () => {
+    // A refused run is a SUCCESSFUL trigger honestly reported (DD-017
+    // D-6): the promise resolves, and the gate's own copy is surfaced,
+    // never paraphrased.
+    const refused = create(ScheduleTriggerResultSchema, {
+      outcome: ScheduleRunOutcome.REFUSED,
+      refusalReason:
+        "run refused: The organization cannot fund a scheduled run right now.",
+      schedule: SCHEDULE,
+    });
+    const trigger = vi.fn().mockResolvedValue(refused);
+    const client = { schedule: { trigger } };
+
+    const { result } = renderHook(() => useTriggerSchedule(), {
+      wrapper: wrapper(client),
+    });
+
+    const res = await result.current.triggerSchedule("sch_01example");
+
+    expect(res.outcome).toBe(ScheduleRunOutcome.REFUSED);
+    expect(toast.error).toHaveBeenCalledWith(
+      "run refused: The organization cannot fund a scheduled run right now.",
+    );
+    expect(toast.success).not.toHaveBeenCalled();
+  });
+
+  it("relays a trigger-level gRPC refusal (disabled) verbatim and rejects", async () => {
+    // A disabled schedule is refused at the trigger itself — a gRPC
+    // error, not a result. Copy is byte-identical across editions.
+    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("useScheduleRuns", () => {
+  it("fetches a schedule's run history, newest first", async () => {
+    const listRuns = vi.fn().mockResolvedValue(
+      create(ScheduleRunListSchema, {
+        totalCount: 2,
+        items: [
+          create(ScheduleRunSchema, {
+            scheduleId: "sch_01example",
+            origin: ScheduleRunOrigin.MANUAL,
+            outcome: ScheduleRunOutcome.STARTED,
+            executionId: "aex_01run",
+          }),
+          create(ScheduleRunSchema, {
+            scheduleId: "sch_01example",
+            origin: ScheduleRunOrigin.CRON,
+            outcome: ScheduleRunOutcome.REFUSED,
+            reason: "run refused: missing credential",
+          }),
+        ],
+      }),
+    );
+    const client = { schedule: { listRuns } };
+
+    const { result } = renderHook(() => useScheduleRuns("sch_01example"), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.runs).toHaveLength(2);
+    expect(result.current.totalCount).toBe(2);
+    expect(result.current.runs[1].reason).toBe("run refused: missing credential");
+  });
+
+  it("skips fetching when scheduleId is null", () => {
+    const listRuns = vi.fn();
+    const client = { schedule: { listRuns } };
+
+    const { result } = renderHook(() => useScheduleRuns(null), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.runs).toEqual([]);
+    expect(listRuns).not.toHaveBeenCalled();
+  });
+});
+
+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();
+  });
+});

package/src/schedule/__tests__/scheduleListFn.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect, vi } from "vitest";
+import { create } 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 { createScheduleListFn, listSchedulesPage } from "../scheduleListFn";
+
+function schedules(count: number): Schedule[] {
+  return Array.from({ length: count }, (_, i) =>
+    create(ScheduleSchema, {
+      metadata: { id: `sch_${i}`, name: `sched-${i}`, slug: `sched-${i}`, org: "acme" },
+    }),
+  );
+}
+
+function clientReturning(items: Schedule[], totalCount: number) {
+  const list = vi
+    .fn()
+    .mockResolvedValue(create(ScheduleListSchema, { items, totalCount }));
+  return { client: { schedule: { list } }, list };
+}
+
+describe("listSchedulesPage", () => {
+  it("sends the org and requested page in the query", async () => {
+    const { client, list } = clientReturning([], 0);
+
+    await listSchedulesPage(client, "acme", { num: 2, size: 10 });
+
+    expect(list).toHaveBeenCalledOnce();
+    const request = list.mock.calls[0][0];
+    expect(request.org).toBe("acme");
+    expect(request.pageInfo?.num).toBe(2);
+    expect(request.pageInfo?.size).toBe(10);
+  });
+
+  it("defaults to page 1, size 20", async () => {
+    const { client, list } = clientReturning([], 0);
+
+    await listSchedulesPage(client, "acme");
+
+    const request = list.mock.calls[0][0];
+    expect(request.pageInfo?.num).toBe(1);
+    expect(request.pageInfo?.size).toBe(20);
+  });
+
+  // Cloud slices server-side: a response never exceeds the page size.
+  it("passes a cloud-shaped page through untouched", async () => {
+    const page = schedules(20);
+    const { client } = clientReturning(page, 50);
+
+    const result = await listSchedulesPage(client, "acme", { num: 2, size: 20 });
+
+    expect(result.items).toHaveLength(20);
+    expect(result.items[0].metadata?.slug).toBe("sched-0");
+    expect(result.totalCount).toBe(50);
+    expect(result.totalPages).toBe(3);
+  });
+
+  it("passes a cloud-shaped final short page through untouched", async () => {
+    const { client } = clientReturning(schedules(10), 50);
+
+    const result = await listSchedulesPage(client, "acme", { num: 3, size: 20 });
+
+    expect(result.items).toHaveLength(10);
+    expect(result.totalPages).toBe(3);
+  });
+
+  // OSS ignores page_info and returns the full org list — an overflowing
+  // response is the tell, and only then is the page sliced locally.
+  it("slices an OSS-shaped full-list response with absolute indices", async () => {
+    const { client } = clientReturning(schedules(50), 50);
+
+    const result = await listSchedulesPage(client, "acme", { num: 2, size: 20 });
+
+    expect(result.items).toHaveLength(20);
+    expect(result.items[0].metadata?.slug).toBe("sched-20");
+    expect(result.items[19].metadata?.slug).toBe("sched-39");
+    expect(result.totalCount).toBe(50);
+    expect(result.totalPages).toBe(3);
+  });
+
+  it("slices the OSS-shaped final short page correctly", async () => {
+    const { client } = clientReturning(schedules(50), 50);
+
+    const result = await listSchedulesPage(client, "acme", { num: 3, size: 20 });
+
+    expect(result.items).toHaveLength(10);
+    expect(result.items[0].metadata?.slug).toBe("sched-40");
+    expect(result.items[9].metadata?.slug).toBe("sched-49");
+  });
+
+  it("returns an empty page with zero totals", async () => {
+    const { client } = clientReturning([], 0);
+
+    const result = await listSchedulesPage(client, "acme");
+
+    expect(result.items).toEqual([]);
+    expect(result.totalCount).toBe(0);
+    expect(result.totalPages).toBe(0);
+  });
+});
+
+describe("createScheduleListFn", () => {
+  it("adapts ListParams to the direct query and back to ListResult", async () => {
+    const { client, list } = clientReturning(schedules(3), 3);
+    const listFn = createScheduleListFn(client);
+
+    const result = await listFn({
+      org: "acme",
+      // No server-side text search for schedules — ignored by contract.
+      query: "ignored",
+      excludePublic: false,
+      crossOrgPublic: false,
+      page: { num: 1, size: 20 },
+    });
+
+    expect(result.totalCount).toBe(3);
+    expect(result.totalPages).toBe(1);
+    expect(result.entries).toHaveLength(3);
+    // Entries are full Schedule protos occupying the SearchResult slot.
+    expect((result.entries[0] as unknown as Schedule).metadata?.slug).toBe("sched-0");
+
+    const request = list.mock.calls[0][0];
+    expect(request.org).toBe("acme");
+    // The query never reaches the wire: ListSchedulesRequest has no
+    // text-search field.
+    expect("query" in request && request.query).toBeFalsy();
+  });
+});

package/src/schedule/__tests__/scheduleState.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { ScheduleSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/spec_pb";
+import { ScheduleStatusSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/status_pb";
+import { deriveScheduleState, formatNextFire } from "../scheduleState";
+
+const enabledSpec = create(ScheduleSpecSchema, {
+  cron: "0 9 * * *",
+  timeZone: "Asia/Kolkata",
+  enabled: true,
+});
+const disabledSpec = create(ScheduleSpecSchema, {
+  cron: "0 9 * * *",
+  timeZone: "Asia/Kolkata",
+  enabled: false,
+});
+const pausedStatus = create(ScheduleStatusSchema, {
+  pausedReason: "5 consecutive failures",
+  consecutiveFailures: 5,
+});
+const healthyStatus = create(ScheduleStatusSchema, {});
+
+describe("deriveScheduleState", () => {
+  // Every lever combination — the two levers must never collapse.
+  const cases = [
+    {
+      name: "enabled + not paused → active",
+      spec: enabledSpec,
+      status: healthyStatus,
+      state: "active",
+      phase: "ready",
+      label: "Active",
+      isPaused: false,
+    },
+    {
+      name: "enabled + paused → paused (platform latch)",
+      spec: enabledSpec,
+      status: pausedStatus,
+      state: "paused",
+      phase: "degraded",
+      label: "Paused",
+      isPaused: true,
+    },
+    {
+      name: "disabled + not paused → disabled (owner switch)",
+      spec: disabledSpec,
+      status: healthyStatus,
+      state: "disabled",
+      phase: "disabled",
+      label: "Disabled",
+      isPaused: false,
+    },
+    {
+      name: "disabled + paused → disabled wins, pause stays visible",
+      spec: disabledSpec,
+      status: pausedStatus,
+      state: "disabled",
+      phase: "disabled",
+      label: "Disabled",
+      isPaused: true,
+    },
+    {
+      name: "missing spec → disabled (fails closed, like the server)",
+      spec: undefined,
+      status: healthyStatus,
+      state: "disabled",
+      phase: "disabled",
+      label: "Disabled",
+      isPaused: false,
+    },
+    {
+      name: "missing status → not paused",
+      spec: enabledSpec,
+      status: undefined,
+      state: "active",
+      phase: "ready",
+      label: "Active",
+      isPaused: false,
+    },
+  ] as const;
+
+  for (const c of cases) {
+    it(c.name, () => {
+      const info = deriveScheduleState(c.spec, c.status);
+      expect(info.state).toBe(c.state);
+      expect(info.phase).toBe(c.phase);
+      expect(info.label).toBe(c.label);
+      expect(info.isPaused).toBe(c.isPaused);
+    });
+  }
+});
+
+describe("formatNextFire", () => {
+  const now = new Date("2026-08-04T10:00:00Z");
+  const at = (offsetMs: number) => new Date(now.getTime() + offsetMs);
+  const MINUTE = 60_000;
+  const HOUR = 60 * MINUTE;
+  const DAY = 24 * HOUR;
+
+  it("renders sub-minute and past instants as 'now' (tick mid-flight)", () => {
+    expect(formatNextFire(at(30_000), now)).toBe("now");
+    expect(formatNextFire(at(-5 * MINUTE), now)).toBe("now");
+  });
+
+  it("renders minutes, hours, and days compactly", () => {
+    expect(formatNextFire(at(5 * MINUTE), now)).toBe("in 5m");
+    expect(formatNextFire(at(59 * MINUTE), now)).toBe("in 59m");
+    expect(formatNextFire(at(3 * HOUR), now)).toBe("in 3h");
+    expect(formatNextFire(at(23 * HOUR), now)).toBe("in 23h");
+    expect(formatNextFire(at(DAY), now)).toBe("in 1d");
+    expect(formatNextFire(at(6 * DAY + 23 * HOUR), now)).toBe("in 6d");
+  });
+
+  it("falls back to a short date beyond a week", () => {
+    const target = at(10 * DAY);
+    // Locale-independent expectation: same formatting call, same options.
+    const expected = target.toLocaleDateString(undefined, {
+      month: "short",
+      day: "numeric",
+    });
+    expect(formatNextFire(target, now)).toBe(expected);
+  });
+
+  it("includes the year when the date crosses a year boundary", () => {
+    const target = new Date("2027-01-15T10:00:00Z");
+    const expected = target.toLocaleDateString(undefined, {
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+    });
+    expect(formatNextFire(target, now)).toBe(expected);
+  });
+});