@amanat-qa/utils-frontend 1.0.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@amanat-qa/utils-frontend",
+  "version": "1.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs",
+  "files": [
+    "src"
+  ],
+  "keywords": [],
+  "license": "MIT",
+  "exports": {
+    ".": "./src/index.js",
+    "./baseAPI": "./src/API/baseAPI.js",
+    "./baseDB": "./src/DB/baseDB.js",
+    "./JSONLoader": "./src/data/JSONLoader.js",
+    "./dataUtils": "./src/data/dataUtils.js",
+    "./filesParser": "./src/data/filesParser.js",
+    "./gitlabCIGenerator": "./src/data/gitlabCIGenerator.js",
+    "./index": "./src/index.js",
+    "./logger": "./src/log/logger.js",
+    "./randomizer": "./src/random/randomizer.js",
+    "./strUtils": "./src/str/strUtils.js",
+    "./timeUtils": "./src/time/timeUtils.js"
+  },
+  "dependencies": {
+    "axios": "*",
+    "mysql2": "*",
+    "moment": "*",
+    "xml2js": "*",
+    "fs": "*",
+    "path": "*",
+    "dotenv": "*",
+    "js-yaml": "*"
+  }
+}

package/src/API/baseAPI.js

@@ -0,0 +1,76 @@
+const axios = require('axios');
+
+class BaseAPI {
+  #baseURL;
+
+  #logString;
+
+  #timeout;
+
+  #headers;
+
+  #logBaseURL;
+
+  #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) this.#logBaseURL = `${this.#logString} ${this.#baseURL}`;
+    return axios.create({
+      baseURL: this.#baseURL,
+      timeout: this.#timeout,
+      headers: this.#headers,
+    });
+  }
+
+  async get(endpoint, params) {
+    const logs = [`[req] ▶ get ${JSON.stringify(params || {})} from ${endpoint}:`];
+    if (this.#logBaseURL) logs.unshift(this.#logBaseURL);
+    try {
+      const response = await this.#axiosInstance.get(`/${endpoint}`, { params });
+      logs.push(`[res]   status code: ${response.status}`);
+      return { data: response.data, status: response.status, logs };
+    } catch (error) {
+      logs.push(`[res]   status code: ${error.response.status}`);
+      logs.push(`[res]   body: ${JSON.stringify(error.response.data)}`);
+      return { data: error.response.data, status: error.response.status, logs };
+    }
+  }
+
+  async post(endpoint, params) {
+    const logs = [`[req] ▶ post ${JSON.stringify(params || {})} to ${endpoint}:`];
+    if (this.#logBaseURL) logs.unshift(this.#logBaseURL);
+    try {
+      const response = await this.#axiosInstance.post(`/${endpoint}`, params);
+      logs.push(`[res]   status code: ${response.status}`);
+      return { data: response.data, status: response.status, logs };
+    } catch (error) {
+      logs.push(`[res]   status code: ${error.response.status}`);
+      logs.push(`[res]   body: ${JSON.stringify(error.response.data)}`);
+      return { data: error.response.data, status: error.response.status, logs };
+    }
+  }
+
+  async patch(endpoint, params) {
+    const logs = [`[req] ▶ patch ${JSON.stringify(params || {})} to ${endpoint}:`];
+    if (this.#logBaseURL) logs.unshift(this.#logBaseURL);
+    try {
+      const response = await this.#axiosInstance.patch(`/${endpoint}`, params);
+      logs.push(`[res]   status code: ${response.status}`);
+      return { data: response.data, status: response.status, logs };
+    } catch (error) {
+      logs.push(`[res]   status code: ${error.response.status}`);
+      logs.push(`[res]   body: ${JSON.stringify(error.response.data)}`);
+      return { data: error.response.data, status: error.response.status, logs };
+    }
+  }
+}
+
+module.exports = BaseAPI;

package/src/DB/baseDB.js

@@ -0,0 +1,62 @@
+const mysql = require('mysql2/promise');
+
+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() {
+    const logs = [`[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,
+    });
+    return { logs };
+  }
+
+  async closeConnection() {
+    const logs = [`[inf] ▶ close connection to ${this.#database} database`];
+    await this.#connection.end();
+    return { logs };
+  }
+
+  async sqlQuery(query, values) {
+    const [rows] = await this.#connection.query(query, values);
+    return rows;
+  }
+
+  async sqlSelect(
+    tableName,
+    target = '*',
+    conditions = '',
+    values = [],
+    options = { hasLogger: true },
+  ) {
+    const logs = [];
+    if (options.hasLogger) logs.push(`[inf] ▶ select ${target} from ${tableName} table`);
+    const query = `SELECT ${target} FROM ${tableName} ${conditions};`;
+    const rows = await this.sqlQuery(query, values);
+    return { rows, logs };
+  }
+}
+
+module.exports = BaseDB;

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/dataUtils.js

@@ -0,0 +1,317 @@
+const moment = require('moment');
+const { parseStringPromise } = require('xml2js');
+const JSONLoader = require('./JSONLoader');
+const StrUtils = require('../str/strUtils');
+const TimeUtils = require('../time/timeUtils');
+const Randomizer = require('../random/randomizer');
+
+class DataUtils {
+  static async XMLToJSON(xml) {
+    return (await parseStringPromise(xml)).response;
+  }
+
+  static getFromRequests(url1, alias1, url2, alias2) {
+    cy.intercept(url1).as(alias1);
+    cy.intercept(url2).as(alias2);
+    return cy.wait([`@${alias1}`, `@${alias2}`]).then(([interception1, interception2]) => [interception1.response.body, interception2.response.body]);
+  }
+
+  static interceptPolicyList({
+    url,
+    sortColumn,
+    sortValue,
+    searchColumn,
+    searchValue,
+    page,
+    perPage,
+    alias,
+    raw = false,
+  } = {}) {
+    if (raw) {
+      cy.intercept('GET', url).as(alias);
+      return;
+    }
+
+    const query = {};
+
+    if (sortColumn) query['sort[column]'] = sortColumn;
+    if (sortValue) query['sort[value]'] = sortValue;
+
+    if (searchColumn && searchValue) {
+      query['search[column]'] = searchColumn;
+      query['search[value]'] = searchValue;
+    }
+
+    if (page) query.page = String(page);
+    if (perPage) query.per_page = String(perPage);
+
+    cy.intercept({
+      method: 'GET',
+      url,
+      query,
+    }).as(alias);
+  }
+
+  static extractDataArray(interception) {
+    return interception.response.body.data || [];
+  }
+
+  static isSorted(arr, order = 'asc') {
+    const sorted = [...arr].sort((a, b) => (order === 'asc' ? a - b : b - a));
+    return JSON.stringify(arr) === JSON.stringify(sorted);
+  }
+
+  static waitForPolicyList(alias, path) {
+    return cy.wait(`@${alias}`).then((interception) => {
+      const parts = ['response', 'body', ...path.split('.')];
+      const result = parts.reduce((acc, key) => (acc && typeof acc === 'object' ? acc[key] : {}), interception);
+      return result;
+    });
+  }
+
+  static getFromRequest(url, alias) {
+    cy.intercept(url).as(alias);
+    return cy.wait(`@${alias}`).then((interception) => interception.response.body);
+  }
+
+  /**
+   * requires one mandatory argument: clients.
+   * options contain optional parameters:
+   * residency,
+   * type of document being passport,
+   * having driver license
+   * and being under 60 years old:
+   * @param {string[]} clients
+   * @param {Object} options
+   * @param {boolean} options.isResident
+   * @param {boolean} options.hasPassport
+   * @param {boolean} options.hasDriverLicence
+   * @param {boolean} options.isUnderSixtyYearsOld
+   */
+  static filterClients(clients, options = {}) {
+    const { isResident } = options;
+    const { hasPassport } = options;
+    const { hasDriverLicence } = options;
+    const { isUnderSixtyYearsOld } = options;
+    const { isJuridical } = 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) {
+        const hasLetter = /[a-zA-Z]/.test(client.document_number);
+        return hasPassport
+          ? client.document_type_id === 11 && hasLetter
+          : client.document_type_id !== 11;
+      }
+
+      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;
+    });
+
+    filteredClients = filteredClients.filter((client) => {
+      if (isJuridical !== undefined) {
+        return isJuridical ? !client.natural_person_bool : client.natural_person_bool;
+      }
+
+      return true;
+    });
+
+    return filteredClients;
+  }
+
+  static createRandomCarStructure(carsArr) {
+    const randomCarIndex = Randomizer.getRandomInteger(carsArr.length - 1);
+    const tempCar = carsArr[randomCarIndex];
+    const resultCar = { ...tempCar };
+
+    resultCar.dt_reg_cert = {};
+    resultCar.dt_reg_cert.YMD = tempCar.dt_reg_cert;
+    resultCar.dt_reg_cert.DMY = TimeUtils.reformatDateFromYMDToDMY(tempCar.dt_reg_cert);
+
+    resultCar.year = tempCar.year.toString();
+    resultCar.engine_volume = tempCar.engine_volume.toString();
+
+    resultCar.model = {};
+    resultCar.model.OGPO = tempCar.model;
+    resultCar.model.KASKO = {};
+    resultCar.model.KASKO.get = tempCar.model;
+    resultCar.model.KASKO.set = tempCar.id !== 1
+      ? StrUtils.toTitleCase(tempCar.model)
+      : '5 серия';
+
+    resultCar.mark = {};
+    resultCar.mark.OGPO = tempCar.mark;
+    resultCar.mark.KASKO = {};
+    resultCar.mark.KASKO.get = tempCar.mark;
+    resultCar.mark.KASKO.set = tempCar.id !== 1 ? StrUtils.toTitleCase(tempCar.mark) : tempCar.mark;
+
+    resultCar.region_id = JSONLoader.testData.carRegion;
+    resultCar.type_id = JSONLoader.testData.carType;
+
+    return resultCar;
+  }
+
+  static createRandomClientsStructures(clientsArr) {
+    let randomHolderIndex = 0;
+    let randomInsuredIndex = 0;
+    let randomBeneficiaryIndex = 0;
+
+    if (clientsArr.length > 1) {
+      randomHolderIndex = Randomizer.getRandomInteger(clientsArr.length - 1);
+
+      do {
+        randomInsuredIndex = Randomizer.getRandomInteger(clientsArr.length - 1);
+      } while (randomInsuredIndex === randomHolderIndex);
+
+      do {
+        randomBeneficiaryIndex = Randomizer.getRandomInteger(clientsArr.length - 1);
+      } while (randomBeneficiaryIndex === randomHolderIndex
+      || randomBeneficiaryIndex === randomInsuredIndex);
+    }
+
+    const tempHolder = clientsArr[randomHolderIndex];
+    const tempInsured = clientsArr[randomInsuredIndex];
+    const tempBeneficiary = clientsArr[randomBeneficiaryIndex];
+
+    const resultHolder = { ...tempHolder };
+    const resultInsured = { ...tempInsured };
+    const resultBeneficiary = { ...tempBeneficiary };
+
+    resultHolder.document_gived_date = {};
+    resultHolder.document_gived_date.YMD = tempHolder.document_gived_date;
+    resultHolder.document_gived_date.DMY = TimeUtils
+      .reformatDateFromYMDToDMY(tempHolder.document_gived_date);
+    resultHolder.born = {};
+    resultHolder.born.YMD = tempHolder.born;
+    resultHolder.born.DMY = TimeUtils.reformatDateFromYMDToDMY(tempHolder.born);
+    resultHolder.date_issue_license = {};
+    resultHolder.date_issue_license.YMD = tempHolder.date_issue_license;
+    resultHolder.date_issue_license.DMY = TimeUtils
+      .reformatDateFromYMDToDMY(tempHolder.date_issue_license);
+
+    resultHolder.iin = tempHolder.iin.toString();
+    resultHolder.document_type = JSONLoader
+      .dictDocumentType[tempHolder.document_type_id.toString()];
+
+    resultHolder.sex = JSONLoader.dictSexID[tempHolder.sex_id];
+    resultHolder.address = JSONLoader.testData.holderAddress;
+    resultHolder.email = JSONLoader.testData.holderEmail;
+    resultHolder.document_gived_by = JSONLoader.testData.holderDocumentGivedBy;
+    resultHolder.document_gived_by_quote = JSONLoader.testData.holderDocumentGivedByQuote;
+    resultHolder.pdl = JSONLoader.testData.holderIsPDL;
+    resultHolder.driver_certificate_type_id = JSONLoader.testData.holderDriverLicenceType;
+    resultHolder.invalid_bool = JSONLoader.testData.holderIsInvalid;
+    resultHolder.pensioner_bool = JSONLoader.testData.holderIsPensioner;
+    resultHolder.country = JSONLoader.testData.holderCountry;
+    resultHolder.region = JSONLoader.testData.holderRegion;
+    resultHolder.phone = JSONLoader.testData.holderPhone;
+    resultHolder.phoneTrimmed = JSONLoader.testData.holderPhoneTrimmed;
+    resultHolder.phoneFormatted = JSONLoader.testData.holderPhoneFormatted;
+
+    resultInsured.document_gived_date = {};
+    resultInsured.document_gived_date.YMD = tempInsured.document_gived_date;
+    resultInsured.document_gived_date.DMY = TimeUtils
+      .reformatDateFromYMDToDMY(tempInsured.document_gived_date);
+    resultInsured.born = {};
+    resultInsured.born.YMD = tempInsured.born;
+    resultInsured.born.DMY = TimeUtils.reformatDateFromYMDToDMY(tempInsured.born);
+    resultInsured.date_issue_license = {};
+    resultInsured.date_issue_license.YMD = tempInsured.date_issue_license;
+    resultInsured.date_issue_license.DMY = TimeUtils
+      .reformatDateFromYMDToDMY(tempInsured.date_issue_license);
+
+    resultInsured.iin = tempInsured.iin.toString();
+    resultInsured.document_type = JSONLoader
+      .dictDocumentType[tempInsured.document_type_id.toString()];
+
+    resultInsured.sex = JSONLoader.dictSexID[tempInsured.sex_id];
+    resultInsured.address = JSONLoader.testData.insuredAddress;
+    resultInsured.email = JSONLoader.testData.insuredEmail;
+    resultInsured.document_gived_by = JSONLoader.testData.insuredDocumentGivedBy;
+    resultInsured.pdl = JSONLoader.testData.insuredIsPDL;
+    resultInsured.driver_certificate_type_id = JSONLoader.testData.insuredDriverLicenceType;
+    resultInsured.invalid_bool = JSONLoader.testData.insuredIsInvalid;
+    resultInsured.pensioner_bool = JSONLoader.testData.insuredIsPensioner;
+
+    resultBeneficiary.document_gived_date = {};
+    resultBeneficiary.document_gived_date.YMD = tempBeneficiary.document_gived_date;
+    resultBeneficiary.document_gived_date.DMY = TimeUtils
+      .reformatDateFromYMDToDMY(tempBeneficiary.document_gived_date);
+    resultBeneficiary.born = {};
+    resultBeneficiary.born.YMD = tempBeneficiary.born;
+    resultBeneficiary.born.DMY = TimeUtils.reformatDateFromYMDToDMY(tempBeneficiary.born);
+    resultBeneficiary.date_issue_license = {};
+    resultBeneficiary.date_issue_license.YMD = tempBeneficiary.date_issue_license;
+    resultBeneficiary.date_issue_license.DMY = TimeUtils
+      .reformatDateFromYMDToDMY(tempBeneficiary.date_issue_license);
+
+    resultBeneficiary.iin = tempBeneficiary.iin.toString();
+    resultBeneficiary.document_type = JSONLoader
+      .dictDocumentType[tempBeneficiary.document_type_id.toString()];
+    resultBeneficiary.sex = JSONLoader.dictSexID[tempBeneficiary.sex_id];
+    resultBeneficiary.address = JSONLoader.testData.beneficiaryAddress;
+    resultBeneficiary.email = JSONLoader.testData.beneficiaryEmail;
+    resultBeneficiary.document_gived_by = JSONLoader.testData.beneficiaryDocumentGivedBy;
+    resultBeneficiary.document_gived_by_quote = JSONLoader.testData.beneficiaryDocumentGivedByQuote;
+    resultBeneficiary.pdl = JSONLoader.testData.beneficiaryIsPDL;
+    resultBeneficiary.driver_certificate_type_id = JSONLoader.testData.beneficiaryDriverLicenceType;
+    resultBeneficiary.invalid_bool = JSONLoader.testData.beneficiaryIsInvalid;
+    resultBeneficiary.pensioner_bool = JSONLoader.testData.beneficiaryIsPensioner;
+
+    return { holder: resultHolder, insured: resultInsured, beneficiary: resultBeneficiary };
+  }
+
+  static prepareSetClientRequestBody(getClientResponse, client) {
+    const requestBody = { ...getClientResponse.data.data };
+    requestBody.first_name = client.first_name;
+    requestBody.middle_name = client.middle_name;
+    requestBody.last_name = client.last_name;
+    requestBody.first_name_eng = client.first_name_eng;
+    requestBody.last_name_eng = client.last_name_eng;
+    requestBody.natural_person_bool = client.natural_person_bool;
+    requestBody.sex_id = client.sex_id;
+    requestBody.born = requestBody.natural_person_bool ? client.born.DMY : null;
+    requestBody.resident_bool = client.resident_bool;
+    requestBody.document_number = client.document_number;
+    requestBody.document_gived_date = client.document_gived_date.DMY;
+    requestBody.document_type_id = client.document_type_id;
+    requestBody.verify_bool = requestBody.natural_person_bool
+      ? Number(JSONLoader.configData.verification) : 0;
+    requestBody.verify_type_id = requestBody.verify_bool ? 1 : 3;
+    requestBody.activity_kind_id = requestBody.natural_person_bool
+      ? 250 : client.activity_kind_id;
+    requestBody.economics_sector_id = requestBody.natural_person_bool
+      ? 10 : client.economics_sector_id;
+    requestBody.juridical_person_name = requestBody.natural_person_bool
+      ? '' : client.juridical_person_name;
+
+    return requestBody;
+  }
+}
+
+module.exports = DataUtils;

