@zohodesk/testinglibrary 0.0.5 → 0.0.6

package/build/bdd-framework/stepDefinitions/createDecorators.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fixture = Fixture;
+exports.appendDecoratorSteps = appendDecoratorSteps;
+exports.createStepDecorator = createStepDecorator;
+exports.getPomNodeByFixtureName = getPomNodeByFixtureName;
+var _bddFixtures = require("../run/bddFixtures");
+var _defineStep = require("./defineStep");
+var _buildStepDefinition = require("../cucumber/buildStepDefinition");
+/* eslint-disable no-unused-vars */
+/**
+ * Define steps via decorators.
+ */
+
+const pomGraph = new Map();
+const decoratedStepSymbol = Symbol('decoratedStep');
+const decoratedSteps = new Set();
+function Fixture(fixtureName) {
+  // context parameter is required for decorator by TS even though it's not used
+  return (Ctor, _context) => {
+    createPomNode(Ctor, fixtureName);
+  };
+}
+function createStepDecorator(keyword) {
+  return pattern => {
+    // context parameter is required for decorator by TS even though it's not used
+    return (method, _context) => {
+      method[decoratedStepSymbol] = {
+        keyword,
+        pattern,
+        fn: method,
+        hasCustomTest: true,
+        isDecorator: true
+      };
+    };
+  };
+}
+function appendDecoratorSteps(supportCodeLibrary) {
+  decoratedSteps.forEach(stepConfig => {
+    const {
+      keyword,
+      pattern,
+      fn
+    } = stepConfig;
+    stepConfig.fn = (fixturesArg, ...args) => {
+      const fixture = getFirstNonAutoInjectFixture(fixturesArg, stepConfig);
+      return fn.call(fixture, ...args);
+    };
+    const code = (0, _defineStep.buildCucumberStepFn)(stepConfig);
+    const stepDefinition = (0, _buildStepDefinition.buildStepDefinition)({
+      keyword,
+      pattern,
+      code,
+      line: 0,
+      // not used in playwright-bdd
+      options: {},
+      // not used in playwright-bdd
+      uri: '' // not used in playwright-bdd
+    }, supportCodeLibrary);
+    supportCodeLibrary.stepDefinitions.push(stepDefinition);
+  });
+  decoratedSteps.clear();
+  // todo: fill supportCodeLibrary.originalCoordinates as it is used in snippets?
+}
+
+function getPomNodeByFixtureName(fixtureName) {
+  for (const pomNode of pomGraph.values()) {
+    if (pomNode.fixtureName === fixtureName) return pomNode;
+  }
+}
+function createPomNode(Ctor, fixtureName) {
+  const pomNode = {
+    fixtureName,
+    children: new Set()
+  };
+  pomGraph.set(Ctor, pomNode);
+  getDecoratedSteps(Ctor).forEach(stepConfig => {
+    stepConfig.pomNode = pomNode;
+    decoratedSteps.add(stepConfig);
+  });
+  const parentCtor = Object.getPrototypeOf(Ctor);
+  if (!parentCtor) return;
+  const parentPomNode = pomGraph.get(parentCtor) || createPomNode(parentCtor, '');
+  parentPomNode === null || parentPomNode === void 0 || parentPomNode.children.add(pomNode);
+  return pomNode;
+}
+function getDecoratedSteps(Ctor) {
+  if (!(Ctor !== null && Ctor !== void 0 && Ctor.prototype)) return [];
+  const propertyDescriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
+  return Object.keys(propertyDescriptors)
+  // filter out getters / setters
+  .filter(methodName => typeof propertyDescriptors[methodName].value === 'function').map(methodName => {
+    return propertyDescriptors[methodName].value[decoratedStepSymbol];
+  }).filter(Boolean);
+}
+function getFirstNonAutoInjectFixture(fixturesArg, stepConfig) {
+  // there should be exatcly one suitable fixture in fixturesArg
+  const fixtureNames = Object.keys(fixturesArg).filter(fixtureName => !(0, _bddFixtures.isBddAutoInjectFixture)(fixtureName));
+  if (fixtureNames.length === 0) {
+    throw new Error(`No suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  if (fixtureNames.length > 1) {
+    throw new Error(`Several suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  return fixturesArg[fixtureNames[0]];
+}

package/build/bdd-framework/stepDefinitions/decorators/poms.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fixture = Fixture;
+exports.getPomNodeByFixtureName = getPomNodeByFixtureName;
+var _steps = require("./steps");
+/**
+ * POM classes marked with @Fixture
+ */
+
+/**
+ * Graph of POM class inheritance.
+ * Allows to guess correct fixture by step text.
+ */
+const pomGraph = new Map();
+/**
+ * @Fixture decorator.
+ */
+function Fixture(fixtureName) {
+  // context parameter is required for decorator by TS even though it's not used
+  // eslint-disable-next-line no-unused-vars
+  return (Ctor, _context) => {
+    createPomNode(Ctor, fixtureName);
+  };
+}
+function createPomNode(Ctor, fixtureName) {
+  const pomNode = {
+    fixtureName,
+    children: new Set()
+  };
+  pomGraph.set(Ctor, pomNode);
+  (0, _steps.linkStepsWithPomNode)(Ctor, pomNode);
+  linkParentWithPomNode(Ctor, pomNode);
+  return pomNode;
+}
+function linkParentWithPomNode(Ctor, pomNode) {
+  const parentCtor = Object.getPrototypeOf(Ctor);
+  if (!parentCtor) return;
+  // if parentCtor is not in pomGraph, add it as well
+  // Case: parent class is not marked with @Fixture, but has decorator steps (base class)
+  const parentPomNode = pomGraph.get(parentCtor) || createPomNode(parentCtor, '');
+  parentPomNode.children.add(pomNode);
+}
+function getPomNodeByFixtureName(fixtureName) {
+  for (const pomNode of pomGraph.values()) {
+    if (pomNode.fixtureName === fixtureName) return pomNode;
+  }
+}

package/build/bdd-framework/stepDefinitions/decorators/steps.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.appendDecoratorSteps = appendDecoratorSteps;
+exports.createStepDecorator = createStepDecorator;
+exports.linkStepsWithPomNode = linkStepsWithPomNode;
+var _bddFixtures = require("../../run/bddFixtures");
+var _buildStepDefinition = require("../../cucumber/buildStepDefinition");
+var _defineStep = require("../defineStep");
+/**
+ * Define steps via decorators.
+ */
+
+// initially we sotre step data inside method,
+// and then extract it in @Fixture decorator call
+const decoratedStepSymbol = Symbol('decoratedStep');
+// global list of all decorator steps
+const decoratedSteps = new Set();
+/**
+ * Creates @Given, @When, @Then decorators.
+ */
+function createStepDecorator(keyword) {
+  return pattern => {
+    // context parameter is required for decorator by TS even though it's not used
+    // eslint-disable-next-line no-unused-vars
+    return (method, _context) => {
+      saveStepConfigToMethod(method, {
+        keyword,
+        pattern,
+        fn: method,
+        hasCustomTest: true
+      });
+    };
+  };
+}
+function linkStepsWithPomNode(Ctor, pomNode) {
+  if (!(Ctor !== null && Ctor !== void 0 && Ctor.prototype)) return;
+  const propertyDescriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
+  return Object.values(propertyDescriptors).forEach(descriptor => {
+    const stepConfig = getStepConfigFromMethod(descriptor);
+    if (!stepConfig) return;
+    stepConfig.pomNode = pomNode;
+    decoratedSteps.add(stepConfig);
+  });
+}
+/**
+ * Append decorator steps to Cucumber's supportCodeLibrary.
+ */
+function appendDecoratorSteps(supportCodeLibrary) {
+  decoratedSteps.forEach(stepConfig => {
+    const {
+      keyword,
+      pattern,
+      fn
+    } = stepConfig;
+    stepConfig.fn = (fixturesArg, ...args) => {
+      const fixture = getFirstNonAutoInjectFixture(fixturesArg, stepConfig);
+      return fn.call(fixture, ...args);
+    };
+    const code = (0, _defineStep.buildCucumberStepCode)(stepConfig);
+    const stepDefinition = (0, _buildStepDefinition.buildStepDefinition)({
+      keyword,
+      pattern,
+      code,
+      line: 0,
+      options: {},
+      uri: '' // not used in playwright-bdd
+    }, supportCodeLibrary);
+    supportCodeLibrary.stepDefinitions.push(stepDefinition);
+  });
+  decoratedSteps.clear();
+  // todo: fill supportCodeLibrary.originalCoordinates as it is used in snippets?
+}
+
+function getFirstNonAutoInjectFixture(fixturesArg, stepConfig) {
+  // there should be exatcly one suitable fixture in fixturesArg
+  const fixtureNames = Object.keys(fixturesArg).filter(fixtureName => !(0, _bddFixtures.isBddAutoInjectFixture)(fixtureName));
+  if (fixtureNames.length === 0) {
+    throw new Error(`No suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  if (fixtureNames.length > 1) {
+    throw new Error(`Several suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  return fixturesArg[fixtureNames[0]];
+}
+function saveStepConfigToMethod(method, stepConfig) {
+  method[decoratedStepSymbol] = stepConfig;
+}
+function getStepConfigFromMethod(descriptor) {
+  // filter out getters / setters
+  return typeof descriptor.value === 'function' ? descriptor.value[decoratedStepSymbol] : undefined;
+}

package/build/bdd-framework/stepDefinitions/defineStep.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCucumberStepCode = buildCucumberStepCode;
+exports.defineStep = defineStep;
+exports.getStepCode = getStepCode;
+var _cucumber = require("@cucumber/cucumber");
+var _utils = require("../utils");
+/**
+ * Defines step by config.
+ * Calls cucumber's Given(), When(), Then() under the hood.
+ */
+function defineStep(stepConfig) {
+  const {
+    keyword,
+    pattern
+  } = stepConfig;
+  const cucumberDefineStepFn = getCucumberDefineStepFn(keyword);
+  const code = buildCucumberStepCode(stepConfig);
+  try {
+    cucumberDefineStepFn(pattern, code);
+  } catch (e) {
+    // todo: detect that this is import from test file
+    // and skip/delay registering cucumber steps until cucumber is loaded
+    const isMissingCucumber = /Cucumber that isn't running/i.test(e.message);
+    if (isMissingCucumber) {
+      (0, _utils.exitWithMessage)(`Option "importTestFrom" should point to separate file without step definitions`, `(e.g. without calls of Given, When, Then)`);
+    } else {
+      throw e;
+    }
+  }
+}
+function buildCucumberStepCode(stepConfig) {
+  const code = function (...args) {
+    const fixturesArg = Object.assign({}, this.customFixtures, {
+      $testInfo: this.testInfo,
+      $test: this.test,
+      $tags: this.tags
+    });
+    return stepConfig.fn.call(this, fixturesArg, ...args);
+  };
+  code.stepConfig = stepConfig;
+  return code;
+}
+function getStepCode(stepDefinition) {
+  return stepDefinition.code;
+}
+function getCucumberDefineStepFn(keyword) {
+  switch (keyword) {
+    case 'Given':
+      return _cucumber.Given;
+    case 'When':
+      return _cucumber.When;
+    case 'Then':
+      return _cucumber.Then;
+    default:
+      return _cucumber.defineStep;
+  }
+}

package/build/bdd-framework/stepDefinitions/stepConfig.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStepConfig = getStepConfig;
+exports.isDecorator = isDecorator;
+exports.isPlaywrightStyle = isPlaywrightStyle;
+/**
+ * Playwright-bdd's step config.
+ */
+function getStepConfig(step) {
+  return step.code.stepConfig;
+}
+function isDecorator(stepConfig) {
+  return Boolean(stepConfig === null || stepConfig === void 0 ? void 0 : stepConfig.pomNode);
+}
+/**
+ * Cucumber-style steps don't have stepConfig
+ * b/c they created directly via cucumber's Given, When, Then.
+ */
+function isPlaywrightStyle(stepConfig) {
+  return Boolean(stepConfig);
+}

package/build/bdd-framework/utils/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exitWithMessage = exitWithMessage;
+exports.getPackageVersion = getPackageVersion;
+exports.getSymbolByName = getSymbolByName;
+exports.removeDuplicates = removeDuplicates;
+exports.resolvePackageRoot = resolvePackageRoot;
+exports.template = template;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("./logger");
+function exitWithMessage(...messages) {
+  _logger.logger.error('ERROR:', ...messages.filter(Boolean));
+  process.exit(1);
+}
+// See: https://stackoverflow.com/questions/50453640/how-can-i-get-the-value-of-a-symbol-property
+function getSymbolByName(target, name) {
+  const ownKeys = Reflect.ownKeys(target);
+  const symbol = ownKeys.find(key => key.toString() === `Symbol(${name})`);
+  if (!symbol) {
+    throw new Error(`Symbol "${name}" not found in target. ownKeys: ${ownKeys}`);
+  }
+  return symbol;
+}
+/**
+ * Inserts params into template.
+ * Params defined as <param>.
+ */
+function template(t, params = {}) {
+  return t.replace(/<(.+?)>/g, (match, key) => {
+    return params[key] !== undefined ? String(params[key]) : match;
+  });
+}
+function removeDuplicates(arr) {
+  return [...new Set(arr)];
+}
+function resolvePackageRoot(packageName) {
+  const packageJsonPath = require.resolve(`${packageName}/package.json`);
+  return _path.default.dirname(packageJsonPath);
+}
+function getPackageVersion(packageName) {
+  const packageRoot = resolvePackageRoot(packageName);
+  const packageJsonPath = _path.default.join(packageRoot, 'package.json');
+  const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, 'utf8'));
+  return packageJson.version || '';
+}

package/build/bdd-framework/utils/jsStringWrap.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsStringWrap = jsStringWrap;
+/**
+ * Adopted version of https://github.com/joliss/js-string-escape
+ * - added support of backticks
+ * - added 'quotes' option to indicate which quotes to escape
+ * - wrap result string with provided quotes
+ *
+ * Considered alternative is https://github.com/mathiasbynens/jsesc,
+ * but it provides additional functionality and much slower
+ * See: https://github.com/mathiasbynens/jsesc/issues/16
+ */
+function jsStringWrap(str, {
+  quotes = 'single'
+} = {}) {
+  const wrapQuote = quotes === 'single' ? "'" : quotes === 'double' ? '"' : '`';
+  // eslint-disable-next-line complexity
+  const escapedStr = ('' + str).replace(/["'`\\\n\r\u2028\u2029]/g, character => {
+    // Escape all characters not included in SingleStringCharacters and
+    // DoubleStringCharacters on
+    // http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+    switch (character) {
+      case wrapQuote:
+      case '\\':
+        return '\\' + character;
+      // Four possible LineTerminator characters need to be escaped:
+      case '\n':
+        return '\\n';
+      case '\r':
+        return '\\r';
+      case '\u2028':
+        return '\\u2028';
+      case '\u2029':
+        return '\\u2029';
+      default:
+        return character;
+    }
+  });
+  return `${wrapQuote}${escapedStr}${wrapQuote}`;
+}

package/build/bdd-framework/utils/logger.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = exports.Logger = void 0;
+/**
+ * Simple logger
+ */
+class Logger {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  log(...args) {
+    if (this.options.verbose) console.log(...args);
+  }
+  warn(...args) {
+    // using log() to output warnings to stdout, not stderr
+    console.log(...args);
+  }
+  error(...args) {
+    console.error(...args);
+  }
+}
+// default logger
+exports.Logger = Logger;
+const logger = new Logger();
+exports.logger = logger;

package/build/core/jest/preprocessor/jsPreprocessor.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _babelJest = _interopRequireDefault(require("babel-jest"));
+var _default = _babelJest.default.createTransformer({
+  presets: [require.resolve('@babel/preset-env'), require.resolve('@babel/preset-react')],
+  plugins: [require.resolve('babel-plugin-transform-dynamic-import')]
+});
+exports.default = _default;

package/{src → build}/core/jest/runner/jest-runner.js

@@ -1,44 +1,46 @@
-// import { run } from 'jest';
-
-// function createJestRunner() {
-//   let config = require('../configs/jest.config');
-
-//   let argv = process.argv.slice(2);
-
-//   argv.push('--config', JSON.stringify(config(folder)), '--no-cache');
-//   run(argv);
-// }
-
-
-// export default createJestRunner;
-
-const { spawn } = require('child_process');
-const path = require('path');
-const { getExecutableBinaryPath } = require('../../../utils/rootPath');
-
-const jestPath = path.resolve(getExecutableBinaryPath('jest'));
-
-// Command and arguments for npx playwright test
-const command = jestPath;
-const args = ['--config', require.resolve('../../../../jest.config.js')];
-
-
-function createJestRunner() {
-  // Spawn the child process
-
-  const childProcess = spawn(command, args, { stdio: 'inherit' });
-
-
-  // Handling the 'exit' event of the child process
-  // childProcess.on('exit', (code, signal) => {
-  //   console.log(`Child process exited with code ${code} and signal ${signal}`);
-  // });
-
-  // // Handling any error that occurs while spawning the child process
-  // childProcess.on('error', (err) => {
-  //   console.error(`Error while spawning child process: ${err.message}`);
-  // });
-}
-
-
-module.exports = createJestRunner;
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createJestRunner;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _rootPath = require("../../../utils/rootPath");
+/* eslint-disable no-unused-vars */
+// import { run } from 'jest';
+
+// function createJestRunner() {
+//   let config  from '../configs/jest.config');
+
+//   let argv = process.argv.slice(2);
+
+//   argv.push('--config', JSON.stringify(config(folder)), '--no-cache');
+//   run(argv);
+// }
+
+// export default createJestRunner;
+
+const jestPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('jest'));
+
+// Command and arguments for npx playwright test
+const command = jestPath;
+const args = ['--config', require.resolve('../../../../jest.config.js')];
+function createJestRunner() {
+  // Spawn the child process
+
+  const childProcess = (0, _child_process.spawn)(command, args, {
+    stdio: 'inherit'
+  });
+
+  // Handling the 'exit' event of the child process
+  // childProcess.on('exit', (code, signal) => {
+  //   console.log(`Child process exited with code ${code} and signal ${signal}`);
+  // });
+
+  // // Handling any error that occurs while spawning the child process
+  // childProcess.on('error', (err) => {
+  //   console.error(`Error while spawning child process: ${err.message}`);
+  // });
+}

