Added services|entities|dao|mobx-store samples. Started code coverage by unit tests

Author: Daniil Yankouski

configs/jest/config.ts

@@ -9,12 +9,15 @@ type JestConfig = Partial<
   transform: Record<string, string>;
 };
 
+process.env.TZ = 'UTC'
+
 const config: JestConfig = {
-  collectCoverageFrom: ['<rootDir>/src/{domain,data-access,core}/**/*.ts'],
+  collectCoverageFrom: ['<rootDir>/src/{domain,data,presentation,core}/**/*.ts'],
   coverageDirectory: 'coverage',
   coveragePathIgnorePatterns: [
     '<rootDir>/node_modules',
     '<rootDir>/configs',
+    '<rootDir>/assets',
     '<rootDir>/src/presentation/web/index.tsx',
     '<rootDir>/src/presentation/web/app.component.tsx',
     '.d.ts',
@@ -32,6 +35,11 @@ const config: JestConfig = {
     'ts-jest': {
       tsconfig: '<rootDir>/tsconfig.json',
     },
+    window: {
+      document: {
+        cookie: ''
+      }
+    },
     ...BuildDefine,
   },
   moduleDirectories: ['<rootDir>/node_modules', '<rootDir>/node_modules/@types', '<rootDir>/src'],

package.json

@@ -5,7 +5,7 @@
     "email": "[email protected]",
     "url": "https://vk.com/qdanik"
   },
-  "version": "2.1.0",
+  "version": "2.2.0",
   "main": "src/presentation/web/index.tsx",
   "scripts": {
     "vite": "vite --config ./configs/vite/config.ts",
@@ -35,6 +35,7 @@
     "mobx-react": "7.3.0",
     "react": "17.0.2",
     "react-dom": "17.0.2",
+    "react-helmet": "^6.1.0",
     "react-hook-form": "7.27.1",
     "react-router": "6.2.2",
     "react-router-dom": "6.2.2",

src/containers/containers.ts

@@ -1,8 +1,8 @@
-import { baseAdapters } from './base';
 import { Container } from './config';
+import { coreModules } from './core';
 
-export const containers = new Container({
+export const container = new Container({
   autoBindInjectable: true,
 });
 
-containers.load(baseAdapters);
+container.load(coreModules);

src/containers/base/index.ts src/containers/core/index.tssrc/containers/base/index.ts renamed to src/containers/core/index.ts

@@ -10,13 +10,18 @@ import {
   SessionStorageAdapter,
   ReactHookFormAdapter,
   I18nextAdapter,
+  WebLoggerAdapter,
 } from 'core/adapters';
 import { FormType } from 'core/form';
 import { HttpClientAdapterType, HttpClientType } from 'core/http';
 import { I18nType } from 'core/i18n';
+import { LoggerType } from 'core/logger';
+import { MobxStoreImpl, MobxStoreType } from 'core/mobx-store';
 import { StorageType, CookieStorageName, LocalStorageName, SessionStorageName } from 'core/storage';
 
-export const baseAdapters = new ContainerModule(bind => {
+export const coreModules = new ContainerModule(bind => {
+  bind(LoggerType).to(WebLoggerAdapter);
+  bind(MobxStoreType).to(MobxStoreImpl).inSingletonScope();
   bind(StorageType).to(BrowserCookieAdapter).whenTargetNamed(CookieStorageName);
   bind(StorageType).to(LocalStorageAdapter).whenTargetNamed(LocalStorageName);
   bind(StorageType).to(SessionStorageAdapter).whenTargetNamed(SessionStorageName);

src/containers/index.ts

@@ -1,3 +1 @@
-import { containers } from './containers';
-
-export const AppContainer = containers;
+export { container as AppContainer } from './containers';

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

@@ -1,14 +1,32 @@
-import axios, { AxiosRequestConfig } from 'axios';
-import { containers } from 'containers/containers';
-import { AxiosAdapter } from 'core/adapters';
-import { HttpClientType } from 'core/http';
+import axios, { AxiosPromise, AxiosRequestConfig } from 'axios';
+import { AbortPromise } from 'core/http';
 import { mockData, mockUrl } from './axios.adapter.mock';
+import { AxiosAbortAdapter } from '../axios-abort.adapter';
+import { AxiosMemoAdapter } from '../axios-memo.adapter';
+import { AxiosAdapter } from '../axios.adapter';
 
 jest.mock('axios', () => {
   const mockAxios = {
+    defaults: {
+      adapter: jest.fn(config => {
+        if (!config) {
+          throw new Error('mockAdapterError');
+        }
+
+        return Promise.resolve();
+      }),
+    },
     delete: jest.fn(() => Promise.resolve()),
     get: jest.fn(() => Promise.resolve()),
     head: jest.fn(() => Promise.resolve()),
+    interceptors: {
+      request: {
+        use: jest.fn(() => Promise.resolve()),
+      },
+      response: {
+        use: jest.fn(() => Promise.resolve()),
+      },
+    },
     options: jest.fn(() => Promise.resolve()),
     patch: jest.fn(() => Promise.resolve()),
     post: jest.fn(() => Promise.resolve()),
@@ -21,19 +39,29 @@ jest.mock('axios', () => {
   };
 });
 
-describe('AxiosAdapterFake', () => {
+describe('AxiosAdapters', () => {
   let axiosAdapter: AxiosAdapter;
+  let axiosAbortAdapter: AxiosAbortAdapter;
+  let axiosMemoAdapter: AxiosMemoAdapter;
   let axiosConfig: AxiosRequestConfig;
 
-  describe('should execute methods with correct arguments', () => {
+  beforeEach(() => {
+    axiosAbortAdapter = new AxiosAbortAdapter();
+    axiosMemoAdapter = new AxiosMemoAdapter(axiosAbortAdapter);
+    axiosAdapter = new AxiosAdapter(axiosMemoAdapter);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('AxiosAdapter', () => {
     beforeEach(() => {
-      containers.snapshot();
-      axiosAdapter = containers.get(HttpClientType) as AxiosAdapter;
+      axiosAdapter.initialize();
       axiosConfig = axiosAdapter.getConfig();
     });
 
     afterEach(() => {
-      containers.restore();
       jest.restoreAllMocks();
     });
 
@@ -42,46 +70,178 @@ describe('AxiosAdapterFake', () => {
       expect(axios.create).toHaveBeenCalledWith(axiosConfig);
     });
 
-    it('delete', async () => {
+    it('send DELETE request', async () => {
       await axiosAdapter.delete(mockUrl, axiosConfig);
 
       expect(axios.delete).toHaveBeenCalledWith(mockUrl, axiosConfig);
     });
 
-    it('get', async () => {
+    it('send GET request', async () => {
       await axiosAdapter.get(mockUrl, axiosConfig);
 
       expect(axios.get).toHaveBeenCalledWith(mockUrl, axiosConfig);
     });
 
-    it('head', async () => {
+    it('send HEAD request', async () => {
       await axiosAdapter.head(mockUrl, axiosConfig);
 
       expect(axios.head).toHaveBeenCalledWith(mockUrl, axiosConfig);
     });
 
-    it('options', async () => {
+    it('send OPTIONS request', async () => {
       await axiosAdapter.options(mockUrl, axiosConfig);
 
       expect(axios.options).toHaveBeenCalledWith(mockUrl, axiosConfig);
     });
 
-    it('patch', async () => {
+    it('send PATCH request', async () => {
       await axiosAdapter.patch(mockUrl, mockData, axiosConfig);
 
       expect(axios.patch).toHaveBeenCalledWith(mockUrl, mockData, axiosConfig);
     });
 
-    it('post', async () => {
+    it('send POST request', async () => {
       await axiosAdapter.post(mockUrl, mockData, axiosConfig);
 
       expect(axios.post).toHaveBeenCalledWith(mockUrl, mockData, axiosConfig);
     });
 
-    it('put', async () => {
+    it('send PUT request', async () => {
       await axiosAdapter.put(mockUrl, mockData, axiosConfig);
 
       expect(axios.put).toHaveBeenCalledWith(mockUrl, mockData, axiosConfig);
     });
+
+    it('set REQUEST interceptors', () => {
+      const callback = () => null;
+      axiosAdapter.setRequestInterceptors(callback, callback);
+
+      expect(axios.interceptors.request.use).toHaveBeenCalledWith(callback, callback);
+    });
+
+    it('set RESPONSE interceptors', () => {
+      const callback = () => null;
+      axiosAdapter.setResponseInterceptors(callback, callback);
+
+      expect(axios.interceptors.response.use).toHaveBeenCalledWith(callback, callback);
+    });
+  });
+
+  describe('AxiosMemoAdapter', () => {
+    let spyAxiosAbortExecute;
+
+    beforeEach(() => {
+      spyAxiosAbortExecute = jest.spyOn(axiosAbortAdapter, 'execute').mockImplementation(
+        (): AxiosPromise<string> =>
+          Promise.resolve({
+            config: {},
+            data: 'response',
+            headers: {},
+            status: 200,
+            statusText: 'OK',
+          }),
+      );
+    });
+
+    afterEach(() => {
+      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');
+      }
+    });
+  });
+
+  describe('AxiosAbortAdapter', () => {
+    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/axios-abort.adapter.ts

@@ -1,16 +1,15 @@
-import httpAdapter from 'axios/lib/adapters/http';
-import { AxiosAdapter, AxiosRequestConfig } from 'axios';
+import axios, { AxiosRequestConfig } from 'axios';
 import { Injectable } from 'containers/config';
 import { AbortPromise, HttpClientAdapter } from 'core/http';
 
 export const AxiosAbortName = Symbol('AxiosAbort');
 
 @Injectable()
 export class AxiosAbortAdapter implements HttpClientAdapter<AxiosRequestConfig> {
-  execute: AxiosAdapter = (config: AxiosRequestConfig): AbortPromise<any> => {
+  execute = (config: AxiosRequestConfig): AbortPromise<any> => {
     const controller = new AbortController();
     try {
-      const request = httpAdapter(config);
+      const request: AbortPromise<any> = axios.defaults.adapter(config);
       request.abort = () => controller.abort();
 
       return request;

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

@@ -1,4 +1,4 @@
-import { AxiosAdapter, AxiosRequestConfig } from 'axios';
+import { AxiosRequestConfig } from 'axios';
 import { Inject, Injectable, Named } from 'containers/config';
 import { AbortPromise, HttpClientAdapter, HttpClientAdapterType } from 'core/http';
 import { AxiosAbortName } from './axios-abort.adapter';
@@ -24,18 +24,26 @@ export class AxiosMemoAdapter implements HttpClientAdapter<AxiosRequestConfig> {
     });
   }
 
-  execute: AxiosAdapter = (config: AxiosRequestConfig): AbortPromise<any> => {
+  execute = (config: AxiosRequestConfig): AbortPromise<any> => {
     const key = AxiosMemoAdapter.getKey(config);
     try {
-      if (!this._requests.has(key)) {
-        this._requests.set(key, this._abortAdapter.execute(config));
+      const execute = () => this._abortAdapter.execute(config);
+
+      if (config.headers?.cached) {
+        if (!this._requests.has(key)) {
+          this._requests.set(key, execute());
+        }
+
+        return this._requests.get(key);
+      }
+
+      if (this._requests.has(key)) {
+        this._requests.delete(key);
       }
 
-      return this._requests.get(key);
+      return execute();
     } catch (e) {
       return Promise.reject(e);
-    } finally {
-      this._requests.delete(key);
     }
   };
 }