fch 2.0.0 → 2.0.1

package/fetch.js

@@ -136,13 +136,6 @@ const fch = swear((url, options = {}) => {
   }
 });
 
-fch.get = (url, options = {}) => fch(url, { ...options, method: "get" });
-fch.head = (url, options = {}) => fch(url, { ...options, method: "head" });
-fch.post = (url, options = {}) => fch(url, { ...options, method: "post" });
-fch.patch = (url, options = {}) => fch(url, { ...options, method: "patch" });
-fch.put = (url, options = {}) => fch(url, { ...options, method: "put" });
-fch.del = (url, options = {}) => fch(url, { ...options, method: "delete" });
-
 // Default values
 fch.method = "get";
 fch.headers = {};
@@ -156,4 +149,23 @@ fch.before = (request) => request;
 fch.after = (response) => response;
 fch.error = (error) => Promise.reject(error);
 
+const request = (url, opts = {}) => fch(url, { ...opts });
+const get = (url, opts = {}) => fch(url, { ...opts });
+const head = (url, opts = {}) => fch(url, { ...opts, method: "head" });
+const post = (url, opts = {}) => fch(url, { ...opts, method: "post" });
+const patch = (url, opts = {}) => fch(url, { ...opts, method: "patch" });
+const put = (url, opts = {}) => fch(url, { ...opts, method: "put" });
+const del = (url, opts = {}) => fch(url, { ...opts, method: "delete" });
+
+fch.request = request;
+fch.get = get;
+fch.head = head;
+fch.post = post;
+fch.patch = patch;
+fch.put = put;
+fch.del = del;
+
+fch.swear = swear;
+
 export default fch;
+export { request, get, head, post, patch, put, del, swear };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fch",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Fetch interface with better promises, deduplication, defaults, etc.",
   "homepage": "https://github.com/franciscop/fetch",
   "repository": "https://github.com/franciscop/fetch.git",
@@ -22,6 +22,7 @@
     "ajax"
   ],
   "main": "fetch.js",