package/build/core/jest/setup/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _testUtils = _interopRequireDefault(require("react-dom/test-utils"));
+var _globals = require("@jest/globals");
+var _react = _interopRequireDefault(require("react"));
+var _propTypes = _interopRequireDefault(require("prop-types"));
+var _reactDom = _interopRequireDefault(require("react-dom"));
+require("@testing-library/jest-dom/extend-expect");

package/build/core/playwright/codegen.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateCodegen;
+var _child_process = require("child_process");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+var _rootPath = require("../../utils/rootPath");
+const userArgs = process.argv.slice(3);
+const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+const command = playwrightPath;
+const args = ['codegen'].concat(userArgs);
+function generateCodegen() {
+  const childProcess = (0, _child_process.spawn)(command, args, {
+    stdio: 'inherit'
+  });
+  childProcess.on('error', error => {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+  });
+  childProcess.on('exit', (code, signal) => {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Child Process Exited with Code ${code} and Signal ${signal}`);
+    process.exit();
+  });
+  process.on('exit', () => {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Terminating Playwright Process...');
+    //childProcess.kill();
+    return;
+  });
+  process.on('SIGINT', () => {
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, 'Cleaning up...');
+    //childProcess.kill();
+    process.exit();
+  });
+}
+
+// Another way to record. Below way will load the url in autheticated state if present
+// function generateCodegen() {
+//   (async () => {
+//     // Make sure to run headed.
+//     const browser = await chromium.launch({ headless: false });
+
+//     // Setup context however you like.
+//     const context = await browser.newContext({ storageState: path.resolve(process.cwd(), 'uat', 'playwright/.auth/user.json') });
+//     await context.route('**/*', route => route.continue());
+
+//     // Pause the page, and start recording manually.
+//     const page = await context.newPage();
+//     console.log(userArgs.join(''));
+//     await page.goto(`https://${userArgs.join('')}`);
+//     await page.pause();
+//   })();
+// }

package/build/core/playwright/custom-commands.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CUSTOM_COMMANDS = void 0;
+const CUSTOM_COMMANDS = ['mode', 'tags'];
+exports.CUSTOM_COMMANDS = CUSTOM_COMMANDS;

package/build/core/playwright/env-initializer.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.initializeEnvConfig = initializeEnvConfig;
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+function initializeEnvConfig(mode = 'dev') {
+  try {
+    const configFile = (0, _fs.readFileSync)(_path.default.resolve(process.cwd(), './uat/env-config.json'));
+    const configJSON = JSON.parse(configFile);
+    process.env.mode = mode;
+    for (const key in configJSON[mode]) {
+      process.env[key] = configJSON[mode][key];
+    }
+  } catch (err) {
+    throw new Error('Config File Not Exists. Please provide a config file to intiailize the environment variables');
+  }
+}