getta 0.4.7 → 1.0.1

package/src/main.test.ts

@@ -1,362 +1,277 @@
-import { StringObject } from "@repodog/types";
-import fetchMock, { MockRequest } from "fetch-mock";
-import md5 from "md5";
-import { performance } from "perf_hooks";
-import { PRD_136_7317 } from "./__tests__/data";
+import { jest } from '@jest/globals';
+import { mockFetch } from 'fetch-mocked';
+import { performance } from 'node:perf_hooks';
+import { Md5 } from 'ts-md5';
+import { PRD_136_7317 } from './__testUtils__/data/index.ts';
 import {
   basePath,
+  buildTestEndpoint,
   defaultEtag,
+  defaultHeaders,
   defaultPath,
   defaultPathTemplateData,
   defaultPayload,
   getCache,
+  graphqlPath,
   idPathTemplateData,
-  mockRequest,
   pathTemplateDataWithoutID,
-  tearDownTest,
-} from "./__tests__/helpers";
-import {
-  COOKIE_HEADER,
-  DELETE_METHOD,
-  GET_METHOD,
-  IF_NONE_MATCH_HEADER,
-  LOCATION_HEADER,
-  MAX_REDIRECTS_EXCEEDED_ERROR,
-  MAX_RETRIES_EXCEEDED_ERROR,
-  POST_METHOD,
-  PUT_METHOD,
-  RESOURCE_NOT_FOUND_ERROR,
-} from "./constants";
-import delay from "./helpers/delay";
-import { Getta, createRestClient } from "./main";
-import { ResponseDataWithErrors, ShortcutProperties } from "./types";
-
-describe("Getta", () => {
-  describe("constructor", () => {
-    it("SHOULD return an instance of the Getta class", () => {
+} from './__testUtils__/helpers/index.ts';
+import * as consts from './constants.ts';
+import { delay } from './helpers/delay/index.ts';
+import { Getta, createRestClient } from './main.ts';
+import { type FetchResponse, type ResponseDataWithErrors, type ShortcutProperties } from './types.ts';
+
+const mockedFetch = mockFetch(jest.fn);
+
+describe('Getta', () => {
+  afterEach(() => {
+    mockedFetch.mockReset();
+  });
+
+  describe('constructor', () => {
+    it('should return an instance of the Getta class', () => {
       const restClient = createRestClient({ basePath, cache: getCache(), performance });
       expect(restClient).toBeInstanceOf(Getta);
     });
   });
 
-  describe("get method", () => {
-    let restClient: Getta & ShortcutProperties<"getProduct">;
+  describe('get method', () => {
+    let restClient: Getta & ShortcutProperties<'getProduct'>;
     let response: ResponseDataWithErrors | ResponseDataWithErrors[];
 
-    beforeAll(() => {
-      restClient = createRestClient<"getProduct">(
+    beforeEach(() => {
+      restClient = createRestClient<'getProduct'>(
         { basePath, cache: getCache(), performance },
         {
           getProduct: [
             defaultPath,
             {
-              method: GET_METHOD,
+              method: consts.GET_METHOD,
               pathTemplateData: pathTemplateDataWithoutID,
             },
           ],
-        },
+        }
       );
     });
 
-    describe("WHEN a resource is requested", () => {
-      beforeAll(async () => {
-        mockRequest(
-          defaultPath,
-          PRD_136_7317.body,
-          { pathTemplateData: defaultPathTemplateData },
-          ({ endpoint, ...rest }) => {
-            fetchMock.get(endpoint, rest);
-          },
-        );
+    afterEach(async () => {
+      await restClient.cache?.clear();
+    });
 
-        response = await restClient.get(defaultPath, { pathTemplateData: defaultPathTemplateData });
-      });
+    describe('when a resource is requested', () => {
+      beforeEach(async () => {
+        mockedFetch.mockGetOnce(buildTestEndpoint(defaultPath), {
+          body: PRD_136_7317.body,
+          headers: defaultHeaders,
+        });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
+        response = await restClient.get(defaultPath, { pathTemplateData: defaultPathTemplateData });
       });
 
-      it("SHOULD have made one request", () => {
-        expect(fetchMock.calls().length).toBe(1);
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
       });
 
-      it("SHOULD return the correct response", () => {
+      it('should return the correct response', () => {
         expect(response).toEqual(
           expect.objectContaining({
             data: PRD_136_7317.body,
-          }),
+          })
         );
       });
     });
 
-    describe("WHEN a resource is requested with a shortcut", () => {
-      beforeAll(async () => {
-        mockRequest(
-          defaultPath,
-          PRD_136_7317.body,
-          { pathTemplateData: defaultPathTemplateData },
-          ({ endpoint, ...rest }) => {
-            fetchMock.get(endpoint, rest);
-          },
-        );
+    describe('when a resource is requested with a shortcut', () => {
+      beforeEach(async () => {
+        mockedFetch.mockGetOnce(buildTestEndpoint(defaultPath), {
+          body: PRD_136_7317.body,
+          headers: defaultHeaders,
+        });
 
         response = await restClient.getProduct({ pathTemplateData: idPathTemplateData });
       });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
-      });
-
-      it("SHOULD have made one request", () => {
-        expect(fetchMock.calls().length).toBe(1);
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
       });
 
-      it("SHOULD return the correct response", () => {
+      it('should return the correct response', () => {
         expect(response).toEqual(
           expect.objectContaining({
             data: PRD_136_7317.body,
-          }),
+          })
         );
       });
     });
 
-    describe("WHEN a resource is in the cache", () => {
-      describe("WHEN the cache entry is valid", () => {
-        beforeAll(async () => {
-          mockRequest(
-            defaultPath,
-            PRD_136_7317.body,
-            { pathTemplateData: defaultPathTemplateData },
-            ({ endpoint, ...rest }) => {
-              fetchMock.get(endpoint, rest);
-            },
-          );
+    describe('when a resource is in the cache', () => {
+      describe('when the cache entry is valid', () => {
+        beforeEach(async () => {
+          mockedFetch.mockGetOnce(buildTestEndpoint(defaultPath), {
+            body: PRD_136_7317.body,
+            headers: defaultHeaders,
+          });
 
           await restClient.getProduct({ pathTemplateData: idPathTemplateData });
-          fetchMock.restore();
+          mockedFetch.mockClear();
           response = await restClient.getProduct({ pathTemplateData: idPathTemplateData });
         });
 
-        afterAll(async () => {
-          await tearDownTest({ fetchMock, restClient });
-        });
-
-        it("SHOULD not have made a request", () => {
-          expect(fetchMock.calls().length).toBe(0);
+        it('should not have made a request', () => {
+          expect(mockedFetch).not.toHaveBeenCalled();
         });
 
-        it("SHOULD return the correct response", () => {
+        it('should return the correct response', () => {
           expect(response).toEqual(
             expect.objectContaining({
               data: PRD_136_7317.body,
-            }),
+            })
           );
         });
       });
 
-      describe("WHEN the cache entry is invalid", () => {
-        function matcher(_url: string, { headers }: MockRequest) {
-          return !!headers && (headers as StringObject)[IF_NONE_MATCH_HEADER] === defaultEtag;
-        }
-
-        async function invalidCacheEntryTestSetup() {
-          mockRequest(
-            defaultPath,
-            PRD_136_7317.body,
-            { headers: { "cache-control": "public, max-age=1" }, pathTemplateData: defaultPathTemplateData },
-            ({ endpoint, ...rest }) => {
-              fetchMock.get(endpoint, rest);
-            },
-          );
+      describe('when the cache entry is invalid', () => {
+        beforeEach(async () => {
+          mockedFetch.mockGetOnce(buildTestEndpoint(defaultPath), {
+            body: PRD_136_7317.body,
+            headers: { ...defaultHeaders, 'cache-control': 'public, max-age=1' },
+          });
 
           await restClient.getProduct({ pathTemplateData: idPathTemplateData });
           await delay(1000);
+          mockedFetch.mockClear();
+        });
 
-          fetchMock.restore();
-        }
-
-        describe("WHEN the response returns not modified status code", () => {
-          beforeAll(async () => {
-            await invalidCacheEntryTestSetup();
-
-            mockRequest(
-              defaultPath,
-              PRD_136_7317.body,
-              { pathTemplateData: defaultPathTemplateData },
-              ({ headers }) => {
-                fetchMock.mock(matcher, { headers, status: 304 });
-              },
+        describe('when the response returns not modified status code', () => {
+          beforeEach(async () => {
+            mockedFetch.mockGetOnce(
+              { headers: { [consts.IF_NONE_MATCH_HEADER]: defaultEtag }, url: buildTestEndpoint(defaultPath) },
+              { headers: defaultHeaders, status: 304 }
             );
 
             response = await restClient.getProduct({ pathTemplateData: idPathTemplateData });
           });
 
-          afterAll(async () => {
-            await tearDownTest({ fetchMock, restClient });
+          it('should have made one request', () => {
+            expect(mockedFetch).toHaveBeenCalledTimes(1);
           });
 
-          it("SHOULD have made one request", () => {
-            expect(fetchMock.calls().length).toBe(1);
-          });
-
-          it("SHOULD return the correct response", () => {
+          it('should return the correct response', () => {
             expect(response).toEqual(
               expect.objectContaining({
                 data: PRD_136_7317.body,
-              }),
+              })
             );
           });
         });
 
-        describe("WHEN the response returns the resource", () => {
-          beforeAll(async () => {
-            await invalidCacheEntryTestSetup();
-
-            mockRequest(
-              defaultPath,
-              PRD_136_7317.body,
-              { pathTemplateData: defaultPathTemplateData },
-              ({ body, headers }) => {
-                fetchMock.mock(matcher, { body, headers, status: 200 });
-              },
+        describe('when the response returns the resource', () => {
+          beforeEach(async () => {
+            mockedFetch.mockGetOnce(
+              { headers: { [consts.IF_NONE_MATCH_HEADER]: defaultEtag }, url: buildTestEndpoint(defaultPath) },
+              { body: PRD_136_7317.body, headers: defaultHeaders }
             );
 
             response = await restClient.getProduct({ pathTemplateData: idPathTemplateData });
           });
 
-          afterAll(async () => {
-            await tearDownTest({ fetchMock, restClient });
-          });
-
-          it("SHOULD have made one request", () => {
-            expect(fetchMock.calls().length).toBe(1);
+          it('should have made one request', () => {
+            expect(mockedFetch).toHaveBeenCalledTimes(1);
           });
 
-          it("SHOULD return the correct response", () => {
+          it('should return the correct response', () => {
             expect(response).toEqual(
               expect.objectContaining({
                 data: PRD_136_7317.body,
-              }),
+              })
             );
           });
         });
 
-        describe("WHEN the response returns a 404", () => {
-          beforeAll(async () => {
-            await invalidCacheEntryTestSetup();
-
-            mockRequest(defaultPath, {}, { pathTemplateData: defaultPathTemplateData }, ({ body, headers }) => {
-              fetchMock.mock(matcher, { body, headers, status: 404 });
-            });
+        describe('when the response returns a 404', () => {
+          beforeEach(async () => {
+            mockedFetch.mockGetOnce(
+              { headers: { [consts.IF_NONE_MATCH_HEADER]: defaultEtag }, url: buildTestEndpoint(defaultPath) },
+              { status: 404 }
+            );
 
             response = await restClient.getProduct({ pathTemplateData: idPathTemplateData });
           });
 
-          afterAll(async () => {
-            await tearDownTest({ fetchMock, restClient });
-          });
-
-          it("SHOULD have made one request", () => {
-            expect(fetchMock.calls().length).toBe(1);
+          it('should have made one request', () => {
+            expect(mockedFetch).toHaveBeenCalledTimes(1);
           });
 
-          it("SHOULD return the correct response", () => {
+          it('should return the correct response', () => {
             expect(response).toEqual(
               expect.objectContaining({
-                data: {},
-                errors: [new Error(RESOURCE_NOT_FOUND_ERROR)],
-              }),
+                errors: [new Error(consts.RESOURCE_NOT_FOUND_ERROR)],
+              })
             );
           });
         });
       });
     });
 
-    describe("WHEN a request is redirected more than five times", () => {
-      const REDIRECT_COOKIE_FLAG = "status=redirect";
-
-      function matcher(_url: string, { headers }: MockRequest) {
-        return !!headers && (headers as StringObject)[COOKIE_HEADER] === REDIRECT_COOKIE_FLAG;
-      }
-
-      beforeAll(async () => {
-        mockRequest(
-          defaultPath,
-          {},
-          { headers: { [LOCATION_HEADER]: basePath }, pathTemplateData: defaultPathTemplateData },
-          ({ body, headers }) => {
-            fetchMock.mock(matcher, { body, headers, status: 301 });
-          },
+    describe('when a request is redirected more than five times', () => {
+      const REDIRECT_COOKIE_FLAG = 'status=redirect';
+
+      beforeEach(async () => {
+        mockedFetch.mockGet(
+          { headers: { [consts.COOKIE_HEADER]: REDIRECT_COOKIE_FLAG }, url: '*' },
+          { headers: { ...defaultHeaders, [consts.LOCATION_HEADER]: basePath }, status: 301 }
         );
 
         response = await restClient.getProduct({
-          headers: { [COOKIE_HEADER]: REDIRECT_COOKIE_FLAG },
+          headers: { [consts.COOKIE_HEADER]: REDIRECT_COOKIE_FLAG },
           pathTemplateData: idPathTemplateData,
         });
       });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
-      });
-
-      it("SHOULD have made five requests", () => {
-        expect(fetchMock.calls().length).toBe(5);
+      it('should have made five requests', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(5);
       });
 
-      it("SHOULD return the correct response", () => {
+      it('should return the correct response', () => {
         expect(response).toEqual(
           expect.objectContaining({
-            errors: [new Error(`${MAX_REDIRECTS_EXCEEDED_ERROR} 5.`)],
-          }),
+            errors: [new Error(`${consts.MAX_REDIRECTS_EXCEEDED_ERROR} 5.`)],
+          })
         );
       });
     });
 
-    describe("WHEN a request is retried more than three times", () => {
-      const RETRY_COOKIE_FLAG = "status=retry";
+    describe('when a request is retried more than three times', () => {
+      const RETRY_COOKIE_FLAG = 'status=retry';
 
-      function matcher(_url: string, { headers }: MockRequest) {
-        return !!headers && (headers as StringObject)[COOKIE_HEADER] === RETRY_COOKIE_FLAG;
-      }
-
-      beforeAll(async () => {
-        mockRequest(defaultPath, {}, { pathTemplateData: defaultPathTemplateData }, ({ body, headers }) => {
-          fetchMock.mock(matcher, { body, headers, status: 500 });
-        });
+      beforeEach(async () => {
+        mockedFetch.mockGet(
+          { headers: { [consts.COOKIE_HEADER]: RETRY_COOKIE_FLAG }, url: buildTestEndpoint(defaultPath) },
+          { body: PRD_136_7317.body, status: 500 }
+        );
 
         response = await restClient.getProduct({
-          headers: { [COOKIE_HEADER]: RETRY_COOKIE_FLAG },
+          headers: { [consts.COOKIE_HEADER]: RETRY_COOKIE_FLAG },
           pathTemplateData: idPathTemplateData,
         });
       });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
-      });
-
-      it("SHOULD have made three requests", () => {
-        expect(fetchMock.calls().length).toBe(3);
+      it('should have made three requests', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(3);
       });
 
-      it("SHOULD return the correct response", () => {
+      it('should return the correct response', () => {
         expect(response).toEqual(
           expect.objectContaining({
-            errors: [new Error(`${MAX_RETRIES_EXCEEDED_ERROR} 3.`)],
-          }),
+            errors: [new Error(`${consts.MAX_RETRIES_EXCEEDED_ERROR} 3.`)],
+          })
         );
       });
     });
 
-    describe("WHEN the same resource is requested in quick succession", () => {
-      beforeAll(async () => {
-        mockRequest(
-          defaultPath,
-          PRD_136_7317.body,
-          { pathTemplateData: defaultPathTemplateData },
-          ({ endpoint, ...rest }) => {
-            fetchMock.get(endpoint, rest);
-          },
-        );
+    describe('when the same resource is requested in quick succession', () => {
+      beforeEach(async () => {
+        mockedFetch.mockGet(buildTestEndpoint(defaultPath), { body: PRD_136_7317.body, headers: defaultHeaders });
 
         response = await Promise.all([
           restClient.get(defaultPath, { pathTemplateData: defaultPathTemplateData }),
@@ -364,336 +279,293 @@ describe("Getta", () => {
         ]);
       });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
-      });
-
-      it("SHOULD have made one request", () => {
-        expect(fetchMock.calls().length).toBe(1);
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
       });
 
-      it("SHOULD return the correct response", () => {
-        expect((response as ResponseDataWithErrors[])[0]).toEqual(
+      it('should return the correct response', () => {
+        expect(response as ResponseDataWithErrors[]).toEqual([
           expect.objectContaining({
             data: PRD_136_7317.body,
           }),
-        );
-
-        expect((response as ResponseDataWithErrors[])[1]).toEqual(
           expect.objectContaining({
             data: PRD_136_7317.body,
           }),
-        );
+        ]);
       });
     });
 
-    describe("WHEN a request times out", () => {
-      // TODO
+    describe('when a request times out', () => {
+      beforeEach(async () => {
+        mockedFetch.mockGet(buildTestEndpoint(defaultPath), { body: PRD_136_7317.body }, { delay: 200 });
+        // @ts-expect-error property is private
+        restClient._fetchTimeout = 100;
+
+        response = await restClient.getProduct({
+          pathTemplateData: idPathTemplateData,
+        });
+      });
+
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
+      });
+
+      it('should return the correct response', () => {
+        expect(response).toEqual(
+          expect.objectContaining({
+            errors: [new Error(`${consts.FETCH_TIMEOUT_ERROR} 100ms.`)],
+          })
+        );
+      });
     });
   });
 
-  describe("post method", () => {
-    let restClient: Getta & ShortcutProperties<"postProduct">;
-    let response: ResponseDataWithErrors | ResponseDataWithErrors[];
+  describe('post method', () => {
+    let restClient: Getta & ShortcutProperties<'postProduct'>;
+    let response: FetchResponse;
 
-    beforeAll(() => {
-      restClient = createRestClient<"postProduct">(
+    beforeEach(() => {
+      restClient = createRestClient<'postProduct'>(
         { basePath, cache: getCache(), performance },
         {
           postProduct: [
-            defaultPath,
+            graphqlPath,
             {
-              method: POST_METHOD,
-              pathTemplateData: pathTemplateDataWithoutID,
+              method: consts.POST_METHOD,
             },
           ],
-        },
+        }
       );
     });
 
-    describe("WHEN a resource is requested", () => {
-      beforeAll(async () => {
-        mockRequest(
-          defaultPath,
-          PRD_136_7317.body,
-          { pathTemplateData: defaultPathTemplateData },
-          ({ endpoint, ...rest }) => {
-            fetchMock.post(endpoint, rest);
-          },
+    afterEach(async () => {
+      await restClient.cache?.clear();
+    });
+
+    describe('when a resource is requested', () => {
+      beforeEach(async () => {
+        mockedFetch.mockPostOnce(
+          { body: { mock: true }, url: buildTestEndpoint(graphqlPath) },
+          { body: PRD_136_7317.body, headers: defaultHeaders }
         );
 
-        response = await restClient.post(defaultPath, {
-          body: defaultPayload,
-          pathTemplateData: defaultPathTemplateData,
+        response = await restClient.post(graphqlPath, {
+          body: JSON.stringify({ ...defaultPayload, mock: true }),
         });
       });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
       });
 
-      it("SHOULD have made one request", () => {
-        expect(fetchMock.calls().length).toBe(1);
-      });
-
-      it("SHOULD return the correct response", () => {
+      it('should return the correct response', () => {
         expect(response).toEqual(
           expect.objectContaining({
             data: PRD_136_7317.body,
-          }),
+          })
         );
       });
     });
 
-    describe("WHEN a resource is requested with a shortcut", () => {
-      beforeAll(async () => {
-        mockRequest(
-          defaultPath,
-          PRD_136_7317.body,
-          { pathTemplateData: defaultPathTemplateData },
-          ({ endpoint, ...rest }) => {
-            fetchMock.post(endpoint, rest);
-          },
+    describe('when a resource is requested with a shortcut', () => {
+      beforeEach(async () => {
+        mockedFetch.mockPostOnce(
+          { body: { mock: true }, url: buildTestEndpoint(graphqlPath) },
+          { body: PRD_136_7317.body, headers: defaultHeaders }
         );
 
-        response = await restClient.postProduct({ body: defaultPayload, pathTemplateData: idPathTemplateData });
-      });
-
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
+        response = await restClient.postProduct({ body: JSON.stringify({ ...defaultPayload, mock: true }) });
       });
 
-      it("SHOULD have made one request", () => {
-        expect(fetchMock.calls().length).toBe(1);
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
       });
 
-      it("SHOULD return the correct response", () => {
+      it('should return the correct response', () => {
         expect(response).toEqual(
           expect.objectContaining({
             data: PRD_136_7317.body,
-          }),
+          })
         );
       });
     });
   });
 
-  describe("delete method", () => {
-    let restClient: Getta & ShortcutProperties<"deleteProduct">;
-    let response: ResponseDataWithErrors | ResponseDataWithErrors[];
-    let requestHash: string;
+  describe('delete method', () => {
+    let restClient: Getta & ShortcutProperties<'deleteProduct'>;
+    let response: FetchResponse;
 
-    beforeAll(() => {
-      restClient = createRestClient<"deleteProduct">(
+    beforeEach(() => {
+      restClient = createRestClient<'deleteProduct'>(
         { basePath, cache: getCache(), performance },
         {
           deleteProduct: [
             defaultPath,
             {
-              method: DELETE_METHOD,
+              method: consts.DELETE_METHOD,
               pathTemplateData: pathTemplateDataWithoutID,
             },
           ],
-        },
+        }
       );
     });
 
-    describe("WHEN a resource is requested to be deleted", () => {
-      beforeAll(async () => {
-        mockRequest(
-          defaultPath,
-          PRD_136_7317.body,
-          { pathTemplateData: defaultPathTemplateData },
-          ({ endpoint, ...rest }) => {
-            requestHash = md5(endpoint);
-            fetchMock.get(endpoint, rest);
-          },
-        );
+    afterEach(async () => {
+      await restClient.cache?.clear();
+    });
 
-        response = await restClient.get(defaultPath, { pathTemplateData: defaultPathTemplateData });
-        fetchMock.restore();
+    describe('when a resource is requested to be deleted', () => {
+      beforeEach(async () => {
+        const url = buildTestEndpoint(defaultPath);
 
-        mockRequest(defaultPath, {}, { pathTemplateData: defaultPathTemplateData }, ({ endpoint, ...rest }) => {
-          fetchMock.delete(endpoint, rest);
+        mockedFetch.mockGetOnce(url, {
+          body: PRD_136_7317.body,
+          headers: defaultHeaders,
         });
 
+        mockedFetch.mockDeleteOnce(url);
+        await restClient.get(defaultPath, { pathTemplateData: defaultPathTemplateData });
+        mockedFetch.mockClear();
         response = await restClient.delete(defaultPath, { pathTemplateData: defaultPathTemplateData });
       });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
-      });
-
-      it("SHOULD have made one request", () => {
-        expect(fetchMock.calls().length).toBe(1);
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
       });
 
-      it("SHOULD return the correct response", () => {
-        expect(response).toEqual(
-          expect.objectContaining({
-            data: {},
-          }),
-        );
+      it('should return the correct response', () => {
+        expect(response.status).toBe(200);
       });
 
-      it("SHOULD delete any matching cache entry", async () => {
-        expect(await restClient?.cache?.has(requestHash)).toBe(false);
+      it('should delete any matching cache entry', async () => {
+        await expect(restClient.cache?.has(Md5.hashStr(buildTestEndpoint(defaultPath)))).resolves.toBe(false);
       });
     });
 
-    describe("WHEN a resource is requested to be deleted with a shortcut", () => {
-      beforeAll(async () => {
-        mockRequest(
-          defaultPath,
-          PRD_136_7317.body,
-          { pathTemplateData: defaultPathTemplateData },
-          ({ endpoint, ...rest }) => {
-            requestHash = md5(endpoint);
-            fetchMock.get(endpoint, rest);
-          },
-        );
-
-        response = await restClient.get(defaultPath, { pathTemplateData: defaultPathTemplateData });
-        fetchMock.restore();
+    describe('when a resource is requested to be deleted with a shortcut', () => {
+      beforeEach(async () => {
+        const url = buildTestEndpoint(defaultPath);
 
-        mockRequest(defaultPath, {}, { pathTemplateData: defaultPathTemplateData }, ({ endpoint, ...rest }) => {
-          fetchMock.delete(endpoint, rest);
+        mockedFetch.mockGetOnce(url, {
+          body: PRD_136_7317.body,
+          headers: defaultHeaders,
         });
 
+        mockedFetch.mockDeleteOnce(url);
+        await restClient.get(defaultPath, { pathTemplateData: defaultPathTemplateData });
+        mockedFetch.mockClear();
         response = await restClient.deleteProduct({ pathTemplateData: idPathTemplateData });
       });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
       });
 
-      it("SHOULD have made one request", () => {
-        expect(fetchMock.calls().length).toBe(1);
+      it('should return the correct response', () => {
+        expect(response.status).toBe(200);
       });
 
-      it("SHOULD return the correct response", () => {
-        expect(response).toEqual(
-          expect.objectContaining({
-            data: {},
-          }),
-        );
-      });
-
-      it("SHOULD delete any matching cache entry", async () => {
-        expect(await restClient?.cache?.has(requestHash)).toBe(false);
+      it('should delete any matching cache entry', async () => {
+        await expect(restClient.cache?.has(Md5.hashStr(buildTestEndpoint(defaultPath)))).resolves.toBe(false);
       });
     });
   });
 
-  describe("put method", () => {
-    let restClient: Getta & ShortcutProperties<"putProduct">;
-    let response: ResponseDataWithErrors | ResponseDataWithErrors[];
+  describe('put method', () => {
+    let restClient: Getta & ShortcutProperties<'putProduct'>;
+    let response: FetchResponse;
 
-    beforeAll(() => {
-      restClient = createRestClient<"putProduct">(
+    beforeEach(() => {
+      restClient = createRestClient<'putProduct'>(
         { basePath, cache: getCache(), performance },
         {
           putProduct: [
             defaultPath,
             {
-              method: PUT_METHOD,
+              method: consts.PUT_METHOD,
               pathTemplateData: pathTemplateDataWithoutID,
             },
           ],
-        },
+        }
       );
     });
 
-    describe("WHEN a resource is send", () => {
-      beforeAll(async () => {
-        mockRequest(defaultPath, {}, { pathTemplateData: defaultPathTemplateData }, ({ endpoint, ...rest }) => {
-          fetchMock.put(endpoint, rest);
-        });
+    afterEach(async () => {
+      await restClient.cache?.clear();
+    });
+
+    describe('when a resource is send', () => {
+      beforeEach(async () => {
+        mockedFetch.mockPutOnce({ body: { mock: true }, url: buildTestEndpoint(defaultPath) }, { status: 201 });
 
         response = await restClient.put(defaultPath, {
-          body: defaultPayload,
+          body: JSON.stringify({ ...defaultPayload, mock: true }),
           pathTemplateData: defaultPathTemplateData,
         });
       });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
-      });
-
-      it("SHOULD have made one request", () => {
-        expect(fetchMock.calls().length).toBe(1);
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
       });
 
-      it("SHOULD return the correct response", () => {
-        expect(response).toEqual(
-          expect.objectContaining({
-            data: {},
-          }),
-        );
+      it('should return the correct response', () => {
+        expect(response.status).toBe(201);
       });
     });
 
-    describe("WHEN a resource is sent with a shortcut", () => {
-      beforeAll(async () => {
-        mockRequest(defaultPath, {}, { pathTemplateData: defaultPathTemplateData }, ({ endpoint, ...rest }) => {
-          fetchMock.put(endpoint, rest);
-        });
-
-        response = await restClient.putProduct({ body: defaultPayload, pathTemplateData: idPathTemplateData });
-      });
+    describe('when a resource is sent with a shortcut', () => {
+      beforeEach(async () => {
+        mockedFetch.mockPutOnce({ body: { mock: true }, url: buildTestEndpoint(defaultPath) }, { status: 201 });
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
+        response = await restClient.putProduct({
+          body: JSON.stringify({ ...defaultPayload, mock: true }),
+          pathTemplateData: idPathTemplateData,
+        });
       });
 
-      it("SHOULD have made one request", () => {
-        expect(fetchMock.calls().length).toBe(1);
+      it('should have made one request', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
       });
 
-      it("SHOULD return the correct response", () => {
-        expect(response).toEqual(
-          expect.objectContaining({
-            data: {},
-          }),
-        );
+      it('should return the correct response', () => {
+        expect(response.status).toBe(201);
       });
     });
   });
 
-  describe("rate limiting", () => {
+  describe('rate limiting', () => {
     let restClient: Getta;
 
-    beforeAll(() => {
-      restClient = createRestClient({ basePath, performance });
+    beforeEach(() => {
+      restClient = createRestClient({ basePath, performance, rateLimit: true });
     });
 
-    describe("WHEN the number of requests per second exceeds rateLimitPerSecond", () => {
-      beforeAll(async () => {
-        const requestKeys = [...Array(55).keys()];
-
-        requestKeys.forEach(key => {
-          mockRequest(`product/${key}`, {}, {}, ({ endpoint, ...rest }) => {
-            fetchMock.get(endpoint, rest);
-          });
-        });
+    afterEach(async () => {
+      await restClient.cache?.clear();
+      // @ts-expect-error property is private
+      clearTimeout(restClient._rateLimitTimer);
+    });
 
-        // @ts-ignore
-        restClient._addRequestToRateLimitedQueue = jest
-          .fn()
-          .mockResolvedValue({ data: {}, headers: new Headers(), status: 200 });
+    describe('when the number of requests per second exceeds rateLimitPerSecond', () => {
+      beforeEach(async () => {
+        const requestKeys = [...Array.from({ length: 55 }).keys()];
 
-        await Promise.all(requestKeys.map(key => restClient.get(`product/${key}`)));
-      });
+        for (const key of requestKeys) {
+          mockedFetch.mockGetOnce(buildTestEndpoint(`product/${key}`));
+        }
 
-      afterAll(async () => {
-        await tearDownTest({ fetchMock, restClient });
+        // @ts-expect-error property is private
+        restClient._addRequestToRateLimitedQueue = jest.fn().mockResolvedValue({ status: 200 });
+        await Promise.all(requestKeys.map(key => restClient.get(`product/${key}`, { headers: defaultHeaders })));
       });
 
-      it("SHOULD call fetch one less than the rate limit", () => {
-        expect(fetchMock.calls().length).toBe(49);
+      it('should call fetch one less than the rate limit', () => {
+        expect(mockedFetch).toHaveBeenCalledTimes(49);
       });
 
-      it("SHOULD add the excess requests to rateLimitedRequestQueue", async () => {
-        // @ts-ignore
+      it('should add the excess requests to rateLimitedRequestQueue', () => {
+        // @ts-expect-error property is private
+        // eslint-disable-next-line @typescript-eslint/unbound-method
         expect(restClient._addRequestToRateLimitedQueue).toHaveBeenCalledTimes(6);
       });
     });