package/src/data/filesParser.js

@@ -0,0 +1,107 @@
+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 JSONDirectory = path.join(envDirectory, './test/resources');
+const suitesDirectory = path.join(envDirectory, './test/tests/suites');
+const jsonExtension = '.json';
+const testExtension = '.test';
+const testSuitePattern = 'Suite.js';
+
+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 generateTestSuitesNames = (selectedFiles) => {
+  const suiteNames = selectedFiles
+    .map((file) => file.replace(testSuitePattern, ''))
+    .map((name) => `'${name}'`)
+    .join(', ');
+  return `\tstatic get testSuitesNames() {\n\t\treturn [${suiteNames}];\n\t}\n\n`;
+};
+
+const generateJSONLoader = (filePath, directory) => {
+  const jsonFiles = getFiles(directory, jsonExtension);
+  const testSuites = getFiles(suitesDirectory, testSuitePattern);
+  const classInit = generateClassInit(jsonFiles, directory);
+  const suitesNames = generateTestSuitesNames(testSuites);
+  const classExport = '}\n\nmodule.exports = JSONLoader;';
+  fs.writeFileSync(filePath, classInit + suitesNames + 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');
+    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!');
+    }
+
+    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, testExtension);
+setConfigData(JSONDirectory, jsonExtension);
+generateTestDataFile(testCarsFileLocation);
+generateTestDataFile(testClientsFileLocation);
+generateJSONLoader(loaderFileLocation, JSONDirectory);

