@amanat-qa/utils-backend 1.0.8

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@amanat-qa/utils-backend",
+  "version": "1.0.8",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs",
+  "files": [
+    "src"
+  ],
+  "keywords": [],
+  "license": "MIT",
+  "exports": {
+    ".": "./src/index.js",
+    "./baseAPI": "./src/api/baseAPI.js",
+    "./JSONLoader": "./src/data/JSONLoader.js",
+    "./JSONMapper": "./src/data/JSONMapper.js",
+    "./dataUtils": "./src/data/dataUtils.js",
+    "./filesParser": "./src/data/filesParser.js",
+    "./gitlabCIGenerator": "./src/data/gitlabCIGenerator.js",
+    "./baseDB": "./src/db/baseDB.js",
+    "./index": "./src/index.js",
+    "./logger": "./src/log/logger.js",
+    "./randomizer": "./src/random/randomizer.js",
+    "./timeUtils": "./src/time/timeUtils.js"
+  },
+  "dependencies": {
+    "axios": "*",
+    "fs": "*",
+    "moment": "*",
+    "path": "*",
+    "dotenv": "*",
+    "js-yaml": "*",
+    "mysql2": "*",
+    "allure-mocha": "*"
+  }
+}

package/src/api/baseAPI.js

@@ -0,0 +1,72 @@
+const axios = require('axios');
+const Logger = require('../log/logger');
+
+class BaseAPI {
+  #baseURL;
+
+  #logString;
+
+  #timeout;
+
+  #headers;
+
+  #axiosInstance;
+
+  constructor(options) {
+    this.#baseURL = options.baseURL;
+    this.#logString = options.logString;
+    this.#timeout = options.timeout;
+    this.#headers = options.headers;
+    this.#axiosInstance = this.createInstance();
+  }
+
+  createInstance() {
+    if (this.#logString) Logger.log(`${this.#logString} ${this.#baseURL}`);
+    return axios.create({
+      baseURL: this.#baseURL,
+      timeout: this.#timeout,
+      headers: this.#headers,
+    });
+  }
+
+  async get(endpoint, params) {
+    Logger.log(`[req] ▶ get ${JSON.stringify(params || {})} from ${endpoint}:`);
+    try {
+      const response = await this.#axiosInstance.get(`/${endpoint}`, { params });
+      Logger.log(`[res]   status code: ${response.status}`);
+      return response;
+    } catch (error) {
+      Logger.log(`[res]   status code: ${error.response.status}`);
+      Logger.log(`[res]   body: ${JSON.stringify(error.response.data)}`);
+      return error.response;
+    }
+  }
+
+  async post(endpoint, params) {
+    Logger.log(`[req] ▶ post ${JSON.stringify(params || {})} to ${endpoint}:`);
+    try {
+      const response = await this.#axiosInstance.post(`/${endpoint}`, params);
+      Logger.log(`[res]   status code: ${response.status}`);
+      return response;
+    } catch (error) {
+      Logger.log(`[res]   status code: ${error.response.status}`);
+      Logger.log(`[res]   body: ${JSON.stringify(error.response.data)}`);
+      return error.response;
+    }
+  }
+
+  async patch(endpoint, params) {
+    Logger.log(`[req] ▶ patch ${JSON.stringify(params || {})} to ${endpoint}:`);
+    try {
+      const response = await this.#axiosInstance.patch(`/${endpoint}`, params);
+      Logger.log(`[res]   status code: ${response.status}`);
+      return response;
+    } catch (error) {
+      Logger.log(`[res]   status code: ${error.response.status}`);
+      Logger.log(`[res]   body: ${JSON.stringify(error.response.data)}`);
+      return error.response;
+    }
+  }
+}
+
+module.exports = BaseAPI;

package/src/data/JSONLoader.js

@@ -0,0 +1,8 @@
+let JSONLoader;
+try {
+	JSONLoader = require('../../../../../test/main/utils/data/JSONLoader');
+} catch (e) {
+	throw new Error('[err]   JSONLoader require error!');
+}
+
+module.exports = JSONLoader;

package/src/data/JSONMapper.js

@@ -0,0 +1,214 @@
+/* eslint no-restricted-syntax: ['off', 'ForInStatement'] */
+const Logger = require('../log/logger');
+
+class JSONMapper {
+  static getNestedProperty(flattenedObj, path) {
+    const keys = [];
+    const values = [];
+    for (const key in flattenedObj) {
+      if (Object.hasOwn(flattenedObj, key)) {
+        if (key.endsWith(`.${path}`) || key === path) {
+          keys.push(key);
+          values.push(flattenedObj[key]);
+        }
+      }
+    }
+
+    return { keys, values };
+  }
+
+  static deleteNotSimilarProperty(flattenedObj, mappingSchema) {
+    const keysToDelete = [];
+    const outputObj = { ...flattenedObj };
+    for (const key in outputObj) {
+      if (Object.hasOwn(outputObj, key)) {
+        let shouldDelete = true;
+        for (const path in mappingSchema) {
+          if (Object.hasOwn(mappingSchema, path)) {
+            if (key.endsWith(`.${path}`) || key === path) {
+              shouldDelete = false;
+              break;
+            }
+          }
+        }
+
+        if (shouldDelete) keysToDelete.push(key);
+      }
+    }
+
+    keysToDelete.forEach((key) => delete outputObj[key]);
+    return outputObj;
+  }
+
+  static flattenJSON(obj) {
+    const result = {};
+    const recursive = (currentObj, prefix = '') => {
+      for (const objKey in currentObj) {
+        if (Object.hasOwn(currentObj, objKey)) {
+          const fullKey = prefix ? `${prefix}.${objKey}` : objKey;
+          if (typeof currentObj[objKey] === 'object') {
+            recursive(currentObj[objKey], fullKey);
+          } else {
+            result[fullKey] = currentObj[objKey];
+          }
+        }
+      }
+    };
+
+    recursive(obj);
+    return result;
+  }
+
+  static mapValues(firstData, secondData, mappingSchema) {
+    const [firstName] = Object.keys(firstData);
+    const firstObj = firstData[firstName];
+    const [secondName] = Object.keys(secondData);
+    const secondObj = secondData[secondName];
+    const firstFlattenedObj = this.flattenJSON(firstObj);
+    const secondFlattenedObj = this.flattenJSON(secondObj);
+    const firstFlattenedObjKeys = Object.keys(firstFlattenedObj);
+    const secondFlattenedObjKeys = Object.keys(secondFlattenedObj);
+    for (const path in mappingSchema) {
+      if (Object.hasOwn(mappingSchema, path)) {
+        if (firstFlattenedObjKeys.some((key) => key.endsWith(path))) {
+          if (secondFlattenedObjKeys.some((key) => key.endsWith(mappingSchema[path]))) {
+            let index = 0;
+            for (const key in firstFlattenedObj) {
+              if (Object.hasOwn(firstFlattenedObj, key)) {
+                if (this.getNestedProperty(firstFlattenedObj, path).keys.includes(key)) {
+                  const valuesArr = this.getNestedProperty(secondFlattenedObj, mappingSchema[path])
+                    .values;
+                  firstFlattenedObj[key] = index >= valuesArr.length
+                    ? valuesArr[valuesArr.length - 1]
+                    : valuesArr[index];
+                  index += 1;
+                }
+              }
+            }
+          } else {
+            throw new Error(Logger.log(`[err]   mapping key "${mappingSchema[path]}" wasn't found in ${secondName}`));
+          }
+        } else {
+          throw new Error(Logger.log(`[err]   mapping key "${path}" wasn't found in ${firstName}`));
+        }
+      }
+    }
+
+    return this.deleteNotSimilarProperty(firstFlattenedObj, mappingSchema);
+  }
+
+  static rewriteValues(mappedObj, firstDict, secondDict) {
+    const firstDictKeys = Object.keys(firstDict);
+    const secondDictKeys = Object.keys(secondDict);
+    const outputObj = { ...mappedObj };
+    for (const key in outputObj) {
+      if (Object.hasOwn(outputObj, key)) {
+        if (firstDictKeys.some((path) => this.getNestedProperty(outputObj, path)
+            .keys.includes(key))
+          && secondDictKeys.some((path) => this.getNestedProperty(outputObj, path)
+            .keys.includes(key))) {
+          secondDictKeys.forEach((dictKey) => {
+            if (this.getNestedProperty(outputObj, dictKey).keys.includes(key)) {
+              for (const dictSubKey in secondDict[dictKey]) {
+                if (Object.hasOwn(secondDict[dictKey], dictSubKey)) {
+                  if (secondDict[dictKey][dictSubKey] === outputObj[key] || dictSubKey === 'constant') {
+                    outputObj[key] = firstDict[dictKey][dictSubKey];
+                  }
+                }
+              }
+            }
+          });
+        }
+      }
+    }
+
+    return outputObj;
+  }
+
+  static unflattenJSON(flattenedObj) {
+    const result = {};
+    for (const key in flattenedObj) {
+      if (Object.hasOwn(flattenedObj, key)) {
+        const keys = key.split('.');
+        let currentLevel = result;
+        for (let i = 0; i < keys.length - 1; i += 1) {
+          const currentKey = keys[i];
+          const nextKeyIsArrayIndex = /^\d+$/.test(keys[i + 1]);
+          if (!currentLevel[currentKey] || typeof currentLevel[currentKey] !== 'object') {
+            currentLevel[currentKey] = nextKeyIsArrayIndex ? [] : {};
+          }
+
+          currentLevel = currentLevel[currentKey];
+        }
+
+        currentLevel[keys[keys.length - 1]] = flattenedObj[key];
+      }
+    }
+
+    return result;
+  }
+
+  static safeMergeObjects(...mappedObjects) {
+    const result = {};
+    const locations = {};
+    mappedObjects.forEach((mappedObj) => {
+      const [currentLocation] = Object.keys(mappedObj);
+      const data = mappedObj[currentLocation];
+      locations[currentLocation] = {};
+      for (const [key, value] of Object.entries(data)) {
+        if (key in result) {
+          if (result[key] !== value) {
+            for (const location in locations) {
+              if (Object.hasOwn(locations, location)) {
+                if (key in locations[location]) {
+                  if (location[key] !== value) {
+                    throw new Error(`[err]   conflicting values for duplicated keys "${key}" found in the ${currentLocation} and in the ${location} during mapped objects merge`);
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        result[key] = value;
+        locations[currentLocation][key] = value;
+      }
+    });
+
+    return result;
+  }
+
+  static getObjectWithSpecifiedKeyFromArray(array, keyName) {
+    let result = null;
+    for (let i = 0; i < array.length; i += 1) {
+      if (this.hasKey(array[i], keyName)) result = array[i];
+    }
+    return result;
+  }
+
+  static hasKey(obj, keyToFind) {
+    if (typeof obj !== 'object' || obj === null) return false;
+
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) { // Safeguard added
+        if (key === keyToFind) {
+          return true;
+        }
+        if (typeof obj[key] === 'object' && this.hasKey(obj[key], keyToFind)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  static appendPrefixToKeys(obj, prefix) {
+    const newObj = {};
+    Object.keys(obj).forEach((key) => {
+      newObj[prefix + key] = obj[key];
+    });
+    return newObj;
+  }
+}
+
+module.exports = JSONMapper;

package/src/data/dataUtils.js

@@ -0,0 +1,398 @@
+const fs = require('fs');
+const moment = require('moment');
+const JSONMapper = require('./JSONMapper');
+const JSONLoader = require('./JSONLoader');
+const TimeUtils = require('../time/timeUtils');
+const Randomizer = require('../random/randomizer');
+
+class DataUtils {
+  static saveToJSON(obj) {
+    const [name] = Object.keys(obj);
+    const data = obj[name];
+    const replacer = (key, value) => (typeof value === 'undefined' ? null : value);
+    fs.writeFileSync(`./test/artifacts/${name}.json`, JSON.stringify(data, replacer, 4));
+  }
+
+  static passBugsTWB(mappedData, getPolicyData) {
+    const outputData = { ...mappedData };
+
+    // Pass TWB bug with "doc_gived_by" value
+    const docGivedByFullKeys = JSONMapper.getNestedProperty(outputData, 'doc_gived_by').keys;
+    docGivedByFullKeys.forEach((fullKey) => {
+      if (JSONMapper.flattenJSON(getPolicyData)[fullKey] === 'МВД РК'
+        || JSONMapper.flattenJSON(getPolicyData)[fullKey] === '-') {
+        outputData[fullKey] = JSONMapper.flattenJSON(getPolicyData)[fullKey];
+      }
+    });
+
+    // Pass TWB bug with "driver_certificate_date" empty value
+    const driverCertificateDateFullKeys = JSONMapper
+      .getNestedProperty(outputData, 'driver_certificate_date').keys;
+    driverCertificateDateFullKeys.forEach((fullKey) => {
+      if (JSONMapper.flattenJSON(getPolicyData)[fullKey] === '') {
+        outputData[fullKey] = JSONMapper.flattenJSON(getPolicyData)[fullKey];
+      }
+    });
+
+    // Pass TWB bug with "verify_bool" value without verification
+    if (getPolicyData.contracts[0].verify_bool === 1
+      && outputData['contracts.0.verify_bool'] === 0) {
+      outputData['contracts.0.verify_bool'] = getPolicyData.contracts[0].verify_bool;
+    }
+
+    return outputData;
+  }
+
+  /* eslint-disable no-param-reassign */
+  static mapRequestToOnes(onesData, requestData, isOGPO, optionalSchema) {
+    let onesDataFileName = 'onesDataCommon';
+    let requestToOnesMappedDataFileName = 'requestToOnesMappedDataCommon';
+    let mapSchema = JSONLoader.requestToOnesMapSchemaCommonKASKO;
+
+    if (isOGPO) {
+      mapSchema = JSONLoader.requestToOnesMapSchemaOGPO;
+      onesDataFileName = 'onesDataOGPO';
+      requestToOnesMappedDataFileName = 'requestToOnesMappedDataOGPO';
+    }
+
+    const mappedData = JSONMapper.mapValues(
+      { onesData },
+      { requestData },
+      optionalSchema ?? mapSchema,
+    );
+
+    const rewrittenData = JSONMapper.rewriteValues(
+      mappedData,
+      JSONLoader.dictOnes,
+      JSONLoader.dictRequest,
+    );
+
+    const requestToOnesMappedData = JSONMapper.unflattenJSON(rewrittenData);
+    requestToOnesMappedData.ie_date = TimeUtils.reformatDateFromDMYToYMDHms(rewrittenData.ie_date);
+    requestToOnesMappedData.claims.forEach((claim, index) => {
+      const rewrittenDateKey = `claims.${index}.notice_date`; // Build the dynamic key
+      claim.notice_date = TimeUtils.reformatDateFromDMYToYMDHms(rewrittenData[rewrittenDateKey]);
+    });
+    this.saveToJSON({ [onesDataFileName]: onesData });
+    this.saveToJSON({ [requestToOnesMappedDataFileName]: requestToOnesMappedData });
+    return requestToOnesMappedData;
+  }
+
+  static sortOGPORequestAndOnesData(requestData, onesData) {
+    /* This method sorts victim objects in requestData and claims in onesData for OGPO case
+    in preparation for mapping.
+    Order: 1st - Victim_Vehicle, 2nd - Victim_Client, 3rd - Victim_Other.
+    */
+
+    const priority = JSONLoader.testData.victimObjectsSortPriority;
+
+    requestData.victim_objects.sort((a, b) => {
+      const typeA = a.type;
+      const typeB = b.type;
+      return (priority[typeA] || 999) - (priority[typeB] || 999);
+    });
+
+    onesData.claims.sort((a, b) => {
+      const typeA = a.victim_objects[0].type;
+      const typeB = b.victim_objects[0].type;
+      return (priority[typeA] || 999) - (priority[typeB] || 999);
+    });
+
+    this.saveToJSON({ requestDataSorted: requestData });
+    this.saveToJSON({ onesDataSorted: onesData });
+    return { requestData, onesData };
+  }
+
+  static mapIEESBDToRequestOGPO(requestData, getIEESBDResponse) {
+    /* OGPO IE and victim object mapping is separated into 4 parts:
+    IE and each of 3 victim objects.
+    Victim objects are created asynchronically, so we can't rely on
+    their array order in request to map them with ESBD.
+    So we need to separate them and determine which victim object from
+    response is to be mapped with victim object in response.
+     */
+
+    // Save input data into files.
+    this.saveToJSON({ requestDataOGPO: requestData });
+    this.saveToJSON({ getIEESBDResponseOGPO: getIEESBDResponse });
+
+    // Main part of mapping - ie from ESBD to request.
+    const IEMappedPart = JSONMapper.mapValues(
+      { requestDataOGPO: requestData },
+      { getIEESBDResponse },
+      JSONLoader.IEToRequestMapSchemaOGPO,
+    );
+
+    // Form array of victim objects from request and esbd response.
+    const victimObjectsRequestArray = requestData.victim_objects;
+    const victimObjectsESBDArray = getIEESBDResponse
+      .GetInsuranceEventsResult.Insurance_Event.Victim_Objects.Victim_Object;
+
+    // Find victim objects in request and ESBD response and using unique keys.
+    const victimVehicleRequest = JSONMapper
+      .getObjectWithSpecifiedKeyFromArray(victimObjectsRequestArray, 'TF_ID');
+    const victimVehicleESBD = JSONMapper
+      .getObjectWithSpecifiedKeyFromArray(victimObjectsESBDArray, 'Victim_Vehicle');
+    let victimVehicleMappedPart = JSONMapper.mapValues(
+      { victimVehicleRequest },
+      { victimVehicleESBD },
+      JSONLoader.victimVehicleToRequestMapSchema,
+    );
+    victimVehicleMappedPart = JSONMapper.appendPrefixToKeys(victimVehicleMappedPart, 'victim_objects.0.');
+
+    const victimClientRequest = JSONMapper
+      .getObjectWithSpecifiedKeyFromArray(victimObjectsRequestArray, 'DEATH_BOOL');
+    const victimClientESBD = JSONMapper
+      .getObjectWithSpecifiedKeyFromArray(victimObjectsESBDArray, 'Victim_Client');
+    let victimClientMappedPart = JSONMapper.mapValues(
+      { victimClientRequest },
+      { victimClientESBD },
+      JSONLoader.victimClientToRequestMapSchema,
+    );
+    victimClientMappedPart = JSONMapper.appendPrefixToKeys(victimClientMappedPart, 'victim_objects.1.');
+
+    const victimOtherRequest = JSONMapper
+      .getObjectWithSpecifiedKeyFromArray(victimObjectsRequestArray, 'VICTIM_OTHER_TYPE_ID');
+    const victimOtherESBD = JSONMapper
+      .getObjectWithSpecifiedKeyFromArray(victimObjectsESBDArray, 'Victim_Other');
+    let victimOtherMappedPart = JSONMapper.mapValues(
+      { victimOtherRequest },
+      { victimOtherESBD },
+      JSONLoader.victimOtherToRequestMapSchema,
+    );
+    victimOtherMappedPart = JSONMapper.appendPrefixToKeys(victimOtherMappedPart, 'victim_objects.2.');
+
+    // After mapping merge them together into single mapped object.
+    const mappingResult = JSONMapper.safeMergeObjects(
+      { IEMappedPart },
+      { victimVehicleMappedPart },
+      { victimClientMappedPart },
+      { victimOtherMappedPart },
+    );
+
+    // Save output data into files.
+    this.saveToJSON({ IEMappedPart });
+    this.saveToJSON({ victimVehicleMappedPart });
+    this.saveToJSON({ victimClientMappedPart });
+    this.saveToJSON({ victimOtherMappedPart });
+
+    const IEToRequestMappedData = JSONMapper.unflattenJSON(mappingResult);
+    this.saveToJSON({ OGPOMappingResult: mappingResult });
+    this.saveToJSON({ OGPOIEToRequestMappedData: IEToRequestMappedData });
+
+    return IEToRequestMappedData;
+  }
+
+  static mapClaimESBDToRequestOGPO(claimESBD) {
+    const mappedBody = JSONLoader.claimToRequestMapTemplateOGPO;
+
+    mappedBody.informer.id_esbd = claimESBD.CLAIMANT_ID;
+    mappedBody.victim_objects[0].pre_appraisal_damage = claimESBD.PRELIMINARY_DAMAGE_APPRAISAL;
+    mappedBody.claimant_type_id = claimESBD.CLAIMANT_TYPE_ID;
+
+    const claimESBDFileName = `claim_ESBD_${claimESBD.IE_CLAIM_ID}`;
+    const claimMappingResultFileName = `claim_mapped_ESBD_to_request_${claimESBD.IE_CLAIM_ID}`;
+    this.saveToJSON({ [claimMappingResultFileName]: mappedBody });
+    this.saveToJSON({ [claimESBDFileName]: claimESBD });
+
+    return mappedBody;
+  }
+
+  static mapESBDToRequestCommon(requestData, getIEESBDResponse) {
+    // Common IE, claim, victim objects are possible to get
+    // using single ESBD method to get common IE.
+
+    this.saveToJSON({ requestDataCommonKASKO: requestData });
+    this.saveToJSON({ getIEESBDResponseCommonKASKO: getIEESBDResponse });
+
+    const mappedData = JSONMapper.mapValues(
+      { requestData },
+      { getIEESBDResponse },
+      JSONLoader.IEToRequestMapSchemaCommon,
+    );
+
+    const IEToRequestMappedData = JSONMapper.unflattenJSON(mappedData);
+
+    // Calculating preliminary damage appraisal from ESBD average RBNS reserve value
+    const insuranceTypeID = requestData.victim_objects[0].insurance_type_id;
+    const averageRBNS = JSONLoader
+      .averageRBNS.filter((avgRBNS) => (
+        avgRBNS.insurance_type_id_esbd === insuranceTypeID
+          ? avgRBNS.insurance_type_id_esbd
+          : null))[0];
+    let preliminaryDamageCalculated = getIEESBDResponse
+      .data.GetIECommon_By_IdResult.COMMON_CLAIMS.COMMON_CLAIM.PRELIMINARY_DAMAGE_APPRAISAL;
+    preliminaryDamageCalculated = Math
+      .round(preliminaryDamageCalculated / (1 + (averageRBNS.percent * 0.01)));
+    IEToRequestMappedData.victim_objects[0].pre_appraisal_damage = preliminaryDamageCalculated;
+
+    // Delete redundant mapped "descriptions".
+    delete IEToRequestMappedData.location.description;
+    delete IEToRequestMappedData.victim_objects[0].participants.client.description;
+
+    this.saveToJSON({ IEToRequestMappedDataCommon: IEToRequestMappedData });
+
+    return IEToRequestMappedData;
+  }
+
+  /* eslint camelcase: ["error", {"properties": "never",
+  ignoreDestructuring: true, allow: ["verify_bool", "verify_type_id"]}] */
+  static generateSetPolicyRequest() {
+    const params = {};
+    const datesInterval = TimeUtils.getDatesInterval(...JSONLoader.testData.timeIncrement);
+    params.date_beg = datesInterval.startDate;
+    params.date_end = datesInterval.finishDate;
+
+    const { testClients } = JSONLoader;
+    const { testCars } = JSONLoader;
+
+    const { holder, insured } = DataUtils.createRandomHolderAndInsuredStructures(testClients);
+    const car = DataUtils.createRandomCarStructure(testCars);
+
+    params.insured_people = [];
+    params.insured_people[0] = insured;
+    params.holder = holder;
+    params.vehicles = [];
+    params.vehicles[0] = car;
+
+    return params;
+  }
+
+  static filterClients(clients, options = {}) {
+    const { isResident } = options;
+    const { hasPassport } = options;
+    const { hasDriverLicence } = options;
+    const { isUnderSixtyYearsOld } = options;
+    let filteredClients = [...clients];
+
+    filteredClients = filteredClients.filter((client) => {
+      if (isResident !== undefined) {
+        return isResident ? client.resident_bool : !client.resident_bool;
+      }
+
+      return true;
+    });
+
+    filteredClients = filteredClients.filter((client) => {
+      if (hasDriverLicence !== undefined) {
+        return hasDriverLicence ? client.driving_license : !client.driving_license;
+      }
+
+      return true;
+    });
+
+    filteredClients = filteredClients.filter((client) => {
+      if (hasPassport !== undefined) {
+        return hasPassport ? client.document_type_id === 2 : client.document_type_id !== 2;
+      }
+
+      return true;
+    });
+
+    filteredClients = filteredClients.filter((client) => {
+      if (isUnderSixtyYearsOld !== undefined) {
+        return isUnderSixtyYearsOld
+          ? moment(client.born) > moment().subtract(60, 'years')
+          : moment(client.born) <= moment().subtract(60, 'years');
+      }
+
+      return true;
+    });
+
+    return filteredClients;
+  }
+
+  /* eslint-disable camelcase */
+  static createRandomHolderAndInsuredStructures(clientsArr) {
+    const randomHolderIndex = Randomizer.getRandomInteger(clientsArr.length - 1);
+    let randomInsuredIndex;
+    do {
+      randomInsuredIndex = Randomizer.getRandomInteger(clientsArr.length - 1);
+    } while (randomInsuredIndex === randomHolderIndex);
+    const tempHolder = clientsArr[randomHolderIndex];
+    const tempInsured = clientsArr[randomInsuredIndex];
+    const resultHolder = { ...tempHolder };
+    const resultInsured = { ...tempInsured };
+
+    const verify_bool = Number(JSONLoader.configData.verification);
+    const verify_type_id = Number(JSONLoader.configData.verification) || 3;
+    const pdl = Randomizer.getRandomInteger(1);
+
+    resultInsured.pdl = pdl;
+    resultInsured.verify_bool = verify_bool;
+    resultInsured.verify_type_id = verify_type_id;
+
+    resultInsured.esbd_id = tempInsured.client_id;
+    resultInsured.driver_certificate = tempInsured.driving_license;
+
+    resultInsured.born = TimeUtils.reformatDateFromYMDToDMY(tempInsured.born);
+    resultInsured.document_gived_date = TimeUtils
+      .reformatDateFromYMDToDMY(tempInsured.document_gived_date);
+    resultInsured.driver_certificate_date = TimeUtils
+      .reformatDateFromYMDToDMY(tempInsured.date_issue_license);
+
+    resultInsured.iin = tempInsured.iin.toString();
+
+    resultInsured.natural_person_bool = JSONLoader.testData.natural_person_bool;
+    resultInsured.economics_sector_id = JSONLoader.testData.economics_sector_id;
+    resultInsured.notification_type_id = JSONLoader.testData.notification_type_id;
+    resultInsured.driver_certificate_type_id = JSONLoader.testData.driver_certificate_type_id;
+    resultInsured.experience_less = JSONLoader.testData.experience_less;
+    resultInsured.pensioner_bool = JSONLoader.testData.pensioner_bool;
+    resultInsured.country_id = JSONLoader.testData.country_id;
+    resultInsured.is_new = JSONLoader.testData.is_new;
+    resultInsured.class_id = JSONLoader.testData.class_id;
+    resultInsured.class = JSONLoader.testData.class;
+    resultInsured.document_gived_by = JSONLoader.testData.insured_document_gived_by;
+    resultInsured.email = JSONLoader.testData.insured_email;
+    resultInsured.mobile_phone = JSONLoader.testData.insured_mobile_phone;
+    resultInsured.address = JSONLoader.testData.insured_address;
+    resultInsured.is_insured = 1;
+
+    resultHolder.pdl = pdl;
+    resultHolder.verify_bool = verify_bool;
+    resultHolder.verify_type_id = verify_type_id;
+
+    resultHolder.esbd_id = tempHolder.client_id;
+    resultHolder.driver_certificate = tempHolder.driving_license;
+
+    resultHolder.born = TimeUtils.reformatDateFromYMDToDMY(tempHolder.born);
+    resultHolder.document_gived_date = TimeUtils
+      .reformatDateFromYMDToDMY(tempHolder.document_gived_date);
+    resultHolder.driver_certificate_date = TimeUtils
+      .reformatDateFromYMDToDMY(tempHolder.date_issue_license);
+
+    resultHolder.iin = tempHolder.iin.toString();
+
+    resultHolder.natural_person_bool = JSONLoader.testData.natural_person_bool;
+    resultHolder.economics_sector_id = JSONLoader.testData.economics_sector_id;
+    resultHolder.notification_type_id = JSONLoader.testData.notification_type_id;
+    resultHolder.driver_certificate_type_id = JSONLoader.testData.driver_certificate_type_id;
+    resultHolder.experience_less = JSONLoader.testData.experience_less;
+    resultHolder.pensioner_bool = JSONLoader.testData.pensioner_bool;
+    resultHolder.country_id = JSONLoader.testData.country_id;
+    resultHolder.is_new = JSONLoader.testData.is_new;
+    resultHolder.activity_kind_id = JSONLoader.testData.activity_kind_id;
+    resultHolder.document_gived_by = JSONLoader.testData.holder_document_gived_by;
+    resultHolder.email = JSONLoader.testData.holder_email;
+    resultHolder.mobile_phone = JSONLoader.testData.holder_mobile_phone;
+    resultHolder.address = JSONLoader.testData.holder_address;
+    resultHolder.is_insured = 0;
+
+    return { holder: resultHolder, insured: resultInsured };
+  }
+
+  static createRandomCarStructure(carsArr) {
+    const randomCarIndex = Randomizer.getRandomInteger(carsArr.length - 1);
+    const tempCar = carsArr[randomCarIndex];
+    const resultCar = { ...tempCar };
+
+    resultCar.esbd_id = tempCar.tf_id;
+    resultCar.dt_reg_cert = TimeUtils.reformatDateFromYMDToDMY(tempCar.dt_reg_cert);
+    resultCar.verified_bool = 1;
+
+    return resultCar;
+  }
+}
+
+module.exports = DataUtils;

package/src/data/filesParser.js

@@ -0,0 +1,104 @@
+const fs = require('fs');
+const path = require('path');
+require('dotenv').config({ path: path.join(__dirname, '../../../../../', '.env.test'), override: true });
+
+const envDirectory = path.join(__dirname, '../../../../../');
+const loaderFileLocation = path.join(__dirname, 'JSONLoader.js');
+const testClientsFileLocation = path.join(envDirectory, './test/resources/data/testClients.json');
+const testCarsFileLocation = path.join(envDirectory, './test/resources/data/testCars.json');
+const averageRBNSFileLocation = path.join(envDirectory, './test/resources/data/averageRBNS.json');
+const JSONDirectory = path.join(envDirectory, './test/resources');
+
+const getFiles = (directory, extension) => {
+  const allFiles = fs.readdirSync(directory);
+  const selectedFiles = allFiles.filter((file) => file.endsWith(extension));
+  allFiles.forEach((file) => {
+    const fullPath = path.join(directory, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      const nestedFiles = getFiles(fullPath, extension);
+      selectedFiles.push(...nestedFiles.map((nestedFile) => path.join(file, nestedFile)));
+    }
+  });
+
+  return selectedFiles;
+};
+
+const generateClassInit = (selectedFiles, directory) => `class JSONLoader {\n${selectedFiles.map((file) => {
+  const variableName = path.parse(file).name;
+  return `\tstatic get ${variableName}() {\n\t\tconst ${variableName} = require('${path.join(directory, file)}');\n\t\treturn JSON.parse(JSON.stringify(${variableName}));\n\t}\n\n`;
+}).join('')}`;
+
+const generateJSONLoader = (filePath, directory, extension) => {
+  const files = getFiles(directory, extension);
+  const classInit = generateClassInit(files, directory);
+  const classExport = '}\n\nmodule.exports = JSONLoader;';
+  fs.writeFileSync(filePath, classInit + classExport);
+};
+
+const setConfigData = (directory, extension) => {
+  const files = getFiles(directory, extension);
+  const configFile = files.filter((file) => file.includes('config')).pop();
+  if (configFile) {
+    const filePath = `${directory}/${configFile}`;
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    data.parallel = process.argv.includes('--parallel');
+    data.setPolicyWaitingTWB = process.argv.includes('--setPolicyWaitingTWB');
+    data.testOGPOClaim = process.argv.includes('--testOGPOClaim');
+
+    try {
+      data.verification = Boolean(JSON.parse(process.env.VERIFICATION ?? data.verification));
+    } catch (error) { // eslint-disable-next-line no-console
+      console.log('  [err]   incorrect value of "VERIFICATION" .env variable!');
+    }
+
+    try {
+      const value = JSON.parse(process.env.SET_POLICY_WAITING_TWB ?? data.setPolicyWaitingTWB);
+      data.setPolicyWaitingTWB = Boolean(value);
+    } catch (error) { // eslint-disable-next-line no-console
+      console.log('  [err]   incorrect value of "SET_POLICY_WAITING_TWB" .env variable!');
+    }
+
+    try {
+      data.getPolicyTWB = Boolean(JSON.parse(process.env.GET_POLICY_TWB ?? data.getPolicyTWB));
+    } catch (error) { // eslint-disable-next-line no-console
+      console.log('  [err]   incorrect value of "GET_POLICY_TWB" .env variable!');
+    }
+
+    if (process.env.GATEWAY_URL) {
+      const value = process.env.GATEWAY_URL.match(/\b(?:localhost|dev|staging)\b/g);
+      if (value) {
+        data.environment = value.pop();
+      } else { // eslint-disable-next-line no-console
+        console.log('  [err]   incorrect value of "GATEWAY_URL" .env variable!');
+      }
+    } else { // eslint-disable-next-line no-console
+      console.log('  [err]   "GATEWAY_URL" .env variable not exists!');
+    }
+
+    try {
+      const value = JSON.parse(process.env.TEST_OGPO_CLAIM ?? data.testOGPOClaim);
+      data.testOGPOClaim = Boolean(value);
+    } catch (error) { // eslint-disable-next-line no-console
+      console.log('  [err]   incorrect value of "TEST_OGPO_CLAIM" .env variable!');
+    }
+
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+  }
+};
+
+const checkEnvExists = (directory, extension) => {
+  const files = getFiles(directory, extension);
+  if (!files.length) throw new Error('[err]   .env.test file not exists in root directory!');
+};
+
+const generateTestDataFile = (filePath) => {
+  const emptyObj = {};
+  if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, JSON.stringify(emptyObj, null, 2), 'utf8');
+};
+
+checkEnvExists(envDirectory, '.test');
+setConfigData(JSONDirectory, '.json');
+generateTestDataFile(testCarsFileLocation);
+generateTestDataFile(testClientsFileLocation);
+generateTestDataFile(averageRBNSFileLocation);
+generateJSONLoader(loaderFileLocation, JSONDirectory, '.json');

package/src/data/gitlabCIGenerator.js

@@ -0,0 +1,50 @@
+const fs = require('fs');
+const path = require('path');
+const YAML = require('js-yaml');
+
+const projectDirectory = path.join(__dirname, '../../../../../');
+const specDirectory = path.join(projectDirectory, './test/tests/specs');
+
+const specFiles = fs.readdirSync(specDirectory);
+const jobs = specFiles.map((spec, index) => ({
+  [`API tests ${index + 1}`]: {
+    image: 'node:latest',
+    stage: 'test',
+    variables: {
+      SPEC_PATTERN: index + 1,
+    },
+    only: [
+      'dev',
+    ],
+    tags: [
+      'k8s',
+    ],
+    before_script: [
+      // eslint-disable-next-line no-template-curly-in-string
+      'echo "${ENV_TEST}" | tr -d "\r" > ./.env.test',
+      'apt-get update && apt-get install -y default-jre',
+      'npm install',
+    ],
+    script: [
+      'npm run lint',
+      'npm run test:split',
+    ],
+    artifacts: {
+      when: 'always',
+      expire_in: '1 month',
+      paths: [
+        'test/artifacts',
+        'test/resources/data/configData.json',
+      ],
+    },
+  },
+}));
+
+const gitlabCIConfig = {
+  ...Object.assign({}, ...jobs),
+};
+
+fs.writeFileSync(
+  path.join(__dirname, '..', '..', '..', '..', '.split-config.yml'),
+  YAML.dump(gitlabCIConfig),
+);

package/src/db/baseDB.js

@@ -0,0 +1,59 @@
+const mysql = require('mysql2/promise');
+const Logger = require('../log/logger');
+
+class BaseDB {
+  #host;
+
+  #user;
+
+  #port;
+
+  #password;
+
+  #database;
+
+  #connection;
+
+  constructor(host, user, password, database, port) {
+    this.#host = host;
+    this.#user = user;
+    this.#password = password;
+    this.#database = database;
+    this.#port = port;
+  }
+
+  async createConnection() {
+    Logger.log(`[inf] ▶ connect to ${this.#database} database`);
+    this.#connection = await mysql.createConnection({
+      host: this.#host,
+      user: this.#user,
+      password: this.#password,
+      database: this.#database,
+      port: this.#port,
+    });
+  }
+
+  async closeConnection() {
+    Logger.log(`[inf] ▶ close connection to ${this.#database} database`);
+    await this.#connection.end();
+  }
+
+  async sqlQuery(query, values) {
+    const [rows] = await this.#connection.query(query, values);
+    return rows;
+  }
+
+  async sqlSelect(
+    tableName,
+    target = '*',
+    conditions = '',
+    values = [],
+    options = { hasLogger: true },
+  ) {
+    if (options.hasLogger) Logger.log(`[inf] ▶ select ${target} from ${tableName} table`);
+    const query = `SELECT ${target} FROM ${tableName} ${conditions};`;
+    return this.sqlQuery(query, values);
+  }
+}
+
+module.exports = BaseDB;

package/src/index.js

@@ -0,0 +1,13 @@
+// Auto-generated file
+
+exports.baseAPI = require('./api/baseAPI');
+exports.JSONLoader = require('./data/JSONLoader');
+exports.JSONMapper = require('./data/JSONMapper');
+exports.dataUtils = require('./data/dataUtils');
+exports.filesParser = require('./data/filesParser');
+exports.gitlabCIGenerator = require('./data/gitlabCIGenerator');
+exports.baseDB = require('./db/baseDB');
+exports.index = require('./index');
+exports.logger = require('./log/logger');
+exports.randomizer = require('./random/randomizer');
+exports.timeUtils = require('./time/timeUtils');

package/src/log/logger.js

@@ -0,0 +1,57 @@
+const path = require('path');
+const moment = require('moment');
+const { createWriteStream } = require('fs');
+const allureMocha = require('allure-mocha/runtime');
+const JSONLoader = require('../data/JSONLoader');
+
+const filePath = path.join(path.resolve(), 'test', 'artifacts', 'log.txt');
+const timeList = [];
+const logList = [];
+
+class Logger {
+  static #title;
+
+  static log(step, title) {
+    logList.push(` ${step}`);
+    const timeStamp = moment().format().slice(0, 19).replace('T', ' ');
+    timeList.push(`${timeStamp}`);
+    if (title) this.#title = title;
+    allureMocha.allure.logStep(`${timeStamp} ${step}`);
+    if (!JSONLoader.configData.parallel) {
+      const stream = createWriteStream(filePath, { flags: 'a', autoClose: true });
+      if (!title) stream.write(`${timeStamp} ${step}\n`);
+      this.hideLogBodies(step);
+    }
+  }
+
+  static hideLogBodies(step) {
+    if (JSONLoader.configData.hiddenLogBodies && step.includes('[req]')) {
+      const words = step.split(' ');
+      const firstPart = words.slice(0, 3).join(' ');
+      const secondPart = words.slice(words.length - 2).join(' ');
+      console.log(`  ${firstPart} ${secondPart}`); // eslint-disable-line no-console
+    } else {
+      console.log(`  ${step}`); // eslint-disable-line no-console
+    }
+  }
+
+  static logParallel() {
+    logList.forEach((step) => this.hideLogBodies(step.trim()));
+  }
+
+  static logToFileParallel() {
+    const zip = (a, b) => a.map((k, i) => [k, b[i]]);
+    const summaryList = zip(timeList, logList);
+    summaryList.shift();
+    const fileName = filePath.split('/')
+      .map((part, index, array) => (index === array.length - 1 ? `${this.#title}.${part}` : part))
+      .join('/');
+    const stream = createWriteStream(fileName, { flags: 'a', autoClose: true });
+    summaryList.forEach((logString) => logString.forEach((logSubString, index) => {
+      /* eslint no-unused-expressions: ["error", { "allowTernary": true }] */
+      index % 2 !== 0 ? stream.write(`${logSubString}\n`) : stream.write(`${logSubString}`);
+    }));
+  }
+}
+
+module.exports = Logger;

package/src/random/randomizer.js

@@ -0,0 +1,83 @@
+class Randomizer {
+  static getRandomString(
+    hasLowerCase = false,
+    hasUpperCase = false,
+    hasNumber = false,
+    hasCyrillic = false,
+    chosenLetter = false,
+    minLength = 1,
+    maxLength = 10,
+  ) {
+    const upperCaseLetters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const lowerCaseLetters = 'abcdefghijklmnopqrstuvwxyz';
+    const numbers = '0123456789';
+    const cyrillicLetters = 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя';
+
+    const length = this.getRandomInteger(maxLength, minLength);
+
+    let randomString = '';
+    if (chosenLetter) randomString += chosenLetter;
+
+    let requiredCharacters = '';
+    if (hasLowerCase) {
+      requiredCharacters
+        += lowerCaseLetters.charAt(Math.floor(Math.random() * lowerCaseLetters.length));
+    }
+
+    if (hasUpperCase) {
+      requiredCharacters
+        += upperCaseLetters.charAt(Math.floor(Math.random() * upperCaseLetters.length));
+    }
+
+    if (hasNumber) {
+      requiredCharacters
+        += numbers.charAt(Math.floor(Math.random() * numbers.length));
+    }
+
+    if (hasCyrillic) {
+      requiredCharacters
+        += cyrillicLetters.charAt(Math.floor(Math.random() * cyrillicLetters.length));
+    }
+
+    randomString += requiredCharacters;
+
+    const characters = (hasLowerCase ? lowerCaseLetters : '')
+      + (hasUpperCase ? upperCaseLetters : '')
+      + (hasNumber ? numbers : '')
+      + (hasCyrillic ? cyrillicLetters : '');
+    const charactersLength = characters.length;
+    const randomLength = length - randomString.length;
+
+    for (let i = 0; i < randomLength; i += 1) {
+      randomString += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+
+    return this.stringShuffler(randomString);
+  }
+
+  static stringShuffler(inputString) {
+    const array = inputString.split('');
+    let currentIndex = array.length;
+    let temporaryValue;
+    let randomIndex;
+    while (currentIndex !== 0) {
+      randomIndex = Math.floor(Math.random() * currentIndex);
+      currentIndex -= 1;
+      temporaryValue = array[currentIndex];
+      array[currentIndex] = array[randomIndex];
+      array[randomIndex] = temporaryValue;
+    }
+
+    return array.join('');
+  }
+
+  static getRandomInteger(max = 9, min = 0) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+
+  static getRandomArrayElement(array) {
+    return array[Randomizer.getRandomInteger(array.length - 1)];
+  }
+}
+
+module.exports = Randomizer;

package/src/time/timeUtils.js

@@ -0,0 +1,58 @@
+const moment = require('moment');
+const JSONLoader = require('../data/JSONLoader');
+
+class TimeUtils {
+  static getDatesInterval(count, unitOfTime, options = {}) {
+    const { dateBegin } = options;
+    const startNextDay = options.startNextDay ?? true;
+    const isNotIncluded = options.isNotIncluded ?? true;
+    const reverseInterval = options.reverseInterval ?? false;
+
+    let startDate;
+    if (reverseInterval) {
+      startDate = startNextDay ? moment().subtract(1, 'days') : moment();
+    } else {
+      startDate = startNextDay ? moment().add(1, 'days') : moment();
+    }
+
+    let finishDate;
+    if (reverseInterval) {
+      finishDate = dateBegin
+        ? moment(dateBegin, JSONLoader.testData.datesFormatDMY).subtract(count, unitOfTime)
+        : moment(startDate).subtract(count, unitOfTime);
+      if (isNotIncluded) {
+        finishDate = moment(finishDate).add(1, 'days');
+      }
+    } else {
+      finishDate = dateBegin
+        ? moment(dateBegin, JSONLoader.testData.datesFormatDMY).add(count, unitOfTime)
+        : moment(startDate).add(count, unitOfTime);
+      if (isNotIncluded) {
+        finishDate = moment(finishDate).subtract(1, 'days');
+      }
+    }
+
+    startDate = moment(startDate).format(JSONLoader.testData.datesFormatDMY);
+    finishDate = moment(finishDate).format(JSONLoader.testData.datesFormatDMY);
+    return reverseInterval
+      ? { startDate: finishDate, finishDate: dateBegin ?? startDate }
+      : { startDate: dateBegin ?? startDate, finishDate };
+  }
+
+  static reformatDateFromYMDToDMY(date) {
+    return moment(date, JSONLoader.testData.datesFormatYMD)
+      .format(JSONLoader.testData.datesFormatDMY);
+  }
+
+  static reformatDateFromDMYToYMD(date) {
+    return moment(date, JSONLoader.testData.datesFormatDMY)
+      .format(JSONLoader.testData.datesFormatYMD);
+  }
+
+  static reformatDateFromDMYToYMDHms(date) {
+    return moment(date, JSONLoader.testData.datesFormatDMY)
+      .format(JSONLoader.testData.datesFormatYMDHms);
+  }
+}
+
+module.exports = TimeUtils;