@multiplatform.one/frappe 6.0.0

package/dist/cjs/doctype.spec.cjs

@@ -0,0 +1,460 @@
+var import_vitest = require("vitest");
+var import_react = require("@testing-library/react");
+var import_doctype = require("./doctype.cjs");
+const mockGetFn = import_vitest.vi.fn();
+import_vitest.vi.mock("./core/http", () => {
+  class MockHttpClient {
+    get = mockGetFn;
+  }
+  return {
+    HttpClient: MockHttpClient
+  };
+});
+function field(fieldname, fieldtype, extra = {}) {
+  return {
+    fieldname,
+    fieldtype,
+    ...extra
+  };
+}
+let testId = 0;
+(0, import_vitest.beforeEach)(() => {
+  testId++;
+  import_vitest.vi.clearAllMocks();
+});
+(0, import_vitest.describe)("parseDependsOn", () => {
+  (0, import_vitest.it)("returns always-true when expression is undefined", () => {
+    const fn = (0, import_doctype.parseDependsOn)(void 0);
+    (0, import_vitest.expect)(fn({})).toBe(true);
+    (0, import_vitest.expect)(fn({
+      status: "anything"
+    })).toBe(true);
+  });
+  (0, import_vitest.it)("returns always-true for empty string", () => {
+    const fn = (0, import_doctype.parseDependsOn)("");
+    (0, import_vitest.expect)(fn({})).toBe(true);
+  });
+  (0, import_vitest.it)("evaluates eval: prefixed JS equality expression", () => {
+    const fn = (0, import_doctype.parseDependsOn)('eval:doc.status=="Active"');
+    (0, import_vitest.expect)(fn({
+      status: "Active"
+    })).toBe(true);
+    (0, import_vitest.expect)(fn({
+      status: "Inactive"
+    })).toBe(false);
+    (0, import_vitest.expect)(fn({})).toBe(false);
+  });
+  (0, import_vitest.it)("evaluates compound eval: expressions with &&", () => {
+    const fn = (0, import_doctype.parseDependsOn)("eval:doc.a && doc.b");
+    (0, import_vitest.expect)(fn({
+      a: "x",
+      b: "y"
+    })).toBe(true);
+    (0, import_vitest.expect)(fn({
+      a: "x",
+      b: ""
+    })).toBe(false);
+    (0, import_vitest.expect)(fn({
+      a: "",
+      b: "y"
+    })).toBe(false);
+  });
+  (0, import_vitest.it)("evaluates numeric comparisons in eval:", () => {
+    const fn = (0, import_doctype.parseDependsOn)("eval:doc.count > 0");
+    (0, import_vitest.expect)(fn({
+      count: 5
+    })).toBe(true);
+    (0, import_vitest.expect)(fn({
+      count: 0
+    })).toBe(false);
+  });
+  (0, import_vitest.it)("evaluates doc.field style expression (without eval: prefix)", () => {
+    const fn = (0, import_doctype.parseDependsOn)("doc.enabled");
+    (0, import_vitest.expect)(fn({
+      enabled: true
+    })).toBe(true);
+    (0, import_vitest.expect)(fn({
+      enabled: false
+    })).toBe(false);
+    (0, import_vitest.expect)(fn({
+      enabled: "yes"
+    })).toBe(true);
+    (0, import_vitest.expect)(fn({})).toBe(false);
+  });
+  (0, import_vitest.it)("evaluates bare field name as truthy check on doc[fieldname]", () => {
+    const fn = (0, import_doctype.parseDependsOn)("is_active");
+    (0, import_vitest.expect)(fn({
+      is_active: true
+    })).toBe(true);
+    (0, import_vitest.expect)(fn({
+      is_active: 1
+    })).toBe(true);
+    (0, import_vitest.expect)(fn({
+      is_active: false
+    })).toBe(false);
+    (0, import_vitest.expect)(fn({})).toBe(false);
+  });
+  (0, import_vitest.it)("returns false (never throws) for an invalid eval: expression", () => {
+    const fn = (0, import_doctype.parseDependsOn)("eval:!!! invalid syntax");
+    (0, import_vitest.expect)(() => fn({})).not.toThrow();
+    (0, import_vitest.expect)(fn({})).toBe(false);
+  });
+  (0, import_vitest.it)("returns false (never throws) when expression accesses nested undefined", () => {
+    const fn = (0, import_doctype.parseDependsOn)("eval:doc.nested.deep.value");
+    (0, import_vitest.expect)(() => fn({})).not.toThrow();
+    (0, import_vitest.expect)(fn({})).toBe(false);
+  });
+});
+(0, import_vitest.describe)("parseFormLayout", () => {
+  (0, import_vitest.it)("returns one empty section for an empty field list", () => {
+    const sections = (0, import_doctype.parseFormLayout)([]);
+    (0, import_vitest.expect)(sections).toHaveLength(1);
+    (0, import_vitest.expect)(sections[0].columns).toHaveLength(1);
+    (0, import_vitest.expect)(sections[0].columns[0].fields).toHaveLength(0);
+    (0, import_vitest.expect)(sections[0].tab).toBeUndefined();
+  });
+  (0, import_vitest.it)("adds regular fields to the current column", () => {
+    const fields = [field("name", "Data"), field("status", "Select")];
+    const sections = (0, import_doctype.parseFormLayout)(fields);
+    (0, import_vitest.expect)(sections).toHaveLength(1);
+    (0, import_vitest.expect)(sections[0].columns[0].fields).toEqual(fields);
+  });
+  (0, import_vitest.it)("skips hidden fields", () => {
+    const fields = [field("visible", "Data"), field("secret", "Data", {
+      hidden: true
+    })];
+    const sections = (0, import_doctype.parseFormLayout)(fields);
+    (0, import_vitest.expect)(sections[0].columns[0].fields).toHaveLength(1);
+    (0, import_vitest.expect)(sections[0].columns[0].fields[0].fieldname).toBe("visible");
+  });
+  (0, import_vitest.it)("starts a new section on Section Break", () => {
+    const fields = [field("field1", "Data"), field("sec", "Section Break", {
+      label: "Details",
+      collapsible: true
+    }), field("field2", "Data")];
+    const sections = (0, import_doctype.parseFormLayout)(fields);
+    (0, import_vitest.expect)(sections).toHaveLength(2);
+    (0, import_vitest.expect)(sections[1].label).toBe("Details");
+    (0, import_vitest.expect)(sections[1].collapsible).toBe(true);
+    (0, import_vitest.expect)(sections[1].columns[0].fields[0].fieldname).toBe("field2");
+  });
+  (0, import_vitest.it)("adds a new column on Column Break within the current section", () => {
+    const fields = [field("left", "Data"), field("cb", "Column Break"), field("right", "Data")];
+    const sections = (0, import_doctype.parseFormLayout)(fields);
+    (0, import_vitest.expect)(sections).toHaveLength(1);
+    (0, import_vitest.expect)(sections[0].columns).toHaveLength(2);
+    (0, import_vitest.expect)(sections[0].columns[0].fields[0].fieldname).toBe("left");
+    (0, import_vitest.expect)(sections[0].columns[1].fields[0].fieldname).toBe("right");
+  });
+  (0, import_vitest.it)("starts a new section with tab=true on Tab Break", () => {
+    const fields = [field("field1", "Data"), field("tab1", "Tab Break", {
+      label: "Tab 1"
+    }), field("field2", "Data")];
+    const sections = (0, import_doctype.parseFormLayout)(fields);
+    (0, import_vitest.expect)(sections).toHaveLength(2);
+    (0, import_vitest.expect)(sections[1].tab).toBe(true);
+    (0, import_vitest.expect)(sections[1].label).toBe("Tab 1");
+    (0, import_vitest.expect)(sections[1].columns[0].fields[0].fieldname).toBe("field2");
+  });
+  (0, import_vitest.it)("handles complex layout: multiple sections each with multiple columns", () => {
+    const fields = [field("name", "Data"), field("sec1", "Section Break", {
+      label: "Section 1"
+    }), field("a", "Data"), field("cb", "Column Break"), field("b", "Data"), field("sec2", "Section Break", {
+      label: "Section 2"
+    }), field("c", "Data")];
+    const sections = (0, import_doctype.parseFormLayout)(fields);
+    (0, import_vitest.expect)(sections).toHaveLength(3);
+    (0, import_vitest.expect)(sections[0].columns[0].fields[0].fieldname).toBe("name");
+    (0, import_vitest.expect)(sections[1].label).toBe("Section 1");
+    (0, import_vitest.expect)(sections[1].columns).toHaveLength(2);
+    (0, import_vitest.expect)(sections[1].columns[0].fields[0].fieldname).toBe("a");
+    (0, import_vitest.expect)(sections[1].columns[1].fields[0].fieldname).toBe("b");
+    (0, import_vitest.expect)(sections[2].label).toBe("Section 2");
+    (0, import_vitest.expect)(sections[2].columns[0].fields[0].fieldname).toBe("c");
+  });
+  (0, import_vitest.it)("Column Break at the start of a Section creates an empty first column", () => {
+    const fields = [field("sec", "Section Break"), field("cb", "Column Break"), field("right", "Data")];
+    const sections = (0, import_doctype.parseFormLayout)(fields);
+    (0, import_vitest.expect)(sections[1].columns).toHaveLength(2);
+    (0, import_vitest.expect)(sections[1].columns[0].fields).toHaveLength(0);
+    (0, import_vitest.expect)(sections[1].columns[1].fields[0].fieldname).toBe("right");
+  });
+});
+function rawDocType(name) {
+  return {
+    name,
+    module: "Core",
+    sort_field: "modified",
+    sort_order: "DESC",
+    fields: [{
+      fieldname: "name",
+      fieldtype: "Data",
+      label: "Name"
+    }, {
+      fieldname: "status",
+      fieldtype: "Select",
+      label: "Status",
+      options: "Active\nInactive"
+    }],
+    permissions: [{
+      role: "System Manager",
+      read: 1,
+      write: 1
+    }]
+  };
+}
+(0, import_vitest.describe)("useDocTypeMeta", () => {
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.it)("starts loading and resolves with parsed meta", async () => {
+    const doctype = `DocA${testId}`;
+    const config = {
+      baseURL: `https://meta-${testId}.example.com`
+    };
+    mockGetFn.mockResolvedValueOnce({
+      payload: {
+        data: rawDocType(doctype)
+      }
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useDocTypeMeta)(config, doctype));
+    (0, import_vitest.expect)(result.current.isLoading).toBe(true);
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(result.current.error).toBeNull();
+    (0, import_vitest.expect)(result.current.meta).toBeDefined();
+    (0, import_vitest.expect)(result.current.meta.name).toBe(doctype);
+    (0, import_vitest.expect)(result.current.meta.fields).toHaveLength(2);
+    (0, import_vitest.expect)(result.current.meta.permissions[0].read).toBe(true);
+  });
+  (0, import_vitest.it)("sets error state when the fetch fails", async () => {
+    const doctype = `DocB${testId}`;
+    const config = {
+      baseURL: `https://meta-err-${testId}.example.com`
+    };
+    mockGetFn.mockRejectedValueOnce(new Error("Not found"));
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useDocTypeMeta)(config, doctype));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(result.current.meta).toBeUndefined();
+    (0, import_vitest.expect)(result.current.error).toBeInstanceOf(Error);
+    (0, import_vitest.expect)(result.current.error.message).toBe("Not found");
+  });
+  (0, import_vitest.it)("returns undefined meta and isLoading=false when config is undefined", () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useDocTypeMeta)(void 0, "AnyDoc"));
+    (0, import_vitest.expect)(result.current.isLoading).toBe(false);
+    (0, import_vitest.expect)(result.current.meta).toBeUndefined();
+    (0, import_vitest.expect)(result.current.error).toBeNull();
+  });
+  (0, import_vitest.it)("parses field_order to reorder fields", async () => {
+    const doctype = `DocC${testId}`;
+    const config = {
+      baseURL: `https://meta-order-${testId}.example.com`
+    };
+    const raw = {
+      ...rawDocType(doctype),
+      field_order: ["status", "name"]
+      // reversed
+    };
+    mockGetFn.mockResolvedValueOnce({
+      payload: {
+        data: raw
+      }
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useDocTypeMeta)(config, doctype));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(result.current.meta.fields[0].fieldname).toBe("status");
+    (0, import_vitest.expect)(result.current.meta.fields[1].fieldname).toBe("name");
+  });
+  (0, import_vitest.it)("refetch() clears cache and re-fetches", async () => {
+    const doctype = `DocD${testId}`;
+    const config = {
+      baseURL: `https://meta-refetch-${testId}.example.com`
+    };
+    mockGetFn.mockResolvedValue({
+      payload: {
+        data: rawDocType(doctype)
+      }
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useDocTypeMeta)(config, doctype));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(mockGetFn).toHaveBeenCalledTimes(1);
+    await (0, import_react.act)(async () => {
+      result.current.refetch();
+    });
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(mockGetFn).toHaveBeenCalledTimes(2);
+  });
+});
+const minimalRawDocType = name => ({
+  name,
+  module: "Test",
+  sort_field: "modified",
+  sort_order: "DESC",
+  fields: [],
+  permissions: []
+});
+(0, import_vitest.describe)("useLinkSearch", () => {
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.useFakeTimers();
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.useRealTimers();
+  });
+  (0, import_vitest.it)("returns empty results and isLoading=false when query is empty", async () => {
+    const config = {
+      baseURL: `https://link-${testId}.example.com`
+    };
+    mockGetFn.mockResolvedValueOnce({
+      payload: {
+        data: minimalRawDocType("Customer")
+      }
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useLinkSearch)(config, "Customer", {
+      query: ""
+    }));
+    await (0, import_react.act)(async () => {
+      await import_vitest.vi.runAllTimersAsync();
+    });
+    (0, import_vitest.expect)(result.current.results).toHaveLength(0);
+    (0, import_vitest.expect)(result.current.isLoading).toBe(false);
+    (0, import_vitest.expect)(mockGetFn).toHaveBeenCalledTimes(1);
+  });
+  (0, import_vitest.it)("debounces and fetches results for a non-empty query", async () => {
+    const config = {
+      baseURL: `https://link2-${testId}.example.com`
+    };
+    mockGetFn.mockResolvedValueOnce({
+      payload: {
+        data: minimalRawDocType("Customer")
+      }
+    });
+    mockGetFn.mockResolvedValueOnce({
+      payload: {
+        message: [{
+          name: "CUST-001",
+          customer_name: "Acme Corp"
+        }, {
+          name: "CUST-002",
+          customer_name: "Beta Inc"
+        }]
+      }
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useLinkSearch)(config, "Customer", {
+      query: "acme",
+      limit: 10
+    }));
+    await (0, import_react.act)(async () => {
+      await import_vitest.vi.runAllTimersAsync();
+    });
+    (0, import_vitest.expect)(result.current.isLoading).toBe(false);
+    (0, import_vitest.expect)(result.current.results).toHaveLength(2);
+    (0, import_vitest.expect)(result.current.results[0].value).toBe("CUST-001");
+  });
+  (0, import_vitest.it)("sets error state on fetch failure", async () => {
+    const config = {
+      baseURL: `https://link-err-${testId}.example.com`
+    };
+    mockGetFn.mockResolvedValueOnce({
+      payload: {
+        data: minimalRawDocType("Customer")
+      }
+    });
+    mockGetFn.mockRejectedValueOnce(new Error("Search failed"));
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useLinkSearch)(config, "Customer", {
+      query: "x"
+    }));
+    await (0, import_react.act)(async () => {
+      await import_vitest.vi.runAllTimersAsync();
+    });
+    (0, import_vitest.expect)(result.current.error).toBeInstanceOf(Error);
+    (0, import_vitest.expect)(result.current.results).toHaveLength(0);
+  });
+});
+(0, import_vitest.describe)("useDocTypeSearch", () => {
+  const docTypeList = [{
+    name: "Customer",
+    module: "Selling",
+    title: "Customer"
+  }, {
+    name: "Sales Order",
+    module: "Selling",
+    title: "Sales Order"
+  }, {
+    name: "Item",
+    module: "Stock",
+    title: "Item"
+  }];
+  (0, import_vitest.it)("returns empty results when config is undefined", () => {
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useDocTypeSearch)(void 0, "customer"));
+    (0, import_vitest.expect)(result.current.results).toHaveLength(0);
+    (0, import_vitest.expect)(result.current.isLoading).toBe(false);
+  });
+  (0, import_vitest.it)("returns empty results when query is empty (even with loaded list)", async () => {
+    const config = {
+      baseURL: `https://search-${testId}.example.com`
+    };
+    mockGetFn.mockResolvedValueOnce({
+      payload: {
+        data: docTypeList
+      }
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useDocTypeSearch)(config, ""));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    (0, import_vitest.expect)(result.current.results).toHaveLength(0);
+  });
+  (0, import_vitest.it)("filters DocType list locally by name and returns list/report/new suggestions", async () => {
+    const config = {
+      baseURL: `https://search2-${testId}.example.com`
+    };
+    mockGetFn.mockResolvedValueOnce({
+      payload: {
+        data: docTypeList
+      }
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useDocTypeSearch)(config, "customer"));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    const types = result.current.results.map(r => r.type);
+    (0, import_vitest.expect)(types).toContain("list");
+    (0, import_vitest.expect)(types).toContain("report");
+    (0, import_vitest.expect)(types).toContain("new");
+    const doctypes = result.current.results.map(r => r.doctype);
+    (0, import_vitest.expect)(doctypes.every(d => d === "Customer")).toBe(true);
+  });
+  (0, import_vitest.it)("matches on module name as well as doctype name", async () => {
+    const config = {
+      baseURL: `https://search3-${testId}.example.com`
+    };
+    mockGetFn.mockResolvedValueOnce({
+      payload: {
+        data: docTypeList
+      }
+    });
+    const {
+      result
+    } = (0, import_react.renderHook)(() => (0, import_doctype.useDocTypeSearch)(config, "stock"));
+    await (0, import_react.waitFor)(() => (0, import_vitest.expect)(result.current.isLoading).toBe(false));
+    const doctypes = [...new Set(result.current.results.map(r => r.doctype))];
+    (0, import_vitest.expect)(doctypes).toContain("Item");
+  });
+});