@multiplatform.one/frappe 6.0.0

package/dist/cjs/core/http.spec.native.js

@@ -0,0 +1,1401 @@
+"use strict";
+
+var import_vitest = require("vitest");
+var import_http = require("./http.native.js");
+var import_types = require("./types.native.js");
+(0, import_vitest.describe)("HttpClient", function () {
+  var client;
+  var baseURL = "https://api.example.com";
+  var getMockFetch = function getMockFetch2() {
+    return import_vitest.vi.mocked(fetch);
+  };
+  (0, import_vitest.beforeEach)(function () {
+    client = new import_http.HttpClient(baseURL);
+    global.fetch = import_vitest.vi.fn();
+  });
+  (0, import_vitest.afterEach)(function () {
+    import_vitest.vi.restoreAllMocks();
+  });
+  (0, import_vitest.describe)("constructor", function () {
+    (0, import_vitest.it)("should initialize with base URL", function () {
+      var httpClient = new import_http.HttpClient(baseURL);
+      (0, import_vitest.expect)(httpClient).toBeDefined();
+    });
+    (0, import_vitest.it)("should accept auth config", function () {
+      var httpClient = new import_http.HttpClient(baseURL, {
+        useToken: true,
+        token: "test-token",
+        type: import_types.AuthType.Bearer
+      });
+      (0, import_vitest.expect)(httpClient).toBeDefined();
+    });
+    (0, import_vitest.it)("should accept retry config", function () {
+      var httpClient = new import_http.HttpClient(baseURL, void 0, {
+        maxRetries: 5,
+        baseDelayMs: 500,
+        exponentialBackoff: false
+      });
+      (0, import_vitest.expect)(httpClient).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("request", function () {
+    (0, import_vitest.it)("should make basic GET request", async function () {
+      var mockPayload = {
+        data: "test"
+      };
+      var mockHeaders = new Headers({
+        "Content-Type": "application/json"
+      });
+      var mockRes = {
+        ok: true,
+        headers: mockHeaders,
+        status: 200,
+        json: async function json() {
+          return mockPayload;
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      var result = await client.request(import_types.HttpMethod.Get, "/test", {});
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
+        method: "GET",
+        credentials: "include"
+      }));
+      (0, import_vitest.expect)(result.payload).toEqual(mockPayload);
+      (0, import_vitest.expect)(result.headers).toBe(mockHeaders);
+      (0, import_vitest.expect)(result.status).toBe(200);
+      (0, import_vitest.expect)(result._res).toBe(mockRes);
+    });
+    (0, import_vitest.it)("should make POST request with JSON body", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var requestBody = {
+        foo: "bar",
+        nested: {
+          value: 123
+        }
+      };
+      var mockPayload = {
+        success: true
+      };
+      var mockHeaders = new Headers({
+        "Content-Type": "application/json"
+      });
+      var mockRes = {
+        ok: true,
+        headers: mockHeaders,
+        status: 200,
+        json: async function json() {
+          return mockPayload;
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      var result = await client.request(import_types.HttpMethod.Post, "/test", {
+        body: requestBody
+      });
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify(requestBody),
+        headers: import_vitest.expect.any(Headers),
+        credentials: "include"
+      }));
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("Content-Type")).toBe("application/json");
+      (0, import_vitest.expect)(result.payload).toEqual(mockPayload);
+      (0, import_vitest.expect)(result.status).toBe(200);
+    });
+    (0, import_vitest.it)("should handle FormData body", async function () {
+      var formData = new FormData();
+      formData.append("field", "value");
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      var result = await client.request(import_types.HttpMethod.Post, "/upload", {
+        body: formData
+      });
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/upload`, import_vitest.expect.objectContaining({
+        method: "POST",
+        body: formData,
+        headers: import_vitest.expect.any(Headers),
+        credentials: "include"
+      }));
+      (0, import_vitest.expect)(result.payload).toEqual({
+        success: true
+      });
+    });
+    (0, import_vitest.it)("should handle URLSearchParams body", async function () {
+      var params = new URLSearchParams();
+      params.append("key", "value");
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "text/plain"
+        }),
+        status: 200,
+        text: async function text() {
+          return "success";
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      var result = await client.request(import_types.HttpMethod.Post, "/form", {
+        body: params
+      });
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/form`, import_vitest.expect.objectContaining({
+        method: "POST",
+        body: params,
+        credentials: "include"
+      }));
+      (0, import_vitest.expect)(result.payload).toBe("success");
+    });
+    (0, import_vitest.it)("should convert object to FormData when Content-Type is multipart/form-data", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var requestBody = {
+        field1: "value1",
+        field2: "value2"
+      };
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/test", {
+        body: requestBody,
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+      var calledBody = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.body;
+      (0, import_vitest.expect)(calledBody).toBeInstanceOf(FormData);
+    });
+    (0, import_vitest.it)("should convert object to URLSearchParams when Content-Type is application/x-www-form-urlencoded", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var requestBody = {
+        field1: "value1",
+        field2: "value2"
+      };
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "text/plain"
+        }),
+        status: 200,
+        text: async function text() {
+          return "success";
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/test", {
+        body: requestBody,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+      var calledBody = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.body;
+      (0, import_vitest.expect)(calledBody).toBe("field1=value1&field2=value2");
+    });
+    (0, import_vitest.it)("should handle text response", async function () {
+      var textResponse = "Plain text response";
+      var mockHeaders = new Headers({
+        "Content-Type": "text/plain"
+      });
+      var mockRes = {
+        ok: true,
+        headers: mockHeaders,
+        status: 200,
+        text: async function text() {
+          return textResponse;
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      var result = await client.request(import_types.HttpMethod.Get, "/text", {});
+      (0, import_vitest.expect)(result.payload).toBe(textResponse);
+      (0, import_vitest.expect)(result.headers).toBe(mockHeaders);
+      (0, import_vitest.expect)(result.status).toBe(200);
+    });
+    (0, import_vitest.it)("should throw FrappeError on non-ok response", async function () {
+      var errorPayload = {
+        message: "Bad Request",
+        details: "Invalid input"
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue({
+        ok: false,
+        status: 400,
+        statusText: "Bad Request",
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        json: async function json() {
+          return errorPayload;
+        }
+      });
+      await (0, import_vitest.expect)(client.request(import_types.HttpMethod.Post, "/test", {})).rejects.toThrow(import_types.FrappeError);
+      try {
+        await client.request(import_types.HttpMethod.Post, "/test", {});
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_types.FrappeError);
+        (0, import_vitest.expect)(error.status).toBe(400);
+        (0, import_vitest.expect)(error.message).toBe("Bad Request");
+        (0, import_vitest.expect)(error.data).toEqual(errorPayload);
+      }
+    });
+    (0, import_vitest.it)("should handle network errors", async function () {
+      var networkError = new Error("Network error");
+      global.fetch = import_vitest.vi.fn().mockRejectedValue(networkError);
+      await (0, import_vitest.expect)(client.request(import_types.HttpMethod.Get, "/test", {})).rejects.toThrow("Network error");
+    });
+  });
+  (0, import_vitest.describe)("authentication", function () {
+    (0, import_vitest.it)("should add Bearer token to headers", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_, _getMockFetch_mock_calls__1, _getMockFetch_mock_calls_1;
+      var token = "test-bearer-token";
+      var authClient = new import_http.HttpClient(baseURL, {
+        useToken: true,
+        token,
+        type: import_types.AuthType.Bearer
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await authClient.request(import_types.HttpMethod.Get, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("Authorization")).toBe(`Bearer ${token}`);
+      (0, import_vitest.expect)((_getMockFetch_mock_calls_1 = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_1 === void 0 ? void 0 : (_getMockFetch_mock_calls__1 = _getMockFetch_mock_calls_1[1]) === null || _getMockFetch_mock_calls__1 === void 0 ? void 0 : _getMockFetch_mock_calls__1.credentials).toBe("omit");
+    });
+    (0, import_vitest.it)("should add token auth to headers", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var token = "test-token";
+      var authClient = new import_http.HttpClient(baseURL, {
+        useToken: true,
+        token,
+        type: import_types.AuthType.Token
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await authClient.request(import_types.HttpMethod.Get, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("Authorization")).toBe(`token ${token}`);
+    });
+    (0, import_vitest.it)("should support token as function", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var token = "dynamic-token";
+      var authClient = new import_http.HttpClient(baseURL, {
+        useToken: true,
+        token: async function token1() {
+          return token;
+        },
+        type: import_types.AuthType.Bearer
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await authClient.request(import_types.HttpMethod.Get, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("Authorization")).toBe(`Bearer ${token}`);
+    });
+    (0, import_vitest.it)("should add CSRF token for non-GET requests without token auth", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var csrfToken = "csrf-test-token";
+      Object.defineProperty(global, "document", {
+        value: {
+          cookie: `frappe-csrf-token=${csrfToken}; path=/`
+        },
+        writable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: {},
+        writable: true
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Frappe-CSRF-Token")).toBe(csrfToken);
+      Object.defineProperty(global, "document", {
+        value: void 0,
+        configurable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: void 0,
+        configurable: true
+      });
+    });
+    (0, import_vitest.it)("should use credentials include when not using token auth", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Get, "/test", {});
+      (0, import_vitest.expect)((_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.credentials).toBe("include");
+    });
+    (0, import_vitest.it)("should set token dynamically via function", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var tokenFn = import_vitest.vi.fn().mockResolvedValue("new-token");
+      var authClient = new import_http.HttpClient(baseURL, {
+        useToken: true,
+        token: tokenFn
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await authClient.request(import_types.HttpMethod.Get, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("Authorization")).toBe("Bearer new-token");
+      (0, import_vitest.expect)(tokenFn).toHaveBeenCalledTimes(1);
+    });
+  });
+  (0, import_vitest.describe)("retry logic", function () {
+    (0, import_vitest.it)("should retry on retry-able status codes", async function () {
+      var retryClient = new import_http.HttpClient(baseURL, void 0, {
+        maxRetries: 2,
+        baseDelayMs: 10,
+        retryStatusCodes: [503]
+      });
+      var attempt = 0;
+      global.fetch = import_vitest.vi.fn().mockImplementation(async function () {
+        attempt++;
+        if (attempt < 3) {
+          return {
+            ok: false,
+            status: 503,
+            statusText: "Service Unavailable",
+            headers: new Headers({
+              "Content-Type": "text/plain"
+            }),
+            text: async function text() {
+              return "Service temporarily unavailable";
+            }
+          };
+        }
+        return {
+          ok: true,
+          headers: new Headers({
+            "Content-Type": "application/json"
+          }),
+          status: 200,
+          json: async function json() {
+            return {
+              success: true
+            };
+          }
+        };
+      });
+      var result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(3);
+      (0, import_vitest.expect)(result.payload).toEqual({
+        success: true
+      });
+    });
+    (0, import_vitest.it)("should retry on network errors when configured", async function () {
+      var retryClient = new import_http.HttpClient(baseURL, void 0, {
+        maxRetries: 1,
+        baseDelayMs: 10,
+        retryOnNetworkError: true
+      });
+      var attempt = 0;
+      global.fetch = import_vitest.vi.fn().mockImplementation(async function () {
+        attempt++;
+        if (attempt === 1) {
+          throw new Error("Network error");
+        }
+        return {
+          ok: true,
+          headers: new Headers({
+            "Content-Type": "application/json"
+          }),
+          status: 200,
+          json: async function json() {
+            return {
+              success: true
+            };
+          }
+        };
+      });
+      var result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(2);
+      (0, import_vitest.expect)(result.payload).toEqual({
+        success: true
+      });
+    });
+    (0, import_vitest.it)("should not retry on non-retry-able status codes", async function () {
+      var retryClient = new import_http.HttpClient(baseURL, void 0, {
+        maxRetries: 2,
+        baseDelayMs: 10,
+        retryStatusCodes: [503]
+      });
+      global.fetch = import_vitest.vi.fn().mockResolvedValue({
+        ok: false,
+        status: 400,
+        statusText: "Bad Request",
+        headers: new Headers({
+          "Content-Type": "text/plain"
+        }),
+        text: async function text() {
+          return "Bad request";
+        }
+      });
+      await (0, import_vitest.expect)(retryClient.request(import_types.HttpMethod.Get, "/test", {})).rejects.toThrow(import_types.FrappeError);
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(1);
+    });
+    (0, import_vitest.it)("should use exponential backoff when configured", async function () {
+      var retryClient = new import_http.HttpClient(baseURL, void 0, {
+        maxRetries: 3,
+        baseDelayMs: 100,
+        exponentialBackoff: true,
+        maxDelayMs: 500,
+        retryStatusCodes: [503]
+      });
+      var delays = [];
+      import_vitest.vi.spyOn(global, "setTimeout").mockImplementation(function (fn, delay) {
+        delays.push(delay || 0);
+        if (typeof fn === "function") fn();
+        return 0;
+      });
+      var attempt = 0;
+      global.fetch = import_vitest.vi.fn().mockImplementation(async function () {
+        attempt++;
+        if (attempt <= 3) {
+          return {
+            ok: false,
+            status: 503,
+            statusText: "Service Unavailable",
+            headers: new Headers({
+              "Content-Type": "text/plain"
+            }),
+            text: async function text() {
+              return "Service unavailable";
+            }
+          };
+        }
+        return {
+          ok: true,
+          headers: new Headers({
+            "Content-Type": "application/json"
+          }),
+          status: 200,
+          json: async function json() {
+            return {
+              success: true
+            };
+          }
+        };
+      });
+      var result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
+      (0, import_vitest.expect)(delays[0]).toBe(100);
+      (0, import_vitest.expect)(delays[1]).toBe(200);
+      (0, import_vitest.expect)(delays[2]).toBe(400);
+      (0, import_vitest.expect)(result.payload).toEqual({
+        success: true
+      });
+    });
+    (0, import_vitest.it)("should respect maxDelayMs", async function () {
+      var retryClient = new import_http.HttpClient(baseURL, void 0, {
+        maxRetries: 3,
+        baseDelayMs: 100,
+        exponentialBackoff: true,
+        maxDelayMs: 150,
+        retryStatusCodes: [503]
+      });
+      var delays = [];
+      import_vitest.vi.spyOn(global, "setTimeout").mockImplementation(function (fn, delay) {
+        delays.push(delay || 0);
+        if (typeof fn === "function") fn();
+        return 0;
+      });
+      var attempt = 0;
+      global.fetch = import_vitest.vi.fn().mockImplementation(async function () {
+        attempt++;
+        if (attempt <= 3) {
+          return {
+            ok: false,
+            status: 503,
+            statusText: "Service Unavailable",
+            headers: new Headers({
+              "Content-Type": "text/plain"
+            }),
+            text: async function text() {
+              return "Service unavailable";
+            }
+          };
+        }
+        return {
+          ok: true,
+          headers: new Headers({
+            "Content-Type": "application/json"
+          }),
+          status: 200,
+          json: async function json() {
+            return {
+              success: true
+            };
+          }
+        };
+      });
+      var result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
+      (0, import_vitest.expect)(delays[0]).toBe(100);
+      (0, import_vitest.expect)(delays[1]).toBe(150);
+      (0, import_vitest.expect)(delays[2]).toBe(150);
+      (0, import_vitest.expect)(result.payload).toEqual({
+        success: true
+      });
+    });
+    (0, import_vitest.it)("should use custom shouldRetry function", async function () {
+      var shouldRetry = import_vitest.vi.fn(function (_err, attempt2) {
+        return attempt2 < 2;
+      });
+      var retryClient = new import_http.HttpClient(baseURL, void 0, {
+        maxRetries: 3,
+        baseDelayMs: 10,
+        shouldRetry
+      });
+      var attempt = 0;
+      global.fetch = import_vitest.vi.fn().mockImplementation(async function () {
+        attempt++;
+        if (attempt < 3) {
+          return {
+            ok: false,
+            status: 500,
+            statusText: "Internal Server Error",
+            headers: new Headers({
+              "Content-Type": "text/plain"
+            }),
+            text: async function text() {
+              return "Server error";
+            }
+          };
+        }
+        return {
+          ok: true,
+          headers: new Headers({
+            "Content-Type": "application/json"
+          }),
+          status: 200,
+          json: async function json() {
+            return {
+              success: true
+            };
+          }
+        };
+      });
+      var result = await retryClient.request(import_types.HttpMethod.Get, "/test", {});
+      (0, import_vitest.expect)(shouldRetry).toHaveBeenCalledTimes(2);
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(3);
+      (0, import_vitest.expect)(result.payload).toEqual({
+        success: true
+      });
+    });
+    (0, import_vitest.it)("should throw last error after max retries", async function () {
+      var retryClient = new import_http.HttpClient(baseURL, void 0, {
+        maxRetries: 2,
+        baseDelayMs: 10,
+        retryStatusCodes: [503]
+      });
+      global.fetch = import_vitest.vi.fn().mockResolvedValue({
+        ok: false,
+        status: 503,
+        statusText: "Service Unavailable",
+        headers: new Headers({
+          "Content-Type": "text/plain"
+        }),
+        text: async function text() {
+          return "Service unavailable";
+        }
+      });
+      await (0, import_vitest.expect)(retryClient.request(import_types.HttpMethod.Get, "/test", {})).rejects.toThrow(import_types.FrappeError);
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledTimes(3);
+    });
+  });
+  (0, import_vitest.describe)("convenience methods", function () {
+    (0, import_vitest.beforeEach)(function () {
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+    });
+    (0, import_vitest.describe)("get", function () {
+      (0, import_vitest.it)("should make GET request without params", async function () {
+        var result = await client.get("/test");
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
+          method: "GET"
+        }));
+        (0, import_vitest.expect)(result.payload).toEqual({
+          success: true
+        });
+      });
+      (0, import_vitest.it)("should make GET request with params", async function () {
+        await client.get("/test", {
+          foo: "bar",
+          num: 123,
+          bool: true,
+          nullValue: null,
+          undefinedValue: void 0
+        });
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test?foo=bar&num=123&bool=true`, import_vitest.expect.objectContaining({
+          method: "GET"
+        }));
+      });
+      (0, import_vitest.it)("should handle complex params", async function () {
+        await client.get("/test", {
+          array: [1, 2, 3],
+          object: {
+            nested: "value"
+          }
+        });
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test?array=%5B1%2C2%2C3%5D&object=%7B%22nested%22%3A%22value%22%7D`, import_vitest.expect.objectContaining({
+          method: "GET"
+        }));
+      });
+      (0, import_vitest.it)("should pass custom headers", async function () {
+        var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+        await client.get("/test", {}, {
+          "X-Custom": "header"
+        });
+        var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+        (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Custom")).toBe("header");
+      });
+    });
+    (0, import_vitest.describe)("post", function () {
+      (0, import_vitest.it)("should make POST request without body", async function () {
+        var result = await client.post("/test");
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
+          method: "POST"
+        }));
+        (0, import_vitest.expect)(result.payload).toEqual({
+          success: true
+        });
+      });
+      (0, import_vitest.it)("should make POST request with body", async function () {
+        var body = {
+          data: "test"
+        };
+        var result = await client.post("/test", body);
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
+          method: "POST",
+          body: JSON.stringify(body)
+        }));
+        (0, import_vitest.expect)(result.payload).toEqual({
+          success: true
+        });
+      });
+      (0, import_vitest.it)("should pass custom headers", async function () {
+        var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+        await client.post("/test", {}, {
+          "X-Custom": "header"
+        });
+        var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+        (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Custom")).toBe("header");
+      });
+    });
+    (0, import_vitest.describe)("put", function () {
+      (0, import_vitest.it)("should make PUT request", async function () {
+        var body = {
+          data: "test"
+        };
+        var result = await client.put("/test", body);
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
+          method: "PUT",
+          body: JSON.stringify(body)
+        }));
+        (0, import_vitest.expect)(result.payload).toEqual({
+          success: true
+        });
+      });
+      (0, import_vitest.it)("should pass custom headers", async function () {
+        var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+        await client.put("/test", {}, {
+          "X-Custom": "header"
+        });
+        var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+        (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Custom")).toBe("header");
+      });
+    });
+    (0, import_vitest.describe)("delete", function () {
+      (0, import_vitest.it)("should make DELETE request", async function () {
+        var result = await client.delete("/test");
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
+          method: "DELETE"
+        }));
+        (0, import_vitest.expect)(result.payload).toEqual({
+          success: true
+        });
+      });
+      (0, import_vitest.it)("should make DELETE request with body", async function () {
+        var body = {
+          id: "123"
+        };
+        var result = await client.delete("/test", body);
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
+          method: "DELETE",
+          body: JSON.stringify(body)
+        }));
+        (0, import_vitest.expect)(result.payload).toEqual({
+          success: true
+        });
+      });
+      (0, import_vitest.it)("should pass custom headers", async function () {
+        var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+        await client.delete("/test", void 0, {
+          "X-Custom": "header"
+        });
+        var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+        (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Custom")).toBe("header");
+      });
+    });
+    (0, import_vitest.describe)("head", function () {
+      (0, import_vitest.it)("should make HEAD request and return response", async function () {
+        var mockRes = {
+          ok: true,
+          headers: new Headers({
+            "Content-Type": "application/json",
+            "Content-Length": "1234"
+          }),
+          status: 200,
+          text: async function text() {
+            return "";
+          },
+          json: async function json() {
+            return {};
+          }
+        };
+        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+        var response = await client.head("/test");
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test`, import_vitest.expect.objectContaining({
+          method: "HEAD"
+        }));
+        (0, import_vitest.expect)(response.headers.get("Content-Type")).toBe("application/json");
+        (0, import_vitest.expect)(response.headers.get("Content-Length")).toBe("1234");
+        (0, import_vitest.expect)(response.status).toBe(200);
+      });
+      (0, import_vitest.it)("should make HEAD request with params", async function () {
+        var mockRes = {
+          ok: true,
+          headers: new Headers(),
+          status: 200,
+          text: async function text() {
+            return "";
+          },
+          json: async function json() {
+            return {};
+          }
+        };
+        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+        var response = await client.head("/test", {
+          check: "true"
+        });
+        (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/test?check=true`, import_vitest.expect.objectContaining({
+          method: "HEAD"
+        }));
+        (0, import_vitest.expect)(response.status).toBe(200);
+      });
+      (0, import_vitest.it)("should pass custom headers", async function () {
+        var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+        var mockRes = {
+          ok: true,
+          headers: new Headers(),
+          status: 200,
+          text: async function text() {
+            return "";
+          },
+          json: async function json() {
+            return {};
+          }
+        };
+        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+        await client.head("/test", {}, {
+          "X-Custom": "header"
+        });
+        var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+        (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Custom")).toBe("header");
+      });
+      (0, import_vitest.it)("should throw FrappeError on non-ok response", async function () {
+        global.fetch = import_vitest.vi.fn().mockResolvedValue({
+          ok: false,
+          status: 404,
+          statusText: "Not Found",
+          headers: new Headers(),
+          text: async function text() {
+            return "Not found";
+          }
+        });
+        await (0, import_vitest.expect)(client.head("/test")).rejects.toThrow(import_types.FrappeError);
+        try {
+          await client.head("/test");
+        } catch (error) {
+          (0, import_vitest.expect)(error).toBeInstanceOf(import_types.FrappeError);
+          (0, import_vitest.expect)(error.status).toBe(404);
+          (0, import_vitest.expect)(error.message).toBe("Not Found");
+        }
+      });
+      (0, import_vitest.it)("should use credentials include when not using token auth", async function () {
+        var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+        var mockRes = {
+          ok: true,
+          headers: new Headers(),
+          status: 200,
+          text: async function text() {
+            return "";
+          },
+          json: async function json() {
+            return {};
+          }
+        };
+        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+        await client.head("/test");
+        (0, import_vitest.expect)((_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.credentials).toBe("include");
+      });
+      (0, import_vitest.it)("should use credentials omit and add auth header when using token auth", async function () {
+        var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_, _getMockFetch_mock_calls__1, _getMockFetch_mock_calls_1;
+        var authClient = new import_http.HttpClient(baseURL, {
+          useToken: true,
+          token: "test-token",
+          type: import_types.AuthType.Bearer
+        });
+        var mockRes = {
+          ok: true,
+          headers: new Headers(),
+          status: 200,
+          text: async function text() {
+            return "";
+          },
+          json: async function json() {
+            return {};
+          }
+        };
+        global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+        await authClient.head("/test");
+        (0, import_vitest.expect)((_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.credentials).toBe("omit");
+        var calledHeaders = (_getMockFetch_mock_calls_1 = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_1 === void 0 ? void 0 : (_getMockFetch_mock_calls__1 = _getMockFetch_mock_calls_1[1]) === null || _getMockFetch_mock_calls__1 === void 0 ? void 0 : _getMockFetch_mock_calls__1.headers;
+        (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("Authorization")).toBe("Bearer test-token");
+      });
+    });
+  });
+  (0, import_vitest.describe)("edge cases", function () {
+    (0, import_vitest.it)("should handle empty response", async function () {
+      var mockRes = {
+        ok: true,
+        headers: new Headers(),
+        status: 200,
+        text: async function text() {
+          return "";
+        },
+        json: async function json() {
+          throw new Error("Invalid JSON");
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      var result = await client.request(import_types.HttpMethod.Get, "/empty", {});
+      (0, import_vitest.expect)(result.payload).toBe("");
+      (0, import_vitest.expect)(result.status).toBe(200);
+    });
+    (0, import_vitest.it)("should handle ArrayBuffer body", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var buffer = new ArrayBuffer(8);
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/binary", {
+        body: buffer
+      });
+      (0, import_vitest.expect)((_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.body).toBe(buffer);
+    });
+    (0, import_vitest.it)("should handle Blob body", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var blob = new Blob(["test"], {
+        type: "text/plain"
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/blob", {
+        body: blob
+      });
+      (0, import_vitest.expect)((_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.body).toBe(blob);
+    });
+    (0, import_vitest.it)("should handle ArrayBufferView body", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var uint8Array = new Uint8Array([1, 2, 3, 4]);
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/typed-array", {
+        body: uint8Array
+      });
+      (0, import_vitest.expect)((_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.body).toBe(uint8Array);
+    });
+    (0, import_vitest.it)("should handle relative paths", async function () {
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Get, "relative/path", {});
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/relative/path`, import_vitest.expect.any(Object));
+    });
+    (0, import_vitest.it)("should handle absolute paths", async function () {
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Get, "/absolute/path", {});
+      (0, import_vitest.expect)(fetch).toHaveBeenCalledWith(`${baseURL}/absolute/path`, import_vitest.expect.any(Object));
+    });
+    (0, import_vitest.it)("should handle error response with _server_messages", async function () {
+      var errorPayload = {
+        _server_messages: "Server error messages",
+        exc: "Exception details",
+        message: "Error message"
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: "Internal Server Error",
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        json: async function json() {
+          return errorPayload;
+        }
+      });
+      try {
+        await client.request(import_types.HttpMethod.Post, "/test", {});
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_types.FrappeError);
+        (0, import_vitest.expect)(error.message).toBe("Error message");
+      }
+    });
+    (0, import_vitest.it)("should handle error response with exc", async function () {
+      var errorPayload = {
+        exc: "Exception details"
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: "Internal Server Error",
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        json: async function json() {
+          return errorPayload;
+        }
+      });
+      try {
+        await client.request(import_types.HttpMethod.Post, "/test", {});
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_types.FrappeError);
+        (0, import_vitest.expect)(error.message).toBe("Exception details");
+      }
+    });
+    (0, import_vitest.it)("should handle FormData with Blob values", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var blob = new Blob(["file content"], {
+        type: "text/plain"
+      });
+      var requestBody = {
+        field: "value",
+        file: blob
+      };
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/upload", {
+        body: requestBody,
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+      var calledBody = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.body;
+      (0, import_vitest.expect)(calledBody).toBeInstanceOf(FormData);
+    });
+    (0, import_vitest.it)("should skip non-string values in URLSearchParams conversion", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var requestBody = {
+        field1: "value1",
+        field2: 123,
+        field3: null,
+        field4: void 0
+      };
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "text/plain"
+        }),
+        status: 200,
+        text: async function text() {
+          return "success";
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/test", {
+        body: requestBody,
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+      var calledBody = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.body;
+      (0, import_vitest.expect)(calledBody).toBe("field1=value1");
+    });
+    (0, import_vitest.it)("should handle ReadableStream body", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      var stream = new ReadableStream();
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/stream", {
+        body: stream
+      });
+      (0, import_vitest.expect)((_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.body).toBe(stream);
+    });
+    (0, import_vitest.it)("should handle global frappe csrf token", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      Object.defineProperty(global, "document", {
+        value: {
+          cookie: ""
+        },
+        writable: true,
+        configurable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: {},
+        writable: true,
+        configurable: true
+      });
+      Object.defineProperty(global, "frappe", {
+        value: {
+          csrf_token: "global-csrf-token"
+        },
+        writable: true,
+        configurable: true
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Frappe-CSRF-Token")).toBe("global-csrf-token");
+      Object.defineProperty(global, "document", {
+        value: void 0,
+        configurable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: void 0,
+        configurable: true
+      });
+      Object.defineProperty(global, "frappe", {
+        value: void 0,
+        configurable: true
+      });
+    });
+    (0, import_vitest.it)("should prefer frappe-csrf-token cookie over csrf_token", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      Object.defineProperty(global, "document", {
+        value: {
+          cookie: "frappe-csrf-token=preferred; csrf_token=fallback"
+        },
+        writable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: {},
+        writable: true
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Frappe-CSRF-Token")).toBe("preferred");
+      Object.defineProperty(global, "document", {
+        value: void 0,
+        configurable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: void 0,
+        configurable: true
+      });
+    });
+    (0, import_vitest.it)("should use csrf_token cookie as fallback", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      Object.defineProperty(global, "document", {
+        value: {
+          cookie: "csrf_token=fallback"
+        },
+        writable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: {},
+        writable: true
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Frappe-CSRF-Token")).toBe("fallback");
+      Object.defineProperty(global, "document", {
+        value: void 0,
+        configurable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: void 0,
+        configurable: true
+      });
+    });
+    (0, import_vitest.it)("should not add CSRF token for GET requests", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      Object.defineProperty(global, "document", {
+        value: {
+          cookie: "frappe-csrf-token=test-token"
+        },
+        writable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: {},
+        writable: true
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Get, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Frappe-CSRF-Token")).toBeNull();
+      Object.defineProperty(global, "document", {
+        value: void 0,
+        configurable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: void 0,
+        configurable: true
+      });
+    });
+    (0, import_vitest.it)("should handle cookie with special characters", async function () {
+      var _getMockFetch_mock_calls__, _getMockFetch_mock_calls_;
+      Object.defineProperty(global, "document", {
+        value: {
+          cookie: "frappe-csrf-token=%2Ftest%2Ftoken%3D"
+        },
+        writable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: {},
+        writable: true
+      });
+      var mockRes = {
+        ok: true,
+        headers: new Headers({
+          "Content-Type": "application/json"
+        }),
+        status: 200,
+        json: async function json() {
+          return {
+            success: true
+          };
+        }
+      };
+      global.fetch = import_vitest.vi.fn().mockResolvedValue(mockRes);
+      await client.request(import_types.HttpMethod.Post, "/test", {});
+      var calledHeaders = (_getMockFetch_mock_calls_ = getMockFetch().mock.calls[0]) === null || _getMockFetch_mock_calls_ === void 0 ? void 0 : (_getMockFetch_mock_calls__ = _getMockFetch_mock_calls_[1]) === null || _getMockFetch_mock_calls__ === void 0 ? void 0 : _getMockFetch_mock_calls__.headers;
+      (0, import_vitest.expect)(calledHeaders === null || calledHeaders === void 0 ? void 0 : calledHeaders.get("X-Frappe-CSRF-Token")).toBe("/test/token=");
+      Object.defineProperty(global, "document", {
+        value: void 0,
+        configurable: true
+      });
+      Object.defineProperty(global, "window", {
+        value: void 0,
+        configurable: true
+      });
+    });
+  });
+});
+//# sourceMappingURL=http.spec.native.js.map