@multiplatform.one/frappe 6.1.0 → 6.4.0

package/dist/cjs/call.spec.cjs

@@ -1,427 +0,0 @@
-var import_vitest = require("vitest");
-var import_call = require("./call.cjs");
-(0, import_vitest.describe)("CallModule", () => {
-  let call;
-  let mockHttpClient;
-  (0, import_vitest.beforeEach)(() => {
-    mockHttpClient = {
-      get: import_vitest.vi.fn(),
-      post: import_vitest.vi.fn(),
-      put: import_vitest.vi.fn(),
-      delete: import_vitest.vi.fn(),
-      head: import_vitest.vi.fn(),
-      request: import_vitest.vi.fn(),
-      setToken: import_vitest.vi.fn()
-    };
-    call = new import_call.CallModule(mockHttpClient);
-  });
-  (0, import_vitest.describe)("constructor", () => {
-    (0, import_vitest.it)("should initialize with http client", () => {
-      const callInstance = new import_call.CallModule(mockHttpClient);
-      (0, import_vitest.expect)(callInstance).toBeDefined();
-    });
-  });
-  (0, import_vitest.describe)("get", () => {
-    (0, import_vitest.it)("should call GET method without params", async () => {
-      const mockResponse = {
-        payload: {
-          message: "Success",
-          data: {
-            result: "test"
-          }
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      const result = await call.get("frappe.api.test_method");
-      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.api.test_method", void 0);
-      (0, import_vitest.expect)(result).toEqual(mockResponse);
-    });
-    (0, import_vitest.it)("should call GET method with params", async () => {
-      const params = {
-        doctype: "TestDocType",
-        name: "TEST-001",
-        fields: ["name", "title"]
-      };
-      const mockResponse = {
-        payload: {
-          message: "Success"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      const result = await call.get("frappe.api.get_doc", params);
-      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.api.get_doc", params);
-      (0, import_vitest.expect)(result).toEqual(mockResponse);
-    });
-    (0, import_vitest.it)("should handle method with dots in name", async () => {
-      const mockResponse = {
-        payload: {
-          message: "OK"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      await call.get("frappe.core.doctype.user.user.get_list");
-      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.core.doctype.user.user.get_list", void 0);
-    });
-    (0, import_vitest.it)("should handle empty params object", async () => {
-      const mockResponse = {
-        payload: {
-          message: "OK"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      await call.get("test_method", {});
-      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/test_method", {});
-    });
-    (0, import_vitest.it)("should handle complex params", async () => {
-      const params = {
-        filters: [["status", "=", "Active"]],
-        order_by: "creation desc",
-        limit: 10,
-        nested: {
-          value: "test",
-          enabled: true
-        }
-      };
-      const mockResponse = {
-        payload: {
-          message: "OK"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      await call.get("custom_method", params);
-      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/custom_method", params);
-    });
-    (0, import_vitest.it)("should handle error response", async () => {
-      const mockError = new Error("Method not found");
-      mockHttpClient.get.mockRejectedValue(mockError);
-      await (0, import_vitest.expect)(call.get("invalid_method")).rejects.toThrow("Method not found");
-    });
-  });
-  (0, import_vitest.describe)("post", () => {
-    (0, import_vitest.it)("should call POST method without body", async () => {
-      const mockResponse = {
-        payload: {
-          message: "Created"
-        },
-        headers: new Headers(),
-        status: 201,
-        _res: {}
-      };
-      mockHttpClient.post.mockResolvedValue(mockResponse);
-      const result = await call.post("frappe.api.create");
-      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/frappe.api.create", void 0);
-      (0, import_vitest.expect)(result).toEqual(mockResponse);
-    });
-    (0, import_vitest.it)("should call POST method with body", async () => {
-      const body = {
-        doctype: "TestDocType",
-        title: "Test Document",
-        description: "Test description"
-      };
-      const mockResponse = {
-        payload: {
-          message: "Document created",
-          data: {
-            name: "TEST-001",
-            ...body
-          }
-        },
-        headers: new Headers(),
-        status: 201,
-        _res: {}
-      };
-      mockHttpClient.post.mockResolvedValue(mockResponse);
-      const result = await call.post("frappe.api.insert", body);
-      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/frappe.api.insert", body);
-      (0, import_vitest.expect)(result).toEqual(mockResponse);
-    });
-    (0, import_vitest.it)("should handle FormData body", async () => {
-      const formData = new FormData();
-      formData.append("file", new Blob(["test"]), "test.txt");
-      formData.append("doctype", "File");
-      const mockResponse = {
-        payload: {
-          message: "File uploaded"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.post.mockResolvedValue(mockResponse);
-      await call.post("upload_file", formData);
-      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/upload_file", formData);
-    });
-    (0, import_vitest.it)("should handle array body", async () => {
-      const body = ["item1", "item2", "item3"];
-      const mockResponse = {
-        payload: {
-          message: "Processed"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.post.mockResolvedValue(mockResponse);
-      await call.post("process_items", body);
-      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/process_items", body);
-    });
-    (0, import_vitest.it)("should handle null body", async () => {
-      const mockResponse = {
-        payload: {
-          message: "OK"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.post.mockResolvedValue(mockResponse);
-      await call.post("test_method", null);
-      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/test_method", null);
-    });
-    (0, import_vitest.it)("should handle error response", async () => {
-      const mockError = {
-        status: 500,
-        message: "Internal server error"
-      };
-      mockHttpClient.post.mockRejectedValue(mockError);
-      await (0, import_vitest.expect)(call.post("failing_method", {})).rejects.toEqual(mockError);
-    });
-  });
-  (0, import_vitest.describe)("put", () => {
-    (0, import_vitest.it)("should call PUT method without body", async () => {
-      const mockResponse = {
-        payload: {
-          message: "Updated"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.put.mockResolvedValue(mockResponse);
-      const result = await call.put("frappe.api.update");
-      (0, import_vitest.expect)(mockHttpClient.put).toHaveBeenCalledWith("/api/method/frappe.api.update", void 0);
-      (0, import_vitest.expect)(result).toEqual(mockResponse);
-    });
-    (0, import_vitest.it)("should call PUT method with body", async () => {
-      const body = {
-        doctype: "TestDocType",
-        name: "TEST-001",
-        updates: {
-          title: "Updated Title",
-          status: "Completed"
-        }
-      };
-      const mockResponse = {
-        payload: {
-          message: "Document updated",
-          success: true
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.put.mockResolvedValue(mockResponse);
-      const result = await call.put("frappe.api.update_doc", body);
-      (0, import_vitest.expect)(mockHttpClient.put).toHaveBeenCalledWith("/api/method/frappe.api.update_doc", body);
-      (0, import_vitest.expect)(result).toEqual(mockResponse);
-    });
-    (0, import_vitest.it)("should handle partial updates", async () => {
-      const body = {
-        field: "status",
-        value: "Active"
-      };
-      const mockResponse = {
-        payload: {
-          message: "Field updated"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.put.mockResolvedValue(mockResponse);
-      await call.put("update_field", body);
-      (0, import_vitest.expect)(mockHttpClient.put).toHaveBeenCalledWith("/api/method/update_field", body);
-    });
-    (0, import_vitest.it)("should handle error response", async () => {
-      const mockError = new Error("Update failed");
-      mockHttpClient.put.mockRejectedValue(mockError);
-      await (0, import_vitest.expect)(call.put("update_method", {})).rejects.toThrow("Update failed");
-    });
-  });
-  (0, import_vitest.describe)("delete", () => {
-    (0, import_vitest.it)("should call DELETE method without body", async () => {
-      const mockResponse = {
-        payload: {
-          message: "Deleted"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.delete.mockResolvedValue(mockResponse);
-      const result = await call.delete("frappe.api.delete");
-      (0, import_vitest.expect)(mockHttpClient.delete).toHaveBeenCalledWith("/api/method/frappe.api.delete", void 0);
-      (0, import_vitest.expect)(result).toEqual(mockResponse);
-    });
-    (0, import_vitest.it)("should call DELETE method with body", async () => {
-      const body = {
-        doctype: "TestDocType",
-        name: "TEST-001"
-      };
-      const mockResponse = {
-        payload: {
-          message: "Document deleted",
-          success: true
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.delete.mockResolvedValue(mockResponse);
-      const result = await call.delete("frappe.api.delete_doc", body);
-      (0, import_vitest.expect)(mockHttpClient.delete).toHaveBeenCalledWith("/api/method/frappe.api.delete_doc", body);
-      (0, import_vitest.expect)(result).toEqual(mockResponse);
-    });
-    (0, import_vitest.it)("should handle batch delete", async () => {
-      const body = {
-        doctype: "TestDocType",
-        names: ["TEST-001", "TEST-002", "TEST-003"]
-      };
-      const mockResponse = {
-        payload: {
-          message: "3 documents deleted"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.delete.mockResolvedValue(mockResponse);
-      await call.delete("batch_delete", body);
-      (0, import_vitest.expect)(mockHttpClient.delete).toHaveBeenCalledWith("/api/method/batch_delete", body);
-    });
-    (0, import_vitest.it)("should handle soft delete", async () => {
-      const body = {
-        doctype: "TestDocType",
-        name: "TEST-001",
-        soft_delete: true
-      };
-      const mockResponse = {
-        payload: {
-          message: "Document marked as deleted"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.delete.mockResolvedValue(mockResponse);
-      await call.delete("soft_delete", body);
-      (0, import_vitest.expect)(mockHttpClient.delete).toHaveBeenCalledWith("/api/method/soft_delete", body);
-    });
-    (0, import_vitest.it)("should handle error response", async () => {
-      const mockError = {
-        status: 403,
-        message: "Permission denied"
-      };
-      mockHttpClient.delete.mockRejectedValue(mockError);
-      await (0, import_vitest.expect)(call.delete("delete_method", {})).rejects.toEqual(mockError);
-    });
-  });
-  (0, import_vitest.describe)("method name handling", () => {
-    (0, import_vitest.it)("should handle method names with special characters", async () => {
-      const mockResponse = {
-        payload: {
-          message: "OK"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      await call.get("frappe.utils.get-data");
-      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/frappe.utils.get-data", void 0);
-    });
-    (0, import_vitest.it)("should handle method names with underscores", async () => {
-      const mockResponse = {
-        payload: {
-          message: "OK"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.post.mockResolvedValue(mockResponse);
-      await call.post("custom_app.api.test_method_name");
-      (0, import_vitest.expect)(mockHttpClient.post).toHaveBeenCalledWith("/api/method/custom_app.api.test_method_name", void 0);
-    });
-    (0, import_vitest.it)("should handle single word method names", async () => {
-      const mockResponse = {
-        payload: {
-          message: "OK"
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      await call.get("ping");
-      (0, import_vitest.expect)(mockHttpClient.get).toHaveBeenCalledWith("/api/method/ping", void 0);
-    });
-  });
-  (0, import_vitest.describe)("generic type handling", () => {
-    (0, import_vitest.it)("should handle custom generic types", async () => {
-      const mockResponse = {
-        payload: {
-          id: 1,
-          name: "Test",
-          items: ["item1", "item2"]
-        },
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      const result = await call.get("get_custom_data");
-      (0, import_vitest.expect)(result).toEqual(mockResponse);
-      (0, import_vitest.expect)(result.payload.id).toBe(1);
-      (0, import_vitest.expect)(result.payload.name).toBe("Test");
-      (0, import_vitest.expect)(result.payload.items).toHaveLength(2);
-    });
-    (0, import_vitest.it)("should handle array response types", async () => {
-      const mockResponse = {
-        payload: ["item1", "item2", "item3"],
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      const result = await call.get("get_list");
-      (0, import_vitest.expect)(result.payload).toEqual(["item1", "item2", "item3"]);
-    });
-    (0, import_vitest.it)("should handle primitive response types", async () => {
-      const mockResponse = {
-        payload: 42,
-        headers: new Headers(),
-        status: 200,
-        _res: {}
-      };
-      mockHttpClient.get.mockResolvedValue(mockResponse);
-      const result = await call.get("get_count");
-      (0, import_vitest.expect)(result.payload).toBe(42);
-    });
-  });
-});