package/src/data/gitlabCIGenerator.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const path = require('path');
+const YAML = require('js-yaml');
+const JSONLoader = require('./JSONLoader');
+
+const testSuites = JSONLoader.testSuitesNames;
+const jobs = testSuites.map((suite) => ({
+  [`e2e tests ${suite}`]: {
+    image: 'lines14/cypress-java-dind:latest',
+    stage: 'test',
+    variables: {
+      DOCKER_HOST: 'tcp://docker:2375',
+      DOCKER_TLS_CERTDIR: '',
+      DOCKER_DRIVER: 'overlay2',
+      DOCKER_DAEMON_TIMEOUT: 600,
+    },
+    only: [
+      'dev',
+    ],
+    services: [
+      {
+        name: 'docker:dind',
+        command: ['--tls=false', '--host=tcp://0.0.0.0:2375'],
+      },
+    ],
+    needs: [],
+    tags: [
+      'k8s',
+    ],
+    before_script: [
+      // eslint-disable-next-line no-template-curly-in-string
+      'echo "${ADP_NUXT_TEST}" | tr -d \'\\r\' > ./.env.test',
+      'docker login --username $USER --password $PASS registry.gitlab.com',
+      'service docker start',
+      'npm ci --prefix ./cypress',
+      'npm run lint --prefix ./cypress',
+    ],
+    script: [
+      'npm run start:ci --prefix ./cypress',
+      `file=${suite} npm run test --prefix ./cypress`,
+    ],
+    artifacts: {
+      when: 'always',
+      expire_in: '1 month',
+      paths: [
+        'cypress/artifacts',
+        'cypress/screenshots',
+        'cypress/videos',
+        'cypress/resources/data/configData.json',
+        'cypress/resources/data/testClients.json',
+        'cypress/resources/data/testCars.json',
+      ],
+    },
+  },
+}));
+
+const gitlabCIConfig = Object.assign({}, ...jobs);
+
+fs.writeFileSync(
+  path.join(__dirname, '..', '..', '..', '..', '.split-config.yml'),
+  YAML.dump(gitlabCIConfig),
+);

