@multiplatform.one/frappe-ui 7.28.1 → 7.29.0

package/src/report/useQueryReport.spec.tsx

@@ -0,0 +1,131 @@
+/**
+ * useQueryReport's live path (MPO-15, GL-28): the desk hook reads the Report
+ * doc and script, then runs the report through useFrappeReport, the
+ * transport FrappeReportView uses, and hands back the one model's columns and
+ * rows. A refused run keeps its HTTP status on the humanized error.
+ */
+import { renderHook, waitFor } from "@testing-library/react";
+import React, { type ReactNode } from "react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { FrappeProvider } from "../FrappeProvider";
+import { useQueryReport } from "./useQueryReport";
+
+interface Recorded {
+  method: string;
+  url: string;
+  body?: Record<string, unknown>;
+}
+
+function json(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+let calls: Recorded[] = [];
+let runResponse: () => Response;
+
+beforeEach(() => {
+  calls = [];
+  runResponse = () =>
+    json({
+      message: {
+        columns: ["ID:Link/ToDo:120", { label: "Assigned To/Owner", fieldtype: "Data" }],
+        result: [
+          ["TD-1", "jane@example.com"],
+          { id: "TD-2", "assigned_to/owner": "joe@example.com" },
+        ],
+        execution_time: 0.25,
+        message: "Two open",
+      },
+    });
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = typeof input === "string" ? input : input.toString();
+      const method = (init?.method ?? "GET").toUpperCase();
+      const body =
+        typeof init?.body === "string"
+          ? (JSON.parse(init.body) as Record<string, unknown>)
+          : undefined;
+      calls.push({ method, url, body });
+      if (url.includes("frappe.client.get")) {
+        return json({
+          message: {
+            name: "Open Work",
+            report_name: "Open Work",
+            filters: [{ fieldname: "owner", label: "Owner", fieldtype: "Data", default: "jane" }],
+          },
+        });
+      }
+      if (url.includes("frappe.desk.query_report.get_script")) return json({ message: {} });
+      if (url.includes("frappe.desk.query_report.run")) return runResponse();
+      return json({ message: null });
+    }),
+  );
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+let run = 0;
+function wrapper() {
+  run += 1;
+  const baseURL = `https://query-report-${run}.spec.test`;
+  return ({ children }: { children: ReactNode }) => (
+    <FrappeProvider baseURL={baseURL} realtime={false}>
+      {children}
+    </FrappeProvider>
+  );
+}
+
+describe("useQueryReport over the shared transport", () => {
+  it("seeds the doc's defaults, runs once, and reads the model's rows", async () => {
+    const { result } = renderHook(() => useQueryReport("Open Work"), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.loading).toBe(false), { timeout: 5000 });
+    expect(result.current.error).toBeUndefined();
+    expect(result.current.columns.map((column) => column.fieldname)).toEqual([
+      "id",
+      "assigned_to/owner",
+    ]);
+    expect(result.current.rows).toEqual([
+      { id: "TD-1", "assigned_to/owner": "jane@example.com" },
+      { id: "TD-2", "assigned_to/owner": "joe@example.com" },
+    ]);
+    expect(result.current.executionTime).toBe(0.25);
+    expect(result.current.serverMessage).toBe("Two open");
+
+    const runs = calls.filter((call) => call.url.includes("frappe.desk.query_report.run"));
+    expect(runs).toHaveLength(1);
+    expect(runs[0].method).toBe("POST");
+    expect(runs[0].body).toMatchObject({
+      report_name: "Open Work",
+      filters: { owner: "jane" },
+      ignore_prepared_report: 1,
+      are_default_filters: 0,
+    });
+  });
+
+  it("keeps the refused run's status on the humanized error", async () => {
+    runResponse = () =>
+      json(
+        {
+          exc_type: "PermissionError",
+          _server_messages: JSON.stringify([
+            JSON.stringify({ message: "You are not permitted to run Open Work" }),
+          ]),
+        },
+        403,
+      );
+    const { result } = renderHook(() => useQueryReport("Open Work"), { wrapper: wrapper() });
+    await waitFor(() => expect(result.current.error).toBeDefined(), { timeout: 5000 });
+    const error = result.current.error as Error & { status?: number; exc_type?: string };
+    expect(error.message).toBe("You are not permitted to run Open Work");
+    expect(error.status).toBe(403);
+    expect(error.exc_type).toBe("PermissionError");
+    expect(result.current.rows).toEqual([]);
+    expect(result.current.loading).toBe(false);
+  });
+});