+  "files": [],
   "type": "module",
   "engines": {
     "node": ">=18.0.0"

package/readme.md

@@ -4,10 +4,7 @@ A library to make API calls easier. Similar to Axios, but tiny size and simpler
 
 ```js
 import api from "fch";
-
-api.baseUrl = "https://pokeapi.co/";
-
-const mew = await api("/pokemon/150");
+const mew = await api("https://pokeapi.co/pokemon/150");
 console.log(mew);
 ```
 
@@ -15,11 +12,10 @@ console.log(mew);
 
 - Automatically `JSON.stringify()` and `Content-Type: 'application/json'` for plain objects.
 - Automatically parse server response as json if it includes the headers, or text otherwise.
-- Isomorphic fetch(); it works the same way in the browser and server.
+- Works the same way in Node.js and the browser.
 - Await/Async Promise interface works as you know and love.
 - Better error handling. `>= 400 and <= 100` will _reject_ the promise with an error instance.
 - Advanced [Promise interface](https://www.npmjs.com/swear) for better scripting.
-- Import with the shorthand for tighter syntax. `import { get, post } from 'fch';`.
 - Easily define shared options straight on the root `fetch.baseUrl = "https://...";`.
 - Interceptors: `before` (the request), `after` (the response) and `error` (it fails).
 - Deduplicates parallel GET requests.
@@ -27,6 +23,24 @@ console.log(mew);
 - [TODO]: cache engine with "highs" and "lows", great for scrapping
 - [TODO]: rate-limiting of requests (N-second, or N-parallel), great for scrapping
 
+These are the available options and their defaults:
+
+- `api.baseUrl = null;`: Set an API endpoint
+- `api.method = 'get';`: Default method to use for api()
+- `api.headers = {};`: Merged with the headers on a per-request basis
+- `api.dedupe = true;`: Avoid parallel GET requests to the same path
+- `api.output = 'body';`: Return the body; use 'response' for the full response
+- `api.before = req => req;`: Interceptor executed before sending the request
+- `api.after = res => res;`: Handle the responses before returning them
+- `api.error = err => Promise.reject(err);`: handle any error thrown by fch
+- `api(url, { method, body, headers, ... })`
+- `api.get(url, { headers, ... });`: helper for convenience
+- `api.head(url, { headers, ... });`: helper for convenience
+- `api.post(url, { body, headers, ... });`: helper for convenience
+- `api.patch(url, { body, headers, ... });`: helper for convenience
+- `api.put(url, { body, headers, ... });`: helper for convenience
+- `api.del(url, { body, headers, ... });`: helper for convenience
+
 ## Getting Started
 
 Install it in your project:
@@ -43,79 +57,124 @@ import api from 'fch';
 const data = await api.get('/');
 ```
 
+## Options
 
-### Advanced promise interface
+```js
+import api, { get, post, put, ... } from 'fch';
+
+// General options with their defaults; most of these are also parameters:
+api.baseUrl = null;  // Set an API endpoint
+api.method = 'get';  // Default method to use for api()
+api.headers = {};    // Is merged with the headers on a per-request basis
+
+// Control simple variables
+api.dedupe = true;   // Avoid parallel GET requests to the same path
+api.output = 'body'; // Return the body; use 'response' for the full response
+
+// Interceptors
+api.before = req => req;
+api.after = res => res;
+api.error = err => Promise.reject(err);
+
+// Similar API to fetch()
+api(url, { method, body, headers, ... });
+
+// Our highly recommended style:
+api.get(url, { headers, ... });
+api.post(url, { body, headers, ... });
+api.put(url, { body, headers, ... });
+// ...
+
+// Just import/use the method you need
+get(url, { headers, ... });
+post(url, { body, headers, ... });
+put(url, { body, headers, ... });
+// ...
+```
 
-This library has a couple of aces up its sleeve. First, it [has a better Promise interface](https://www.npmjs.com/swear):
+### URL
+
+This is normally the first argument, though technically you can use both styles:
 
 ```js
-import api from "fch";
+// All of these methods are valid
+import api from 'fch';
 
-// You can keep performing actions like it was sync
-const firstFriendName = await api.get("/friends")[0].name;
-console.log(firstFriendName);
+// We strongly recommend using this style for your normal code:
+await api.post('/hello', { body: '...', headers: {} })
+
+// Try to avoid these, but they are also valid:
+await api('/hello', { method: 'post', body: '...', headers: {} });
+await api({ url: '/hello', method: 'post', headers: {}, body: '...' });
+await api.post({ url: '/hello', headers: {}, body: '...' });
 ```
 
-### Define shared options
+It can be either absolute or relative, in which case it'll use the local one in the page. It's recommending to set `baseUrl`:
 
-You can also define values straight away:
+```js
+import api from 'fch';
+api.baseUrl = 'https//api.filemon.io/';
+api.get('/hello');
+// Called https//api.filemon.io/hello
+```
+
+### Body
+
+The `body` can be a string, a FormData instance or a plain object. If it's an object, it'll be stringified and the header `application/json` will be added. Otherwise it'll be sent as plain text:
 
 ```js
-import api from "fch";
+import api from 'api';
 
-api.baseUrl = "https://pokeapi.co/";
+// Sending plain text
+await api.post('/houses', { body: 'plain text' });
 
-const mew = await api.get("/pokemon/150");
-console.log(mew);
+// Will JSON.stringify it internally, and add the JSON headers
+await api.post('/houses', { body: { id: 1, name: 'Cute Cottage' } });
+
+// Send it as FormData
+form.onsubmit = e => {
+  await api.post('/houses', { body: new FormData(e.target) });
+};
 ```
 
-If you prefer Axios' style of outputting the whole response, you can do:
+
+### Headers
+
+You can define headers globally, in which case they'll be added to every request, or locally, so that they are only added to the current request. You can also add them in the `before` callback:
+
 
 ```js
-// Default, already only returns the data on a successful call
-api.output = "data";
-const name = await api.get("/users/1").name;
+import api from 'fch';
+api.headers.abc = 'def';
 
-// Axios-like
-api.output = "response";
-const name = await api.get("/users/1").data.name;
+api.get('/helle', { headers: { ghi: 'jkl' } });
+// Total headers on the request:
+// { abc: 'def', ghi: 'jkl' }
 ```
 
-### Interceptors
 
-You can also easily add the interceptors `before`, `after` and `error`:
+### Output
+
+This controls whether the call returns just the body (default), or the whole response. It can be controlled globally or on a per-request basis:
 
 ```js
-// Perform an action or request transformation before the request is sent
-fch.before = async req => {
-  // Normalized request ready to be sent
-  ...
-  return req;
-};
+import api from 'fch';
 
-// Perform an action or data transformation after the request is finished
-fch.after = async res => {
-  // Full response as just after the request is made
-  ...
-  return res;
-};
+// "body" (default) or "response"
+api.output = 'body';
 
-// Perform an action or data transformation when an error is thrown
-fch.error = async err => {
-  // Need to re-throw if we want to throw on error
-  ...
-  throw err;
+// Return only the body, this is the default
+const body = await api.get('/data');
 
-  // OR, resolve it as if it didn't fail
-  return err.response;
+// Return the whole response (with .body):
+const response = await api.get('/data', { output: 'response' });
 
-  // OR, resolve it with a custom value
-  return { message: 'Request failed with a code ' + err.response.status };
-};
+// Throws error
+const invalid = await api.get('/data', { output: 'invalid' });
 ```
 
 
-## Dedupe
+### Dedupe
 
 When you perform a GET request to a given URL, but another GET request *to the same* URL is ongoing, it'll **not** create a new request and instead reuse the response when the first one is finished:
 
@@ -157,28 +216,90 @@ it("can opt out locally", async () => {
 });
 ```
 
+### Interceptors
 
-## How to
+You can also easily add the interceptors `before`, `after` and `error`:
 
-### Stop errors from throwing
+```js
+// Perform an action or request transformation before the request is sent
+fch.before = async req => {
+  // Normalized request ready to be sent
+  ...
+  return req;
+};
+
+// Perform an action or data transformation after the request is finished
+fch.after = async res => {
+  // Full response as just after the request is made
+  ...
+  return res;
+};
+
+// Perform an action or data transformation when an error is thrown
+fch.error = async err => {
+  // Need to re-throw if we want to throw on error
+  ...
+  throw err;
+
+  // OR, resolve it as if it didn't fail
+  return err.response;
 
-While you can handle this on a per-request basis, if you want to overwrite the global behavior you can just do:
+  // OR, resolve it with a custom value
+  return { message: 'Request failed with a code ' + err.response.status };
+};
+```
+
+
+
+### Advanced promise interface
+
+This library uses [the `swear` promise interface](https://www.npmjs.com/swear), which allows you to query operations seamlessly on top of your promise:
 
 ```js
-import fch from 'fch';
-fch.error = error => error.response;
+import api from "fch";
 
-const res = fch('/notfound');
-expect(res.status).toBe(404);
+// You can keep performing actions like it was sync
+const firstFriendName = await api.get("/friends")[0].name;
+console.log(firstFriendName);
+```
+
+### Define shared options
+
+You can also define values straight away:
+
+```js
+import api from "fch";
+
+api.baseUrl = "https://pokeapi.co/";
+
+const mew = await api.get("/pokemon/150");
+console.log(mew);
 ```
 
-Just that, then when there's an error it'll just return as usual, e.g.:
+If you prefer Axios' style of outputting the whole response, you can do:
+
+```js
+// Default, already only returns the data on a successful call
+api.output = "data";
+const name = await api.get("/users/1").name;
+
+// Axios-like
+api.output = "response";
+const name = await api.get("/users/1").data.name;
+```
+
+
+## How to
+
+### Stop errors from throwing
+
+While you can handle this on a per-request basis, if you want to overwrite the global behavior you can write a interceptor:
 
 ```js
 import fch from 'fch';
 fch.error = error => error.response;
 
-const res = fch('/notfound');
+const res = await fch('/notfound');
 expect(res.status).toBe(404);
 ```
 
@@ -214,8 +335,8 @@ There's a configuration parameter for that:
 import fch from 'fch';
 fch.baseUrl = 'https://api.filemon.io/';
 
-// Calls "https://api.filemon.io/blabla/"
-const body = await fch.get('/blabla/');
+// Calls "https://api.filemon.io/blabla"
+const body = await fch.get('/blabla');
 ```
 
 
@@ -230,7 +351,7 @@ fch.headers.Authorization = 'bearer abc';
 const me = await fch('/users/me');
 ```
 
-Globally on a per-request basis, for example if you take the value from localStorage:
+Or globally on a per-request basis, for example if you take the value from localStorage:
 
 ```js
 import fch from 'fch';

package/fetch.test.js

@@ -1,370 +0,0 @@
-import fch from "./fetch.js";
-import mock from "jest-fetch-mock";
-
-mock.enableMocks();
-
-const jsonHeaders = { headers: { "Content-Type": "application/json" } };
-
-describe("fetch()", () => {
-  beforeEach(() => {
-    fetch.resetMocks();
-  });
-
-  it("can create a basic request", async () => {
-    fetch.once("hello");
-    const data = await fch("/");
-
-    expect(data).toEqual("hello");
-    expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual("/");
-    expect(fetch.mock.calls[0][1].method).toEqual("get");
-    expect(fetch.mock.calls[0][1].headers).toEqual({});
-  });
-
-  it("accepts Axios syntax as well", async () => {
-    fetch.once("hello");
-    const data = await fch({ url: "/" });
-
-    expect(data).toEqual("hello");
-    expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual("/");
-    expect(fetch.mock.calls[0][1].method).toEqual("get");
-    expect(fetch.mock.calls[0][1].headers).toEqual({});
-  });
-
-  it("can receive a full response", async () => {
-    fetch.once("hello", { status: 200, headers: { hello: "world" } });
-    const res = await fch("/", { output: "response" });
-
-    expect(res.body).toEqual("hello");
-    expect(res.status).toEqual(200);
-    expect(res.statusText).toEqual("OK");
-    expect(res.headers.hello).toEqual("world");
-    expect(fetch.mock.calls.length).toEqual(1);
-  });
-
-  it("works with JSON", async () => {
-    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
-    const data = await fch("https://google.com/");
-
-    expect(data).toEqual({ secret: "12345" });
-    expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual("https://google.com/");
-  });
-
-  it("can use the swear interface", async () => {
-    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
-    const hello = await fch("/").secret;
-    expect(hello).toEqual("12345");
-  });
-
-  it("can use the baseUrl", async () => {
-    fetch.once("hi");
-    fch.baseUrl = "https://google.com/";
-    const data = await fch.get("/hello");
-    expect(data).toBe("hi");
-    expect(fetch.mock.calls[0][0]).toBe("https://google.com/hello");
-    expect(fetch.mock.calls[0][1].method).toEqual("get");
-    fch.baseUrl = null;
-  });
-
-  it("can use the `fetch.get()` shorthand", async () => {
-    fetch.once("my-data");
-    const data = await fch.get("/");
-    expect(data).toBe("my-data");
-    expect(fetch.mock.calls[0][1].method).toEqual("get");
-  });
-
-  it("can use the `fetch.patch()` shorthand", async () => {
-    fetch.once("my-data");
-    expect(await fch.patch("/")).toBe("my-data");
-    expect(fetch.mock.calls[0][1].method).toEqual("patch");
-  });
-
-  it("can use the `fetch.put()` shorthand", async () => {
-    fetch.once("my-data");
-    expect(await fch.put("/")).toBe("my-data");
-    expect(fetch.mock.calls[0][1].method).toEqual("put");
-  });
-
-  it("can use the `fetch.post()` shorthand", async () => {
-    fetch.once("my-data");
-    expect(await fch.post("/")).toBe("my-data");
-    expect(fetch.mock.calls[0][1].method).toEqual("post");
-  });
-
-  it("can use the `fetch.del()` shorthand", async () => {
-    fetch.once("my-data");
-    expect(await fch.del("/")).toBe("my-data");
-    expect(fetch.mock.calls[0][1].method).toEqual("delete");
-  });
-
-  it("ignores invalid options", async () => {
-    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
-    const res = await fch("https://google.com/", 10);
-
-    expect(res).toEqual({ secret: "12345" });
-    expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual("https://google.com/");
-  });
-
-  it("will not overwrite if it is FormData", async () => {
-    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
-    const res = await fch("/", { method: "post", body: new FormData() });
-
-    expect(res).toEqual({ secret: "12345" });
-    expect(fetch.mock.calls.length).toEqual(1);
-    const [url, opts] = fetch.mock.calls[0];
-    expect(opts).toMatchObject({ body: expect.any(FormData) });
-  });
-
-  it("will not overwrite if content-type is set", async () => {
-    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
-    const res = await fch("/", {
-      method: "POST",
-      body: { a: "b" },
-      headers: { "Content-Type": "xxx" },
-    });
-
-    expect(res).toEqual({ secret: "12345" });
-    expect(fetch.mock.calls.length).toEqual(1);
-    const [url, opts] = fetch.mock.calls[0];
-    expect(url).toEqual("/");
-    expect(opts).toMatchObject({
-      method: "post",
-      body: { a: "b" },
-      headers: { "content-type": "xxx" },
-    });
-  });
-
-  it("will send JSON", async () => {
-    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
-    const res = await fch("/", { method: "POST", body: { a: "b" } });
-
-    expect(res).toEqual({ secret: "12345" });
-    expect(fetch.mock.calls.length).toEqual(1);
-    const [url, opts] = fetch.mock.calls[0];
-    expect(url).toEqual("/");
-    expect(opts).toMatchObject({
-      method: "post",
-      body: '{"a":"b"}',
-      headers: { "content-type": "application/json; charset=utf-8" },
-    });
-  });
-
-  it("can run in parallel", async () => {
-    fetch.once("a").once("b");
-    const res = await Promise.all([fch("/a"), fch("/b")]);
-
-    expect(res).toEqual(["a", "b"]);
-    expect(fetch.mock.calls.length).toEqual(2);
-  });
-
-  it("can set `accepts` insensitively", async () => {
-    fetch.once(JSON.stringify({ secret: "12345" }), jsonHeaders);
-    const res = await fch("/", { headers: { Accepts: "text/xml" } });
-
-    expect(fetch.mock.calls[0][1].headers).toEqual({ accepts: "text/xml" });
-  });
-
-  it("can accept network rejections", async () => {
-    fetch.mockResponseOnce(JSON.stringify("unauthorized"), {
-      status: 401,
-      ok: false,
-    });
-    await expect(fch("/")).rejects.toMatchObject({
-      message: "Unauthorized",
-    });
-  });
-
-  it("throws with the wrong 'output' option", async () => {
-    fetch.once("hello");
-    await expect(fch("/", { output: "abc" })).rejects.toMatchObject({
-      message: `options.output needs to be either "body" (default) or "response", not "abc"`,
-    });
-  });
-
-  it("can accept rejections", async () => {
-    fetch.mockRejectOnce(new Error("fake error message"));
-    await expect(fch("/error")).rejects.toMatchObject({
-      message: "fake error message",
-    });
-  });
-});
-
-describe("interceptors", () => {
-  beforeEach(() => {
-    fetch.resetMocks();
-  });
-  afterEach(() => {
-    fetch.resetMocks();
-    delete fch.before;
-    delete fch.after;
-  });
-
-  it("can create a before interceptor", async () => {
-    fetch.once("hello");
-    const data = await fch("/", {
-      before: (req) => {
-        req.url = "/hello";
-        req.method = "put";
-        return req;
-      },
-    });
-
-    expect(data).toEqual("hello");
-    expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual("/hello");
-    expect(fetch.mock.calls[0][1].method).toEqual("put");
-    expect(fetch.mock.calls[0][1].headers).toEqual({});
-  });
-
-  it("can create a global before interceptor", async () => {
-    fetch.once("hello");
-    fch.before = (req) => {
-      req.url = "/hello";
-      req.method = "put";
-      return req;
-    };
-    const data = await fch("/");
-
-    expect(data).toEqual("hello");
-    expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual("/hello");
-    expect(fetch.mock.calls[0][1].method).toEqual("put");
-    expect(fetch.mock.calls[0][1].headers).toEqual({});
-
-    delete fch.before;
-  });
-
-  it("can create an after interceptor", async () => {
-    fetch.once("hello", { status: 201, headers: { hello: "world" } });
-    const res = await fch("/", {
-      output: "response",
-      after: (res) => {
-        res.body = "bye";
-        res.status = 200;
-        res.headers.hello = "world";
-        return res;
-      },
-    });
-
-    expect(res.body).toEqual("bye");
-    expect(res.status).toEqual(200);
-    expect(res.statusText).toEqual("Created");
-    expect(res.headers.hello).toEqual("world");
-    expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual("/");
-    expect(fetch.mock.calls[0][1].method).toEqual("get");
-    expect(fetch.mock.calls[0][1].headers).toEqual({});
-  });
-
-  it("can create a global after interceptor", async () => {
-    fetch.once("hello", { status: 201, headers: { hello: "world" } });
-    fch.after = (res) => {
-      res.body = "bye";
-      res.status = 200;
-      res.headers.hello = "world";
-      return res;
-    };
-    const res = await fch("/", { output: "response" });
-
-    expect(res.body).toEqual("bye");
-    expect(res.status).toEqual(200);
-    expect(res.statusText).toEqual("Created");
-    expect(res.headers.hello).toEqual("world");
-    expect(fetch.mock.calls.length).toEqual(1);
-    expect(fetch.mock.calls[0][0]).toEqual("/");
-    expect(fetch.mock.calls[0][1].method).toEqual("get");
-    expect(fetch.mock.calls[0][1].headers).toEqual({});
-  });
-});
-
-describe("dedupe network calls", () => {
-  beforeEach(() => {
-    fetch.resetMocks();
-  });
-
-  it("dedupes ongoing/parallel calls", async () => {
-    fetch.once("a").once("b");
-    const res = await Promise.all([fch("/a"), fch("/a")]);
-
-    expect(res).toEqual(["a", "a"]);
-    expect(fetch.mock.calls.length).toEqual(1);
-  });
-
-  it("dedupes named calls", async () => {
-    fetch.once("a").once("b");
-    const res = await Promise.all([fch.get("/a"), fch.get("/a")]);
-
-    expect(res).toEqual(["a", "a"]);
-    expect(fetch.mock.calls.length).toEqual(1);
-  });
-
-  it("can opt out locally", async () => {
-    fetch.once("a").once("b");
-    const res = await Promise.all([fch("/a"), fch("/a", { dedupe: false })]);
-
-    expect(res).toEqual(["a", "b"]);
-    expect(fetch.mock.calls.length).toEqual(2);
-  });
-
-  it("cannot reuse an opted out call", async () => {
-    fetch.once("a").once("b");
-    const res = await Promise.all([fch("/a", { dedupe: false }), fch("/a")]);
-
-    expect(res).toEqual(["a", "b"]);
-    expect(fetch.mock.calls.length).toEqual(2);
-  });
-
-  it("will reuse the last opt-in call", async () => {
-    fetch.once("a").once("b").once("c");
-    const res = await Promise.all([
-      fch("/a"),
-      fch("/a", { dedupe: false }),
-      fch("/a"),
-    ]);
-
-    expect(res).toEqual(["a", "b", "a"]);
-    expect(fetch.mock.calls.length).toEqual(2);
-  });
-
-  it("can opt out globally", async () => {
-    fetch.once("a").once("b").once("c");
-    fch.dedupe = false;
-    const res = await Promise.all([fch("/a"), fch("/a"), fch("/a")]);
-
-    expect(res).toEqual(["a", "b", "c"]);
-    expect(fetch.mock.calls.length).toEqual(3);
-    fch.dedupe = true;
-  });
-
-  it("does NOT dedupe/cache serial requests", async () => {
-    fetch.once("a").once("b");
-    const resa = await fch("/a");
-    const resb = await fch("/a");
-
-    expect([resa, resb]).toEqual(["a", "b"]);
-    expect(fetch.mock.calls.length).toEqual(2);
-  });
-
-  it("does NOT dedupe/cache other request types", async () => {
-    fetch.once("a").once("b");
-    const res = await Promise.all([fch.get("/a"), fch.post("/a")]);
-
-    expect(res).toEqual(["a", "b"]);
-    expect(fetch.mock.calls.length).toEqual(2);
-  });
-
-  it("NOT deduping are invisible for other request", async () => {
-    fetch.once("a").once("b").once("c");
-    const res = await Promise.all([
-      fch.get("/a"),
-      fch.post("/a"),
-      fch.get("/a"),
-    ]);
-
-    expect(res).toEqual(["a", "b", "a"]);
-    expect(fetch.mock.calls.length).toEqual(2);
-  });
-});