Cover axios adapters and utils by unit tests

Author: Daniil Yankouski

configs/jest/config.ts

@@ -12,7 +12,7 @@ type JestConfig = Partial<
 process.env.TZ = 'UTC'
 
 const config: JestConfig = {
-  collectCoverageFrom: ['<rootDir>/src/{domain,data,presentation,core}/**/*.ts'],
+  collectCoverageFrom: ['<rootDir>/src/{domain,data,core}/**/*.ts'],
   coverageDirectory: 'coverage',
   coveragePathIgnorePatterns: [
     '<rootDir>/node_modules',
@@ -22,6 +22,7 @@ const config: JestConfig = {
     '<rootDir>/src/presentation/web/app.component.tsx',
     '.d.ts',
     '.mock.ts',
+    'index.ts',
   ],
   coverageThreshold: {
     global: {
@@ -35,12 +36,8 @@ const config: JestConfig = {
     'ts-jest': {
       tsconfig: '<rootDir>/tsconfig.json',
     },
-    window: {
-      document: {
-        cookie: ''
-      }
-    },
     ...BuildDefine,
+    UI_VERSION: '0.0.123'
   },
   moduleDirectories: ['<rootDir>/node_modules', '<rootDir>/node_modules/@types', '<rootDir>/src'],
   moduleNameMapper: {

configs/jest/setup.ts

@@ -1,6 +1,8 @@
 import 'reflect-metadata';
-// re-export everything
-export * from '@testing-library/react';
-
+// @ts-ignore
+global.document = {}
+// @ts-ignore
+global.window = {document: {cookie: ''}}
 // override another methods here
 // render
+export * from '@testing-library/react';

src/core/adapters/axios/__tests__/axios-abort.adapter.test.ts

@@ -0,0 +1,62 @@
+import axios, { AxiosRequestConfig } from 'axios';
+import { AbortPromise } from 'core/http';
+import { AxiosAbortAdapter } from '../axios-abort.adapter';
+
+jest.mock('axios', () => {
+  const mockAxios = {
+    defaults: {
+      adapter: jest.fn(config => {
+        if (!config) {
+          throw new Error('mockAdapterError');
+        }
+
+        return Promise.resolve();
+      }),
+    },
+  };
+
+  return {
+    create: jest.fn(() => mockAxios),
+    ...mockAxios,
+  };
+});
+
+describe('AxiosAbortAdapters', () => {
+  let axiosAbortAdapter: AxiosAbortAdapter;
+
+  beforeEach(() => {
+    axiosAbortAdapter = new AxiosAbortAdapter();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should execute adapter with default axios adapter', async () => {
+    const spyAbortController = jest.spyOn(AbortController.prototype, 'abort');
+    const config: AxiosRequestConfig = {
+      data: { key: 'value' },
+      method: 'GET',
+      params: { pages: 2 },
+      url: 'example.com',
+    };
+    const response: AbortPromise<any> = axiosAbortAdapter.execute(config);
+    expect(response?.abort).toBeInstanceOf(Function);
+    response.abort();
+    expect(spyAbortController).toHaveBeenCalled();
+    await response;
+    expect(axios.defaults.adapter).toBeCalledWith(config);
+    spyAbortController.mockReset();
+    spyAbortController.mockRestore();
+  });
+
+  it('should execute adapter and catch an error', async () => {
+    try {
+      const config: AxiosRequestConfig = null;
+      await axiosAbortAdapter.execute(config);
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      expect(error.message).toBe('mockAdapterError');
+    }
+  });
+});

src/core/adapters/axios/__tests__/axios-memo.adapter.test.ts

@@ -0,0 +1,97 @@
+import { AxiosPromise, AxiosRequestConfig } from 'axios';
+import { AxiosAbortAdapter } from '../axios-abort.adapter';
+import { AxiosMemoAdapter } from '../axios-memo.adapter';
+
+describe('AxiosMemoAdapter', () => {
+  let axiosAbortAdapter: AxiosAbortAdapter;
+  let axiosMemoAdapter: AxiosMemoAdapter;
+
+  let spyAxiosAbortExecute;
+
+  beforeEach(() => {
+    axiosAbortAdapter = new AxiosAbortAdapter();
+    axiosMemoAdapter = new AxiosMemoAdapter(axiosAbortAdapter);
+    spyAxiosAbortExecute = jest.spyOn(axiosAbortAdapter, 'execute').mockImplementation(
+      (): AxiosPromise<string> =>
+        Promise.resolve({
+          config: {},
+          data: 'response',
+          headers: {},
+          status: 200,
+          statusText: 'OK',
+        }),
+    );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    spyAxiosAbortExecute.mockReset();
+    spyAxiosAbortExecute.mockRestore();
+  });
+
+  it('shouldn`t put request into cache', async () => {
+    const spyGetKey = jest.spyOn(AxiosMemoAdapter, 'getKey').mockImplementation(() => 'key');
+    const config: AxiosRequestConfig = {
+      data: { key: 'value' },
+      method: 'GET',
+      params: { pages: 2 },
+      url: 'example.com',
+    };
+    await axiosMemoAdapter.execute(config);
+
+    expect(spyAxiosAbortExecute).toHaveBeenCalledWith(config);
+    expect(spyGetKey).toHaveBeenLastCalledWith(config);
+
+    await axiosMemoAdapter.execute(config);
+
+    expect(spyAxiosAbortExecute).toHaveBeenCalledTimes(2);
+    expect(spyGetKey).toHaveBeenCalledTimes(2);
+    spyGetKey.mockReset();
+    spyGetKey.mockRestore();
+  });
+
+  it('should put request into cache', async () => {
+    const config: AxiosRequestConfig = {
+      data: { key: 'value' },
+      headers: { cached: true },
+      method: 'GET',
+      params: { pages: 2 },
+      url: 'example.com',
+    };
+    await axiosMemoAdapter.execute(config);
+
+    expect(spyAxiosAbortExecute).toHaveBeenCalledWith(config);
+
+    await axiosMemoAdapter.execute(config);
+
+    expect(spyAxiosAbortExecute).toHaveBeenCalledTimes(1);
+
+    await axiosMemoAdapter.execute({
+      ...config,
+      headers: {},
+    });
+
+    expect(spyAxiosAbortExecute).toHaveBeenCalledTimes(2);
+  });
+
+  it('should catch an error', async () => {
+    spyAxiosAbortExecute = jest
+      .spyOn(axiosAbortAdapter, 'execute')
+      .mockImplementation((): AxiosPromise<string> => {
+        throw new Error('mockExecuteError');
+      });
+    const config: AxiosRequestConfig = {
+      data: { key: 'value' },
+      headers: { cached: true },
+      method: 'GET',
+      params: { pages: 2 },
+      url: 'example.com',
+    };
+    try {
+      await axiosMemoAdapter.execute(config);
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      expect(error.message).toBe('mockExecuteError');
+    }
+  });
+});