package/src/report/useQueryReport.ts

@@ -0,0 +1,309 @@
+// Data hook for frappe Query / Script Reports (the desk
+// /app/query-report/<name> surface): loads the Report doc (title,
+// ref_doctype, doc-level filters) plus the desk-side script module
+// (frappe.desk.query_report.get_script) and runs the report through
+// useFrappeReport, the transport FrappeReportView uses too. Wire-shape
+// normalization (and the probed response documentation) lives in
+// queryReport.ts; this file owns the desk's filter state and gating.
+//
+//   GET /api/method/frappe.client.get {doctype:"Report", name}
+//   → {message: {report_name, ref_doctype, report_type, disabled,
+//      prepared_report, add_total_row, filters: [...], ...}}
+//   GET /api/method/frappe.desk.query_report.get_script {report_name}
+//   → {message: {script, html_format, execution_time, filters}}
+//
+// Filter meta sources (desk precedence, query_report.js setup): the script
+// module's declarative `filters` win when the script declares any; the
+// Report doc `filters` child table applies only when it doesn't. Script
+// filters are extracted from the raw JS text without eval
+// (queryReport.extractScriptFilters) — entries beyond the declarative
+// subset (get_query functions, dynamic defaults, desk-only fieldtypes)
+// surface as `scriptFilterGap` so the screen can render an honest note.
+// `ignore_prepared_report` forces a synchronous run for prepared reports
+// (desk's background Prepared Report queue is out of scope here).
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useFrappeConfig } from "../FrappeProvider";
+import { isPermissionError } from "../liveErrors";
+import {
+  type QueryReportColumn,
+  type QueryReportFilterMeta,
+  type QueryReportFilters,
+  type QueryReportFixture,
+  type QueryReportMeta,
+  type QueryReportRow,
+  buildRunFilters,
+  defaultFilterValues,
+  extractScriptFilters,
+  humanizeFrappeError,
+  isEmptyFilterValue,
+  normalizeFilterMeta,
+  normalizeQueryReportColumns,
+  normalizeQueryReportRows,
+} from "./queryReport";
+import { reportCall, useFrappeReport, type FrappeReportConnection } from "./useFrappeReport";
+
+const SCRIPT_METHOD = "frappe.desk.query_report.get_script";
+const EMPTY_COLUMNS: QueryReportColumn[] = [];
+const EMPTY_ROWS: QueryReportRow[] = [];
+
+export interface UseQueryReportOptions {
+  fixture?: QueryReportFixture;
+  /** Filter values applied before the first run (report swaps re-apply them). */
+  initialFilters?: QueryReportFilters;
+}
+
+export interface UseQueryReportResult {
+  meta?: QueryReportMeta;
+  columns: QueryReportColumn[];
+  rows: QueryReportRow[];
+  /** True until the first meta+script+run cycle settles. */
+  loading: boolean;
+  /** True while a (re)run is in flight. */
+  running: boolean;
+  /** The failed run's server sentence; `status` and `exc_type` ride along. */
+  error?: Error;
+  /** The server refused the run: the session may not run this report (LC-96). */
+  refused: boolean;
+  /** The report's informational `message` payload (may embed HTML). */
+  serverMessage?: string;
+  /** Server-reported run time in seconds. */
+  executionTime?: number;
+  /** Merged filter meta: script-declared filters, else doc-level rows. */
+  filterMeta: QueryReportFilterMeta[];
+  /**
+   * True when the desk script declares filters this surface could not
+   * derive (non-declarative entries) — the honest "defined in code" note.
+   */
+  scriptFilterGap: boolean;
+  /** Mandatory filters currently unfilled — the run is skipped while non-empty. */
+  missingRequired: QueryReportFilterMeta[];
+  filters: QueryReportFilters;
+  setFilters: (next: QueryReportFilters) => void;
+  reload: () => void;
+}
+
+async function fetchReportMeta(
+  connection: FrappeReportConnection,
+  reportName: string,
+): Promise<QueryReportMeta> {
+  const res = await reportCall(connection).get<{ message?: QueryReportMeta }>("frappe.client.get", {
+    doctype: "Report",
+    name: reportName,
+  });
+  const doc = res.payload?.message;
+  if (!doc) throw new Error(`Report "${reportName}" not found`);
+  return doc;
+}
+
+async function fetchReportScript(
+  connection: FrappeReportConnection,
+  reportName: string,
+): Promise<string | undefined> {
+  const res = await reportCall(connection).get<{ message?: { script?: string | null } }>(
+    SCRIPT_METHOD,
+    { report_name: reportName },
+  );
+  const script = res.payload?.message?.script;
+  return typeof script === "string" ? script : undefined;
+}
+
+export function useQueryReport(
+  reportName: string,
+  options: UseQueryReportOptions = {},
+): UseQueryReportResult {
+  const { fixture } = options;
+  const config = useFrappeConfig();
+  const baseURL = config?.baseURL;
+  const auth = config?.auth;
+  const connection = useMemo<FrappeReportConnection | undefined>(
+    () => (baseURL ? { baseURL, auth } : undefined),
+    [baseURL, auth],
+  );
+
+  // Latest initialFilters without re-running effects on identity churn.
+  const initialFiltersRef = useRef(options.initialFilters);
+  initialFiltersRef.current = options.initialFilters;
+
+  const [meta, setMeta] = useState<QueryReportMeta | undefined>(undefined);
+  const [script, setScript] = useState<string | undefined>(undefined);
+  const [sourcesSettled, setSourcesSettled] = useState(false);
+  const [filters, setFiltersState] = useState<QueryReportFilters>(() => ({
+    ...initialFiltersRef.current,
+  }));
+  const seededFor = useRef<string | undefined>(undefined);
+
+  // The route component is reused across query-report navigations — a
+  // report swap resets filters and shows the loading state again.
+  const lastReport = useRef(reportName);
+  useEffect(() => {
+    if (lastReport.current === reportName) return;
+    lastReport.current = reportName;
+    setFiltersState({ ...initialFiltersRef.current });
+    setMeta(undefined);
+    setScript(undefined);
+    setSourcesSettled(false);
+  }, [reportName]);
+
+  // Report doc meta (title, ref_doctype, doc filters) + the desk script
+  // module, fetched together. Both are non-fatal niceties — the run below
+  // reports the real errors — but the run waits for them so declared
+  // defaults are seeded into the FIRST run (desk parity).
+  useEffect(() => {
+    if (fixture) return;
+    if (!connection) {
+      setSourcesSettled(true);
+      return;
+    }
+    let cancelled = false;
+    setSourcesSettled(false);
+    Promise.allSettled([
+      fetchReportMeta(connection, reportName),
+      fetchReportScript(connection, reportName),
+    ]).then(([metaResult, scriptResult]) => {
+      if (cancelled) return;
+      const doc = metaResult.status === "fulfilled" ? metaResult.value : undefined;
+      const scriptText = scriptResult.status === "fulfilled" ? scriptResult.value : undefined;
+      if (doc) setMeta(doc);
+      if (scriptText) setScript(scriptText);
+      // Seed filter defaults once per report; user edits (and deep-link
+      // initialFilters, already in state) win over defaults.
+      if (seededFor.current !== reportName) {
+        seededFor.current = reportName;
+        const extraction = extractScriptFilters(scriptText);
+        const merged = extraction.declared ? extraction.filters : normalizeFilterMeta(doc?.filters);
+        const defaults = defaultFilterValues(merged);
+        if (Object.keys(defaults).length > 0)
+          setFiltersState((previous) => ({ ...defaults, ...previous }));
+      }
+      setSourcesSettled(true);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [connection, fixture, reportName]);
+
+  const scriptExtraction = useMemo(
+    () => extractScriptFilters(fixture ? fixture.script : script),
+    [fixture, script],
+  );
+  const docFilterMeta = useMemo(
+    () => normalizeFilterMeta(fixture ? fixture.meta?.filters : meta?.filters),
+    [fixture, meta],
+  );
+  // Desk precedence (query_report.js): the script module's filters apply
+  // when the script declares the key at all; doc rows only otherwise.
+  const filterMeta = useMemo(
+    () => (scriptExtraction.declared ? scriptExtraction.filters : docFilterMeta),
+    [scriptExtraction, docFilterMeta],
+  );
+  const scriptFilterGap = scriptExtraction.declaredCount > scriptExtraction.filters.length;
+
+  // Fixture branch seeds defaults too (no fetch effect runs for fixtures).
+  useEffect(() => {
+    if (!fixture) return;
+    if (seededFor.current === reportName) return;
+    seededFor.current = reportName;
+    const defaults = defaultFilterValues(filterMeta);
+    if (Object.keys(defaults).length > 0)
+      setFiltersState((previous) => ({ ...defaults, ...previous }));
+  }, [fixture, reportName, filterMeta]);
+
+  // Desk parity: defaults SEED the controls (state) once; after that the
+  // gate reads the live values only — clearing a defaulted mandatory filter
+  // re-gates instead of firing a doomed run (desk's get_filter_values reads
+  // control values, not declarations).
+  const missingRequired = useMemo(
+    () =>
+      filterMeta.filter(
+        (filter) => filter.mandatory === 1 && isEmptyFilterValue(filters[filter.fieldname]),
+      ),
+    [filterMeta, filters],
+  );
+  const hasMissingRequired = missingRequired.length > 0;
+  const metaDisabled = (fixture ? fixture.meta?.disabled : meta?.disabled) === 1;
+
+  const runFilters = useMemo(() => buildRunFilters(filterMeta, filters), [filterMeta, filters]);
+  const runEnabled =
+    !fixture && sourcesSettled && Boolean(connection) && !metaDisabled && !hasMissingRequired;
+  const run = useFrappeReport(connection, {
+    reportName,
+    filters: runFilters,
+    ignorePreparedReport: true,
+    debounceMs: 0,
+    enabled: runEnabled,
+  });
+  const { refresh } = run;
+
+  const setFilters = useCallback((next: QueryReportFilters) => {
+    setFiltersState(next);
+  }, []);
+
+  const reload = useCallback(() => {
+    if (runEnabled) refresh();
+  }, [runEnabled, refresh]);
+
+  const runError = useMemo(
+    () => (run.error ? humanizeFrappeError(run.error) : undefined),
+    [run.error],
+  );
+
+  // Fixture branch: static data, no RPCs (stories/tests).
+  const fixtureResult = useMemo(() => {
+    if (!fixture) return undefined;
+    const fixtureColumns = normalizeQueryReportColumns(fixture.columns);
+    return {
+      columns: fixtureColumns,
+      rows: normalizeQueryReportRows(fixture.rows, fixtureColumns),
+      meta: fixture.meta ? ({ name: reportName, ...fixture.meta } as QueryReportMeta) : undefined,
+    };
+  }, [fixture, reportName]);
+
+  if (fixtureResult) {
+    return {
+      meta: fixtureResult.meta,
+      columns: fixtureResult.columns,
+      rows: hasMissingRequired ? EMPTY_ROWS : fixtureResult.rows,
+      loading: false,
+      running: false,
+      error: undefined,
+      refused: false,
+      serverMessage: fixture?.message,
+      executionTime: undefined,
+      filterMeta,
+      scriptFilterGap,
+      missingRequired,
+      filters,
+      setFilters,
+      reload,
+    };
+  }
+
+  const noConnection = sourcesSettled && !connection;
+  // A settled run shows its result; a gated one (disabled report, missing
+  // mandatory filters) shows nothing rather than the last report's rows.
+  const showsRun = runEnabled && !runError;
+  const payload = showsRun ? run.payload : undefined;
+  const error = noConnection
+    ? new Error("No Frappe connection configured")
+    : runEnabled
+      ? runError
+      : undefined;
+  return {
+    meta,
+    columns: payload?.columns ?? EMPTY_COLUMNS,
+    rows: payload?.rows ?? EMPTY_ROWS,
+    loading: !sourcesSettled || (runEnabled && (run.isLoading || (!run.payload && !run.error))),
+    running: runEnabled && run.isFetching,
+    error,
+    refused: error !== undefined && isPermissionError(error),
+    serverMessage: payload?.message,
+    executionTime:
+      typeof payload?.raw.execution_time === "number" ? payload.raw.execution_time : undefined,
+    filterMeta,
+    scriptFilterGap,
+    missingRequired,
+    filters,
+    setFilters,
+    reload,
+  };
+}

package/src/useFrappeForm.spec.tsx

@@ -0,0 +1,209 @@
+/**
+ * useFrappeForm is FrappeForm's own state, handed to its caller (MPO-15
+ * AC2): a page renders the fields with `<FrappeForm form={controller} />`
+ * and builds its chrome on the same controller, so the desk and a bare
+ * FrappeForm run one engine. A new record also starts from the doctype's
+ * defaults, the way desk create_new seeds it.
+ */
+
+import { InMemoryFixtureProvider } from "@multiplatform.one/frappe";
+import { renderWithProviders } from "@multiplatform.one/test-utils";
+import { act, cleanup, fireEvent, screen, waitFor } from "@testing-library/react";
+import i18next from "i18next";
+import { initReactI18next } from "react-i18next";
+import { Text } from "tamagui";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { assetLoanLifecycleFixtures } from "../tests/fixtures/assetLoanLifecycle";
+import { setCreatePrefill } from "./formEngine/createPrefill";
+import { FrappeForm } from "./FrappeForm";
+import { FrappeProvider } from "./FrappeProvider";
+import type { FieldOverride } from "./schemaForm";
+import { useFrappeForm, type FrappeFormController } from "./useFrappeForm";
+
+beforeAll(async () => {
+  await i18next.use(initReactI18next).init({
+    lng: "en",
+    interpolation: { escapeValue: false },
+    resources: { en: { translation: {} } },
+  });
+});
+
+let confirm: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  confirm = vi.fn(() => true);
+  vi.stubGlobal("confirm", confirm);
+});
+
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+type Doc = Record<string, unknown> & { name: string; doctype: string };
+
+const probe: FieldOverride = (props) => {
+  const name = props.fieldMeta?.name ?? "";
+  const value = props.value === undefined || props.value === null ? "" : String(props.value);
+  return <Text testID={`probe-${name}`}>{`val=${value} err=${props.error ?? ""}`}</Text>;
+};
+
+const ticketMeta = {
+  name: "Desk Ticket",
+  doctype: "DocType",
+  autoname: "hash",
+  fields: [
+    { fieldname: "subject", fieldtype: "Data", label: "Subject", reqd: 1 },
+    { fieldname: "status", fieldtype: "Select", label: "Status", options: "Open\nClosed" },
+    { fieldname: "priority", fieldtype: "Data", label: "Priority", default: "Medium" },
+    { fieldname: "more_tab", fieldtype: "Tab Break", label: "More" },
+    { fieldname: "resolution", fieldtype: "Data", label: "Resolution", reqd: 1 },
+  ],
+  permissions: [{ role: "All", read: 1, write: 1, create: 1 }],
+};
+
+const ticketOverrides = { subject: probe, status: probe, priority: probe, resolution: probe };
+
+function ticketFixtures() {
+  return new InMemoryFixtureProvider({
+    DocType: [ticketMeta],
+    "Desk Ticket": [
+      { name: "TICKET-1", doctype: "Desk Ticket", subject: "Printer", status: "Open" },
+    ],
+  });
+}
+
+let controller: FrappeFormController<Doc> | undefined;
+
+function Host({ doctype, name }: { doctype: string; name?: string }) {
+  const form = useFrappeForm<Doc>({ doctype, name, roles: ["Loan Manager", "All"] });
+  controller = form;
+  return (
+    <>
+      <button type="button" data-testid="host-validate" onClick={() => revealFirst(form)}>
+        validate
+      </button>
+      <button type="button" data-testid="host-submit" onClick={() => void form.submitDocument()}>
+        submit
+      </button>
+      <FrappeForm<Doc>
+        form={form}
+        doctype={doctype}
+        name={name}
+        overrides={{ ...ticketOverrides, employee_name: probe }}
+        showToolbar={false}
+        showSidebar={false}
+        showTimeline={false}
+        showBanners={false}
+      />
+    </>
+  );
+}
+
+function revealFirst(form: FrappeFormController<Doc>) {
+  const errors = form.validate();
+  form.setErrors(errors);
+  Object.keys(errors).some((field) => form.revealField(field));
+}
+
+async function expectProbe(field: string, text: string): Promise<void> {
+  await waitFor(() => {
+    expect(screen.getByTestId(`probe-${field}`).textContent).toContain(text);
+  });
+}
+
+describe("FrappeForm seeds a new record from the doctype's defaults", () => {
+  it("a Data default and a Select's first option fill in", async () => {
+    renderWithProviders(
+      <FrappeProvider baseURL="http://test" fixtures={ticketFixtures()}>
+        <FrappeForm doctype="Desk Ticket" overrides={ticketOverrides} showSidebar={false} />
+      </FrappeProvider>,
+    );
+    await expectProbe("status", "val=Open");
+    await expectProbe("priority", "val=Medium");
+    await expectProbe("subject", "val=");
+  });
+
+  it("a stashed draft (?d=, Duplicate, Amend) wins over the defaults", async () => {
+    setCreatePrefill("Desk Ticket", { priority: "High", subject: "From the list" });
+    renderWithProviders(
+      <FrappeProvider baseURL="http://test" fixtures={ticketFixtures()}>
+        <FrappeForm doctype="Desk Ticket" overrides={ticketOverrides} showSidebar={false} />
+      </FrappeProvider>,
+    );
+    await expectProbe("priority", "val=High");
+    await expectProbe("subject", "val=From the list");
+    await expectProbe("status", "val=Open");
+  });
+});
+
+describe("a caller-owned FrappeForm", () => {
+  it("renders the fields without its own toolbar and lays out the same tabs", async () => {
+    renderWithProviders(
+      <FrappeProvider baseURL="http://test" fixtures={ticketFixtures()}>
+        <Host doctype="Desk Ticket" name="TICKET-1" />
+      </FrappeProvider>,
+    );
+    await expectProbe("subject", "val=Printer");
+    expect(screen.queryByText("Save")).toBeNull();
+    expect(controller?.fieldTargets.map((field) => [field.name, field.tabKey])).toEqual([
+      ["subject", "__details"],
+      ["status", "__details"],
+      ["priority", "__details"],
+      ["resolution", "more_tab"],
+    ]);
+  });
+
+  it("reveals the tab a failing required field sits on", async () => {
+    renderWithProviders(
+      <FrappeProvider baseURL="http://test" fixtures={ticketFixtures()}>
+        <Host doctype="Desk Ticket" name="TICKET-1" />
+      </FrappeProvider>,
+    );
+    await expectProbe("subject", "val=Printer");
+    expect(screen.queryByTestId("probe-resolution")).toBeNull();
+    fireEvent.click(screen.getByTestId("host-validate"));
+    await expectProbe("resolution", "err=Resolution is required");
+    expect(controller?.activeTab).toBe("more_tab");
+  });
+
+  it("submits without FrappeForm's own confirm, so the host owns the question", async () => {
+    const fixtures = assetLoanLifecycleFixtures();
+    renderWithProviders(
+      <FrappeProvider baseURL="http://test" fixtures={fixtures}>
+        <Host doctype="Asset Loan" name="LOAN-DRAFT" />
+      </FrappeProvider>,
+    );
+    await expectProbe("employee_name", "val=Ada Lovelace");
+    await waitFor(() => expect(controller?.rights.submit).toBe(true));
+    fireEvent.click(screen.getByTestId("host-submit"));
+    await waitFor(async () =>
+      expect((await fixtures.getDoc("Asset Loan", "LOAN-DRAFT"))?.docstatus).toBe(1),
+    );
+    await waitFor(() => expect(controller?.docstatus).toBe(1));
+    expect(confirm).not.toHaveBeenCalled();
+  });
+
+  it("save resolves with the created record's name", async () => {
+    const fixtures = ticketFixtures();
+    renderWithProviders(
+      <FrappeProvider baseURL="http://test" fixtures={fixtures}>
+        <Host doctype="Desk Ticket" />
+      </FrappeProvider>,
+    );
+    await expectProbe("priority", "val=Medium");
+    act(() => {
+      controller?.setValue("subject", "Scanner");
+      controller?.setValue("resolution", "Rebooted");
+    });
+    await waitFor(() => expect(controller?.doc.subject).toBe("Scanner"));
+    let saved: string | undefined;
+    await act(async () => {
+      saved = await controller?.save();
+    });
+    expect(saved).toBeTruthy();
+    const created = await fixtures.getDoc("Desk Ticket", String(saved));
+    expect(created).toMatchObject({ subject: "Scanner", priority: "Medium", status: "Open" });
+  });
+});