package/src/index.js

@@ -0,0 +1,13 @@
+// Auto-generated file
+
+exports.baseAPI = require('./API/baseAPI');
+exports.baseDB = require('./DB/baseDB');
+exports.JSONLoader = require('./data/JSONLoader');
+exports.dataUtils = require('./data/dataUtils');
+exports.filesParser = require('./data/filesParser');
+exports.gitlabCIGenerator = require('./data/gitlabCIGenerator');
+exports.index = require('./index');
+exports.logger = require('./log/logger');
+exports.randomizer = require('./random/randomizer');
+exports.strUtils = require('./str/strUtils');
+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 JSONLoader = require('../data/JSONLoader');
+
+const filePath = path.join(path.resolve(), '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;
+    if (!JSONLoader.configData.parallel) {
+      const stream = createWriteStream(filePath, { flags: 'a', autoClose: true });
+      if (!title) stream.write(`${timeStamp} ${step}\n`);
+      this.hideLogBodies(step);
+    }
+
+    return timeStamp;
+  }
+
+  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,148 @@
+const moment = require('moment');
+const JSONLoader = require('../data/JSONLoader');
+
+class Randomizer {
+  static getRandomDatesIntervalFromTomorrow(count, unitOfTime) {
+    const nextDayObject = moment().add(1, 'days').startOf('day');
+    const unixOne = nextDayObject.unix();
+    const unixTwo = moment(moment().add(1, 'days').startOf('day')).add(count, unitOfTime).unix();
+
+    const startDateUnix = moment.unix(this.getRandomFloat(unixOne, unixTwo)).unix();
+    let finishDateUnix;
+    do {
+      finishDateUnix = moment.unix(this.getRandomFloat(startDateUnix, unixTwo)).unix();
+    } while ((finishDateUnix - startDateUnix) < 86400 * 2);
+
+    const startDateObject = moment.unix(startDateUnix).startOf('day');
+    const finishDateObject = moment.unix(finishDateUnix).startOf('day');
+    const startDate = startDateObject.format(JSONLoader.testData.datesFormatDMY);
+    const finishDate = finishDateObject.format(JSONLoader.testData.datesFormatDMY);
+
+    const daysDifferenceIncluded = finishDateObject.diff(startDateObject, 'days') + 1;
+
+    const getAbsoluteMonth = (date) => {
+      const months = Number(moment(date, JSONLoader.testData.datesFormatDMY).format('MM'));
+      const years = Number(moment(date, JSONLoader.testData.datesFormatDMY).format('YYYY'));
+      return months + (years * 12);
+    };
+
+    const currentMonth = getAbsoluteMonth(moment.unix(unixOne)
+      .format(JSONLoader.testData.datesFormatDMY));
+    const startMonth = getAbsoluteMonth(startDate);
+    const finishMonth = getAbsoluteMonth(finishDate);
+    let startMonthDifference = startMonth - currentMonth;
+    let finishMonthDifference = finishMonth - currentMonth;
+
+    if (nextDayObject.date() === 1) startMonthDifference += 1;
+    if (nextDayObject.date() === 1) finishMonthDifference += 1;
+
+    return {
+      startDate,
+      finishDate,
+      startMonthDifference,
+      finishMonthDifference,
+      daysDifferenceIncluded,
+    };
+  }
+
+  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 getRandomFloat(min, max) {
+    return Math.random() * (max - min) + min;
+  }
+
+  static getRandomElementByText(baseElements, exceptionsList = []) {
+    const exceptions = exceptionsList ?? [];
+    const baseElementsList = baseElements.slice(0, baseElements.length);
+    let element;
+    if (exceptions.length > 0) {
+      while (true) { // eslint-disable-line no-constant-condition
+        element = baseElementsList[Math.floor(Math.random() * baseElementsList.length)];
+        if (!exceptions.includes(element) && (element !== '')) break;
+      }
+    } else {
+      while (true) { // eslint-disable-line no-constant-condition
+        element = baseElementsList[Math.floor(Math.random() * baseElementsList.length)];
+        if (element !== '') break;
+      }
+    }
+
+    return element;
+  }
+}
+
+module.exports = Randomizer;

package/src/str/strUtils.js

@@ -0,0 +1,14 @@
+class StrUtils {
+  static toTitleCase(str) {
+    return str.replace(
+      /\w\S*/g,
+      (txt) => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase(),
+    );
+  }
+
+  static removeAllNonNumbersFromString(str) {
+    return str.replace(/\D/g, '');
+  }
+}
+
+module.exports = StrUtils;

package/src/time/timeUtils.js

@@ -0,0 +1,53 @@
+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);
+  }
+}
+
+module.exports = TimeUtils;