@testomatio/reporter 1.1.0-beta-2 → 1.2.0-beta-1

package/lib/{storages/data-storage.js → dataStorage.js}

@@ -3,18 +3,16 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { join } = require('path');
-const { TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
-const { fileSystem, jestHelpers, parseTest } = require('../utils/utils');
-
-const getTestIdFromTestTitle = parseTest;
+const JestReporter = require('./adapter/jest');
+const { TESTOMAT_TMP_STORAGE } = require('./constants');
+const { fileSystem } = require('./utils/utils');
+const getTestIdFromTestTitle = require('./utils/utils').parseTest;
 
 class DataStorage {
   /**
    * Creates data storage instance for specific data type.
    * Stores data to global variable or to file depending on what is applicable for current test runner
    * (running environment).
-   * Recommend to use composition while using this class (instead of inheritance).
-   * ! Also the class which will use data storage should be singleton (to avoid data loss).
    * @param {*} dataType storage type (like 'log', 'artifact'); could be any string, used only to define file path
    */
   constructor(dataType) {
@@ -22,35 +20,8 @@ class DataStorage {
     this.isFileStorage = true;
     this.#refreshStorageType();
 
-    this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE_DIR, this.dataType);
-
-    // set test title for mocha (could not be moved to adapter)
-    // it does not override existing hook, just add new one
-    try {
-      // @ts-ignore
-      if (!beforeEach) return;
-      // @ts-ignore-next-line
-      beforeEach(function () {
-        if (this.currentTest?.__mocha_id__) {
-          global.testTitle = this.currentTest.fullTitle();
-        }
-      });
-    } catch (e) {
-      // ignore
-    }
-
-    // set test title for playwright
-    try {
-      // eslint-disable-next-line import/no-extraneous-dependencies, import/no-unresolved
-      const { test } = require('@playwright/test');
-      // eslint-disable-next-line no-empty-pattern
-      test.beforeEach(async ({}, testInfo) => {
-        global.testTitle = testInfo.title;
-        global.testomatioRunningEnvironment = 'playwright';
-      });
-    } catch (e) {
-      // ignore
-    }
+    this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE.mainDir, this.dataType);
+    fileSystem.createDir(this.dataDirPath);
   }
 
   /**
@@ -73,18 +44,15 @@ class DataStorage {
   }
 
   /**
-   * Puts any data to storage (file or global variable).
-   * If file: stores data as text, if global variable – stores as array of data.
-   * @param {*} data anything you want to store (string, object, array, etc)
+   * Puts any data to storage (file or global variable)
+   * @param {*} data anything you want to store
    * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
    * @returns
    */
   putData(data, context = null) {
-    fileSystem.createDir(this.dataDirPath);
-
     this.#refreshStorageType();
-    context = context ?? global.testTitle ?? null;
-    let testId = this.#tryToRetrieveTestId(context) || context || null;
+
+    let testId = this.#tryToRetrieveTestId(context) || null;
 
     if (this.runningEnvironment === 'codeceptjs') {
       this.isFileStorage = false;
@@ -92,7 +60,7 @@ class DataStorage {
     }
 
     if (this.runningEnvironment === 'jest') {
-      testId = testId ?? jestHelpers.getIdOfCurrentlyRunningTest();
+      testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
     }
 
     // logs in playwright are gathered by pw framework itself
@@ -106,7 +74,7 @@ class DataStorage {
       testId = this.#tryToRetrieveTestId(global.currentlyRunningTestTitle);
 
     if (!testId) {
-      debug(`No test id provided for "${this.dataType}" data:`, data);
+      debug(`No test id provided for ${this.dataType} data: ${data}`);
       return;
     }
 
@@ -119,10 +87,12 @@ class DataStorage {
 
   /**
    * Returns data, stored for specific testId (or data which was stored without test id specified).
-   * This method will get data from global variable and/or from from file (previosly saved with put method).
+   * This method will get data from global variable. But if it is not available, it will try to get data from file.
+   * Thus, good approach is to remove file storage folder before each test run (and after, for sure).
    *
-   * @param {*} context could be testId or any context (test title, suite, etc) which is used to define testId
-   * @returns array of data (any type), null (if no data found for test) or string (if data type is log)
+   * Defining the execution environment is not guaranteed! Is used only as additional check.
+   * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
+   * @returns
    */
   getData(context) {
     this.#refreshStorageType();
@@ -130,6 +100,9 @@ class DataStorage {
     let testId = null;
     if (typeof context === 'string') {
       testId = this.#tryToRetrieveTestId(context) || context;
+    } else {
+      // TODO: derive testId from context
+      // testId = context...
     }
 
     if (!testId) {
@@ -137,20 +110,12 @@ class DataStorage {
       return null;
     }
 
-    let testDataFromFile = [];
-    let testDataFromGlobalVar = [];
+    let testData = '';
 
     if (global?.testomatioDataStore) {
-      testDataFromGlobalVar = this.#getDataFromGlobalVar(testId);
+      testData = this.#getDataFromGlobalVar(testId);
       // these frameworks use global variable storage
-      // if (testDataFromGlobalVar && ['cucumber', 'codeceptjs'].includes(this.runningEnvironment)) {
-      if (testDataFromGlobalVar) {
-        // return as string if its log data
-        if (this.dataType === 'log' && testDataFromGlobalVar.length) return testDataFromGlobalVar.join('\n');
-        // return as array for other data types
-        if (testDataFromGlobalVar.length) return testDataFromGlobalVar;
-      }
-      // don't return nothing if no data in global variable
+      if (testData && ['cucumber', 'codeceptjs'].includes(this.runningEnvironment)) return testData;
     }
 
     /* condition is removed for mocha
@@ -161,16 +126,11 @@ class DataStorage {
     //   if (testData) return testData;
     // }
 
-    testDataFromFile = this.#getDataFromFile(testId);
+    const testDataFromFile = this.#getDataFromFile(testId);
+    testData += testDataFromFile || '';
 
-    if (testDataFromFile.length) {
-      if (this.dataType === 'log') return testDataFromFile.join('\n');
-      return testDataFromFile;
-    }
-    debug(`No "${this.dataType}" data for test id ${testId} in both file and global variable`);
-
-    // in case no data found for test
-    return null;
+    debug(`No ${this.dataType} data for test id ${testId} in both file and global variable`);
+    return testData || '';
   }
 
   /**
@@ -206,63 +166,46 @@ class DataStorage {
     this.runningEnvironment = this.getRunningEnviroment();
 
     // some test frameworks do not persist global variables, thus file storage is used for them (by default)
-    if (this.runningEnvironment === 'codeceptjs') this.isFileStorage = false;
-    // playwrigth stores logs by itself; but file storage is used for other data types for playwright
-    if (this.runningEnvironment === 'playwright' && this.dataType === 'log') this.isFileStorage = false;
+    if (['playwright', 'codeceptjs'].includes(this.runningEnvironment)) this.isFileStorage = false;
   }
 
-  /**
-   * @param {*} testId
-   * @returns aray of data (any type)
-   */
   #getDataFromGlobalVar(testId) {
     try {
       if (global?.testomatioDataStore[this.dataType]) {
         const testData = global.testomatioDataStore[this.dataType][testId];
-        if (testData) debug(`"${this.dataType}" data for test id ${testId}:`, testData.join(', '));
-        return testData || [];
+        debug(`Data for test id ${testId}:\n${testData}`);
+        return testData || '';
       }
-      // debug(`No ${this.dataType} data for test id ${testId} in <global> storage`);
-      return [];
+      debug(`No ${this.dataType} data for test id ${testId} in <global> storage`);
+      return '';
     } catch (e) {
       // there could be no data, ignore
     }
   }
 
-  /**
-   *
-   * @param {*} testId
-   * @returns array of data (any type)
-   */
   #getDataFromFile(testId) {
     try {
       const filepath = join(this.dataDirPath, `${this.dataType}_${testId}`);
       if (fs.existsSync(filepath)) {
-        const testDataAsText = fs.readFileSync(filepath, 'utf-8');
-        if (testDataAsText) debug(`"${this.dataType}" data for test id ${testId}:`, testDataAsText);
-        const testDataArr = testDataAsText?.split(os.EOL) || [];
-        return testDataArr;
+        const testData = fs.readFileSync(filepath, 'utf-8');
+        debug(`Data for test id ${testId}:\n${testData}`);
+        return testData || '';
       }
-      // debug(`No ${this.dataType} data for test id ${testId} in <file> storage`);
-      return [];
+      debug(`No ${this.dataType} data for test id ${testId} in <file> storage`);
+      return '';
     } catch (e) {
       // there could be no data, ignore
     }
-    return [];
+    return '';
   }
 
-  /**
-   * Puts data to global variable. Unlike the file storage, stores data in array (file storage just append as string).
-   * @param {*} data
-   * @param {*} testId
-   */
   #putDataToGlobalVar(data, testId) {
-    debug(`Saving data to global variable for test ${testId}:`, data);
+    debug('Saving data to global variable for test', testId, ':\n', data, '\n');
     if (!global.testomatioDataStore) global.testomatioDataStore = {};
     if (!global.testomatioDataStore?.[this.dataType]) global.testomatioDataStore[this.dataType] = {};
-
-    if (!global.testomatioDataStore?.[this.dataType][testId]) global.testomatioDataStore[this.dataType][testId] = [];
-    global.testomatioDataStore[this.dataType][testId].push(data);
+    global.testomatioDataStore?.[this.dataType][testId] // eslint-disable-line no-unused-expressions
+      ? (global.testomatioDataStore[this.dataType][testId] += `\n${data}`)
+      : (global.testomatioDataStore[this.dataType][testId] = data);
   }
 
   #putDataToFile(data, testId) {
@@ -272,36 +215,18 @@ class DataStorage {
     if (!fs.existsSync(this.dataDirPath)) fileSystem.createDir(this.dataDirPath);
     debug('Saving data to file for test', testId, 'to', filepath, ':\n', data, '\n');
 
-    // append new line if file already exists (in this case its definitely includes some data)
-    if (fs.existsSync(filepath)) {
-      fs.appendFileSync(filepath, os.EOL + data, 'utf-8');
-    } else {
-      fs.writeFileSync(filepath, data, 'utf-8');
-    }
+    // TODO: handle multiple invocations of JSON.stringify.
+    // UPD: not actual because decided not to use it - it created extra wrapping quotes "" and // (escaped slashes)
+    fs.appendFileSync(filepath, data + os.EOL, 'utf-8');
   }
 }
 
-module.exports = DataStorage;
+module.exports.DataStorage = DataStorage;
 
 // TODO: consider using fs promises instead of writeSync/appendFileSync to
 // prevent blocking and improve performance (probably queue usage will be required)
 
 // TODO: rewrite client - everything regarding storing artifacts
 // TODO: try to define adapter inside client
+// TODO: use .env
 // TODO: ability to intercept multiple loggers (upd: no need)
-
-/* does not work for Playwright
-    try {
-      const { test } = require('@playwright/test');
-      test.beforeEach(async ({}, testInfo) => {
-        global.testTitle = testInfo.title;
-        global.testomatioRunningEnvironment = 'playwright';
-      });
-    } catch (e) {
-      // ignore
-    }
-// Playwright storage works fine only when running tests from a single file;
-// otherwise it is not possible to define test id/title, it is overwritten
- TODO: the only way implementation for Pw for now is to pass testInfo inside test
-//  (and process this testInfo inside "put" function)
-*/

package/lib/{storages/logger.js → logger.js}

@@ -1,6 +1,6 @@
 const chalk = require('chalk');
 const debug = require('debug')('@testomatio/reporter:logger');
-const DataStorage = require('./data-storage');
+const { DataStorage } = require('./dataStorage');
 
 const LOG_METHODS = ['assert', 'debug', 'error', 'info', 'log', 'trace', 'warn'];
 const LEVELS = {
@@ -38,6 +38,20 @@ class Logger {
     if (!Logger.instance) {
       Logger.instance = this;
     }
+
+    // add beforeEach hook for mocha. it does not override existing hook, just add new one
+    try {
+      // @ts-ignore
+      if (!beforeEach) return;
+      // @ts-ignore-next-line
+      beforeEach(function () {
+        if (this.currentTest?.__mocha_id__) {
+          global.testTitle = this.currentTest.fullTitle();
+        }
+      });
+    } catch (e) {
+      // ignore
+    }
   }
 
   /**
@@ -47,6 +61,9 @@ class Logger {
    * @param  {...any} values
    */
   step(strings, ...values) {
+    // get testId for mocha
+    const context = global.testTitle ?? null;
+
     let logs = '';
     for (let i = 0; i < strings.length; i++) {
       logs += strings[i];
@@ -55,7 +72,7 @@ class Logger {
       }
     }
     logs = chalk.blue(`> ${logs}`);
-    this.#dataStorage.putData(logs);
+    this.#dataStorage.putData(logs, context);
   }
 
   /**
@@ -100,6 +117,11 @@ class Logger {
   templateLiteralLog(strings, ...args) {
     if (Array.isArray(strings)) strings = strings.filter(item => item !== '').map(item => item.trim());
     if (Array.isArray(args)) args = args.filter(item => item !== '');
+    // entity which is used to define testId
+    let context = null;
+
+    // get testId for mocha
+    context = global.testTitle ?? null;
 
     let logs;
     // this block means tagged template is used (syntax like $`text ${someVar}`)
@@ -124,7 +146,7 @@ class Logger {
       logs = this.#stringifyLogs(strings, ...args);
     }
     this.#originalUserLogger.log(logs);
-    this.#dataStorage.putData(logs);
+    this.#dataStorage.putData(logs, context);
   }
 
   /**
@@ -136,12 +158,18 @@ class Logger {
   #logWrapper(argsArray, level) {
     if (!argsArray.length) return;
 
+    // entity which is used to define testId
+    let context = null;
+
+    // get context for mocha
+    context = global.testTitle ?? null;
+
     const severity = LEVELS[level].severity;
     if (severity < LEVELS[this.logLevel]?.severity) return;
 
     const logs = this.#stringifyLogs(...argsArray);
     const colorizedLogs = chalk[LEVELS[level].color](logs);
-    this.#dataStorage.putData(colorizedLogs);
+    this.#dataStorage.putData(colorizedLogs, context);
     try {
       // level.toLowerCase() represents method name (log, warn, error, etc)
       this.#originalUserLogger[level.toLowerCase()](colorizedLogs);
@@ -241,6 +269,7 @@ class Logger {
 
 Logger.instance = null;
 
+// module.exports.Logger = Logger;
 const logger = new Logger();
 
 module.exports = logger;

package/lib/pipe/html.js

@@ -0,0 +1,187 @@
+const debug = require('debug')('@testomatio/reporter:pipe:html');
+const merge = require('lodash.merge');
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const handlebars = require('handlebars');
+
+const { fileSystem, isSameTest } = require('../utils/utils');
+const { HTML_REPORT } = require('../constants');
+
+class HtmlPipe {
+    constructor(params, store = {}) {
+        this.store = store || {};
+        this.title = params.title || process.env.TESTOMATIO_TITLE;
+        this.apiKey = params.apiKey || process.env.TESTOMATIO;
+        this.isHtml = process.env.TESTOMATIO_HTML_REPORT_SAVE;
+        this.data = {};
+
+        debug('HTML Pipe: ', this.apiKey ? 'API KEY' : '*no api key*');
+        if (!this.apiKey) {
+            return;
+        }
+
+        this.isEnabled = false;
+        this.htmlOutputPath = "";
+        this.tests = [];
+        this.data = {};
+
+        if (this.isHtml) {
+            this.isEnabled = true;
+            this.htmlReportDir = process.env.TESTOMATIO_HTML_REPORT_FOLDER || HTML_REPORT.FOLDER;
+
+            if (process.env.TESTOMATIO_HTML_FILENAME && process.env.TESTOMATIO_HTML_FILENAME.endsWith(".html")) {
+                this.htmlReportName = process.env.TESTOMATIO_HTML_FILENAME
+            }
+
+            if (process.env.TESTOMATIO_HTML_FILENAME && !process.env.TESTOMATIO_HTML_FILENAME.endsWith(".html")) {
+                console.log(
+                    chalk.blue(`The name must include the extension ".html". The default report name is used!`)
+                );
+                this.htmlReportName = HTML_REPORT.REPORT_DEFAULT_NAME;
+            }
+
+            if (!process.env.TESTOMATIO_HTML_FILENAME) {
+                this.htmlReportName = HTML_REPORT.REPORT_DEFAULT_NAME;
+            }
+
+            this.templateFolderPath = path.resolve(__dirname, '..', 'template');
+            this.templateHtmlPath = path.resolve(this.templateFolderPath, HTML_REPORT.TEMPLATE_NAME);
+            this.htmlOutputPath = path.join(this.htmlReportDir, this.htmlReportName);
+            // create a new folder for the HTML reports
+            fileSystem.createDir(this.htmlReportDir);
+
+            debug(
+                chalk.yellow('HTML Pipe:'),
+                `Save HTML report: ${this.isEnabled}`,
+                `HTML report folder: ${this.htmlReportDir}, report name: ${this.htmlReportName}`
+            );
+        }
+    }
+
+    async createRun() {
+        // empty
+    }
+
+    updateRun() {
+        // empty
+    }
+
+    /**
+     * Add test data to the result array for saving. As a result of this function, we get a result object to save.
+     * @param {Object} test - object which includes each test entry.
+     */
+    addTest(test) {
+        if (!this.isEnabled) return;
+
+        const index = this.tests.findIndex(t => isSameTest(t, test));
+        // update if they were already added
+        if (index >= 0) {
+            this.tests[index] = merge(this.tests[index], test);
+            return;
+        }
+
+        this.tests.push(test);
+    }
+
+    async finishRun(runParams) {
+        if (!this.isEnabled) return;
+
+        if (this.isHtml) {
+            this.data = {
+                runId: this.store.runId,
+                status: runParams.status,
+                parallel: runParams.isParallel,
+                runUrl: this.store.runUrl,
+                executionTime: testExecutionSumTime(this.tests),
+                executionDate: getCurrentDateTimeFormatted(),
+                tests: this.tests 
+            };
+
+            // GENERATE HTML reports based on the results data
+            this.buildReport(this.data);
+        }
+    }
+
+    buildReport(data) {
+        debug('HTML tests data:', data);
+
+        if (!this.htmlOutputPath && this.htmlOutputPath !== "") {
+            console.log(chalk.yellow(`HTML export path is not set, ignoring...`));
+            return;
+        }
+
+        console.log(chalk.yellow(`The test results will be added to the HTML report. It will take some time...`));
+        // generate output HTML based on the template
+        const html = this.#generateHTMLReport(data);
+
+        fs.writeFileSync(this.htmlOutputPath, html, 'utf-8');
+    }
+
+    #generateHTMLReport(data) {
+        if (!this.templateHtmlPath) {
+            console.log(chalk.red(`HTML template not found. Report generation is impossible!`))
+            return;
+        }
+
+        const templateSource = fs.readFileSync(this.templateHtmlPath, 'utf8');
+        this.#loadReportHelpers();
+        try {
+            const template = handlebars.compile(templateSource);
+
+            console.log(chalk.green(`Generated HTML report saved in file: ${this.htmlOutputPath}`));
+            return template(data);
+        }
+        catch (e) {
+            console.log('Unknown HTML report generation error: ', e);
+        }
+    }
+
+    #loadReportHelpers() {
+        handlebars.registerHelper('getTestsByStatus', (tests, status) => 
+            tests.filter(test => test.status.toLowerCase() === status.toLowerCase()).length
+        );
+
+        handlebars.registerHelper('json', (obj) => JSON.stringify(obj));
+    }
+
+    toString() {
+        return 'HTML Reporter';
+    }
+}
+
+function testExecutionSumTime(tests) {
+    const totalMilliseconds = tests.reduce((sum, test) => {
+        if (typeof test.run_time === 'number') {
+            return sum + test.run_time;
+        }
+        return sum;
+    }, 0);
+
+    return formatDuration(totalMilliseconds);
+}
+
+function formatDuration(duration) {
+    const milliseconds = duration % 1000;
+    duration = (duration - milliseconds) / 1000;
+    const seconds = duration % 60;
+    duration = (duration - seconds) / 60;
+    const minutes = duration % 60;
+    const hours = (duration - minutes) / 60;
+
+    return `${hours}h ${minutes}m ${seconds}s ${milliseconds}ms`;
+}
+
+function getCurrentDateTimeFormatted() {
+    const currentDate = new Date();
+    const day = currentDate.getDate().toString().padStart(2, '0');
+    const month = (currentDate.getMonth() + 1).toString().padStart(2, '0');
+    const year = currentDate.getFullYear();
+    const hours = currentDate.getHours().toString().padStart(2, '0');
+    const minutes = currentDate.getMinutes().toString().padStart(2, '0');
+    const seconds = currentDate.getSeconds().toString().padStart(2, '0');
+
+    return `(${day}/${month}/${year} ${hours}:${minutes}:${seconds})`;
+}
+
+module.exports = HtmlPipe;

package/lib/pipe/index.js

@@ -6,6 +6,7 @@ const TestomatioPipe = require('./testomatio');
 const GitHubPipe = require('./github');
 const GitLabPipe = require('./gitlab');
 const CsvPipe = require('./csv');
+const HtmlPipe = require('./html');
 
 function PipeFactory(params, opts) {
   const extraPipes = [];
@@ -43,6 +44,7 @@ function PipeFactory(params, opts) {
     new GitHubPipe(params, opts),
     new GitLabPipe(params, opts),
     new CsvPipe(params, opts),
+    new HtmlPipe(params, opts),
     ...extraPipes,
   ];
 

package/lib/reporter.js

@@ -1,10 +1,10 @@
-const logger = require('./storages/logger');
+const logger = require('./logger');
 const TestomatClient = require('./client');
 const TRConstants = require('./constants');
+const TRArtifacts = require('./_ArtifactStorageOld');
 
 const log = logger.templateLiteralLog.bind(logger);
 const step = logger.step.bind(logger);
-const reporterFunctions = require('./reporter-functions');
 
 module.exports = {
   logger,
@@ -13,11 +13,6 @@ module.exports = {
   step,
   TestomatClient,
   TRConstants,
-};
-
-module.exports.testomat = {
-  artifact: reporterFunctions.artifact,
-  log: reporterFunctions.log,
-  step: reporterFunctions.step,
-  meta: reporterFunctions.keyValue,
+  TRArtifacts,
+  addArtifact: TRArtifacts.artifact,
 };

package/lib/template/real-data-example.js

@@ -0,0 +1,47 @@
+// TODO: use as example for the unit-tests
+
+const result = {
+    "runId": "51eb2798",
+    "status": "failed",
+    "runUrl": "https://beta.testomat.io/projects/codecept-new-mode-exmple/runs/51eb2798/report",
+    "executionTime": "0 seconds",
+    "executionDate": "(30/07/2023 11:11:11)",
+    "tests": [{
+        "files": [],
+        "steps": "\u001b[32m\u001b[1mOn TodosPage: goto \u001b[22m\u001b[39m\n",
+        "status": "passed",
+        "stack": "I execute script () => sessionStorage.clear()",
+        "example": null,
+        "code": null,
+        "title": "Create a new todo item @T50e82737",
+        "suite_title": "Create Tasks @step:06 @smoke @story:12 @S2f5c1942",
+        "test_id": "50e82737",
+        "message": "",
+        "run_time": 121,
+        "artifacts": [],
+        "api_key": "tstmt_gRqrhBUaVxTpezGpZjRmlahOeqcRBBbDMA1692050199",
+        "create": false
+    }, {
+        "files": [{
+            "path": "/home/codeceptjs-testomat-example/codeceptJS/output/Create_2_@T5b8d1186.failed.png",
+            "type": "image/png"
+        }],
+        "steps": "I am on page \"http://todomvc.com/examples/angularjs/#/\"",
+        "status": "failed",
+        "stack": "I am on page \"http://todomvc.com/examples/angularjs/#/\"",
+        "example": null,
+        "code": null,
+        "title": "Create a new todo item part 2 @T5b8d1186",
+        "suite_title": "@second Create Tasks @step:07 @smoke @story:13 @S2f5c1942",
+        "test_id": "5b8d1186",
+        "message": "expected expected number of visible is 2, but found 1 \"1\" to equal \"2\"",
+        "run_time": 176,
+        "artifacts": [null],
+        "api_key": "tstmt_gRqrhBUaVxTpezGpZjRmlahOeqcRBBbDMA1692050199",
+        "create": false
+    }]
+}
+
+module.exports = {
+    result
+}