@zohodesk/testinglibrary 0.1.9 → 0.2.1

package/build/bdd-framework/run/bddData/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BddDataManager = void 0;
+exports.getBddDataFromTest = getBddDataFromTest;
+var _createTestStep = require("../../cucumber/createTestStep");
+var _utils = require("../../utils");
+var _utils2 = require("../../playwright/utils");
+const BDD_DATA_ANNOTATION_NAME = '__bddData';
+class BddDataManager {
+  testInfo;
+  data;
+  constructor(testInfo, testMeta, uri) {
+    this.testInfo = testInfo;
+    this.data = {
+      uri,
+      pickleLocation: testMeta.pickleLocation,
+      steps: []
+    };
+    this.save({
+      create: true
+    });
+  }
+  registerStep(stepDefinition, stepText, pwStepLocation) {
+    const step = (0, _createTestStep.createTestStep)(stepDefinition, stepText);
+    this.data.steps.push({
+      pwStepLocation: (0, _utils.stringifyLocation)(pwStepLocation),
+      stepMatchArgumentsLists: step.stepMatchArgumentsLists || []
+    });
+    this.save();
+  }
+  save({
+    create = false
+  } = {}) {
+    (0, _utils2.updateAnnotation)(this.testInfo, {
+      type: BDD_DATA_ANNOTATION_NAME,
+      description: JSON.stringify(this.data)
+    }, {
+      create
+    });
+  }
+}
+exports.BddDataManager = BddDataManager;
+function getBddDataFromTest({
+  annotations
+}) {
+  const annotationIndex = annotations.findIndex(isBddDataAnnotation);
+  const annotation = annotations[annotationIndex];
+  const bddData = annotation !== null && annotation !== void 0 && annotation.description ? JSON.parse(annotation.description) : undefined;
+  return {
+    bddData,
+    annotationIndex
+  };
+}
+function isBddDataAnnotation(annotation) {
+  return annotation.type === BDD_DATA_ANNOTATION_NAME;
+}

package/build/bdd-framework/run/bddData/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/build/bdd-framework/run/bddFixtures.js

@@ -11,7 +11,7 @@ var _loadSteps = require("../cucumber/loadSteps");
 var _bddWorld = require("./bddWorld");
 var _config = require("../config");
 var _env = require("../config/env");
-var _steps = require("../stepDefinitions/decorators/steps");
+var _steps = require("../steps/decorators/steps");
 var _configDir = require("../config/configDir");
 var _scenario = require("../hooks/scenario");
 var _worker = require("../hooks/worker");
@@ -19,6 +19,7 @@ var _StepInvoker = require("./StepInvoker");
 var _testMeta = require("../gen/testMeta");
 var _logger = require("../utils/logger");
 var _enrichReporterData = require("../config/enrichReporterData");
+var _bddData = require("./bddData");
 const test = exports.test = _test.test.extend({
   // load cucumber once per worker (auto-fixture)
   // todo: maybe remove caching in cucumber/loadConfig.ts and cucumber/loadSteps.ts
@@ -76,12 +77,12 @@ const test = exports.test = _test.test.extend({
       log: () => _logger.logger.warn(`world.log() is noop, please use world.testInfo.attach()`),
       attach: async () => _logger.logger.warn(`world.attach() is noop, please use world.testInfo.attach()`)
     });
+    if ((0, _enrichReporterData.getEnrichReporterData)(config)) {
+      world.$internal.bddDataManager = new _bddData.BddDataManager(testInfo, $testMeta, $uri);
+    }
     await world.init();
     await use(world);
     await world.destroy();
-    if ((0, _enrichReporterData.getEnrichReporterData)(config)) {
-      await world.$internal.bddData.attach($testMeta, $uri);
-    }
   },
   Given: ({
     $bddWorld

package/build/bdd-framework/run/bddWorld.js

@@ -9,15 +9,15 @@ var _cucumber = require("@cucumber/cucumber");
 var _bddWorldInternal = require("./bddWorldInternal");
 class BddWorld extends _cucumber.World {
   options;
-  // special property to hold internal bdd related methods, must be public.
+  // special namespace to hold internal bdd related methods, must be public.
   $internal;
   constructor(options) {
     super(options);
     this.options = options;
-    this.$internal = new _bddWorldInternal.BddWorldInternal(this);
+    this.$internal = new _bddWorldInternal.BddWorldInternal();
   }
   /**
-     * Use particular fixture in cucumber-style steps.
+     * Use custom fixture in cucumber-style steps.
      *
      * Note: TS does not support partial generic inference,
      * that's why we can't use this.useFixture<typeof test>('xxx');

package/build/bdd-framework/run/bddWorldInternal.js

@@ -4,12 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.BddWorldInternal = void 0;
-var _bddDataAttachment = require("./bddDataAttachment");
 class BddWorldInternal {
   currentStepFixtures = {};
-  bddData;
-  constructor(world) {
-    this.bddData = new _bddDataAttachment.BddData(world);
-  }
+  bddDataManager;
 }
 exports.BddWorldInternal = BddWorldInternal;

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

@@ -7,7 +7,7 @@ exports.Snippets = void 0;
 var _url = require("url");
 var _loadSnippetBuilder = require("../cucumber/loadSnippetBuilder");
 var _logger = require("../utils/logger");
-var _stepConfig = require("../stepDefinitions/stepConfig");
+var _stepConfig = require("../steps/stepConfig");
 /**
  * Generate and show snippets for undefined steps
  */

package/build/bdd-framework/steps/createBdd.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBdd = createBdd;
+exports.hasCustomTest = void 0;
+var _bddFixtures = require("../run/bddFixtures");
+var _testTypeImpl = require("../playwright/testTypeImpl");
+var _defineStep = require("./defineStep");
+var _exit = require("../utils/exit");
+var _scenario = require("../hooks/scenario");
+var _worker = require("../hooks/worker");
+var _fixtureParameterNames = require("../playwright/fixtureParameterNames");
+/**
+ * Stuff related to writing steps in Playwright-style.
+ */
+
+// Global flag showing that custom test was passed.
+// Used when checking 'importTestFrom' config option.
+// todo: https://github.com/vitalets/playwright-bdd/issues/46
+let hasCustomTest = exports.hasCustomTest = false;
+function createBdd(customTest, _CustomWorld) {
+  if (!hasCustomTest) {
+    exports.hasCustomTest = hasCustomTest = isCustomTest(customTest);
+  }
+  const Given = defineStepCtor('Given', hasCustomTest);
+  const When = defineStepCtor('When', hasCustomTest);
+  const Then = defineStepCtor('Then', hasCustomTest);
+  const Step = defineStepCtor('Unknown', hasCustomTest);
+  const Before = (0, _scenario.scenarioHookFactory)('before');
+  const After = (0, _scenario.scenarioHookFactory)('after');
+  const BeforeAll = (0, _worker.workerHookFactory)('beforeAll');
+  const AfterAll = (0, _worker.workerHookFactory)('afterAll');
+  return {
+    Given,
+    When,
+    Then,
+    Step,
+    Before,
+    After,
+    BeforeAll,
+    AfterAll
+  };
+}
+function defineStepCtor(keyword, hasCustomTest) {
+  return (pattern, fn) => {
+    (0, _defineStep.defineStep)({
+      keyword,
+      pattern,
+      fn,
+      hasCustomTest
+    });
+    return (fixtures, ...args) => {
+      assertStepIsCalledWithRequiredFixtures(pattern, fn, fixtures);
+      return fn(fixtures, ...args);
+    };
+  };
+}
+function isCustomTest(customTest) {
+  if (!customTest || customTest === _bddFixtures.test) {
+    return false;
+  }
+  assertTestHasBddFixtures(customTest);
+  return true;
+}
+function assertTestHasBddFixtures(customTest) {
+  if (!(0, _testTypeImpl.isTestContainsSubtest)(customTest, _bddFixtures.test)) {
+    (0, _exit.exit)(`createBdd() should use 'test' extended from "playwright-bdd"`);
+  }
+}
+function assertStepIsCalledWithRequiredFixtures(pattern, fn, fixtures) {
+  const fixtureNames = (0, _fixtureParameterNames.fixtureParameterNames)(fn);
+  const missingFixtures = fixtureNames.filter(fixtureName => !Object.prototype.hasOwnProperty.call(fixtures, fixtureName));
+  if (missingFixtures.length) {
+    throw new Error([`Invocation of step "${pattern}" from another step does not pass all required fixtures.`, `Missings fixtures: ${missingFixtures.join(', ')}`].join(' '));
+  }
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fixture = Fixture;
+exports.getPomNodeByFixtureName = getPomNodeByFixtureName;
+var _steps = require("./steps");
+var _exit = require("../../utils/exit");
+/**
+ * Class level @Fixture decorator.
+ */
+
+/**
+ * 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
+  return (Ctor, _context) => {
+    createPomNode(Ctor, fixtureName);
+  };
+}
+function createPomNode(Ctor, fixtureName) {
+  const pomNode = {
+    fixtureName,
+    className: Ctor.name,
+    children: new Set()
+  };
+  ensureUniqueFixtureName(pomNode);
+  pomGraph.set(Ctor, pomNode);
+  (0, _steps.linkStepsWithPomNode)(Ctor, pomNode);
+  linkParentWithPomNode(Ctor, pomNode);
+  return pomNode;
+}
+function ensureUniqueFixtureName({
+  fixtureName,
+  className
+}) {
+  if (!fixtureName) {
+    return;
+  }
+  const existingPom = getPomNodeByFixtureName(fixtureName);
+  if (existingPom) {
+    (0, _exit.exit)(`Duplicate fixture name "${fixtureName}"`, `defined for classes: ${existingPom.className}, ${className}`);
+  }
+}
+function linkParentWithPomNode(Ctor, pomNode) {
+  const parentCtor = Object.getPrototypeOf(Ctor);
+  if (!parentCtor) {
+    return;
+  }
+  // if parentCtor is not in pomGraph, add it.
+  // 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/steps/decorators/steps.js

@@ -0,0 +1,98 @@
+"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
+    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,
+      // 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 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/steps/defineStep.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCucumberStepCode = buildCucumberStepCode;
+exports.defineStep = defineStep;
+exports.getStepCode = getStepCode;
+var _cucumber = require("@cucumber/cucumber");
+var _exit = require("../utils/exit");
+/**
+ * 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, _exit.exit)(`Option "importTestFrom" should point to a separate file without step definitions`, `(e.g. without calls of Given, When, Then)`);
+    } else {
+      throw e;
+    }
+  }
+}
+function buildCucumberStepCode(stepConfig) {
+  const code = function (...args) {
+    // build the first argument (fixtures) for step fn
+    const fixturesArg = Object.assign({}, this.$internal.currentStepFixtures, {
+      $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/steps/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/core/playwright/builtInFixtures/page.js

@@ -1,12 +1,10 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _getUsers = require("../helpers/auth/getUsers");
-var _loginSteps = _interopRequireDefault(require("../helpers/auth/loginSteps"));
+var _auth = require("../helpers/auth");
 var _readConfigFile = require("../readConfigFile");
 /* eslint-disable global-require */
 
@@ -19,12 +17,14 @@ function getTagInputFromSelectedTags(tags, inputString) {
   return tagInput;
 }
 function getCustomAccountDetails(tags) {
-  const filteredTags = tags.filter(tag => tag.startsWith('@profile') || tag.startsWith('@edition') || tag.startsWith('@profile') || tag.startsWith('@darkLaunch'));
+  const tagsTobeFiltered = ['@profile', '@edition', '@beta', '@portal'];
+  const filteredTags = tags.filter(tag => tagsTobeFiltered.some(prefix => tag.startsWith(prefix)));
   if (filteredTags && filteredTags.length > 0) {
-    const selectedProfile = getTagInputFromSelectedTags(filteredTags, '@profile');
-    const selectedEdition = getTagInputFromSelectedTags(filteredTags, '@edition');
-    const darkLaunchFeature = getTagInputFromSelectedTags(filteredTags, '@darkLaunch');
-    const user = (0, _getUsers.getUserForSelectedEditionAndProfile)(selectedEdition, selectedProfile, darkLaunchFeature);
+    const portalInfo = getTagInputFromSelectedTags(filteredTags, '@portal');
+    const betaFeature = getTagInputFromSelectedTags(filteredTags, '@beta');
+    const profileInfo = getTagInputFromSelectedTags(filteredTags, '@profile');
+    const editionInfo = getTagInputFromSelectedTags(filteredTags, '@edition');
+    const user = (0, _auth.getUserForSelectedEditionAndProfile)(editionInfo, profileInfo, betaFeature, portalInfo);
     return user;
   }
   return null;
@@ -53,22 +53,29 @@ var _default = exports.default = {
     $tags,
     page
   }, use) => {
-    const customAccountDetails = getCustomAccountDetails($tags);
-    if (customAccountDetails === null) {
+    const testPortalDetails = getCustomAccountDetails($tags);
+    if (testPortalDetails === null) {
       await performDefaultPageSteps({
         context,
         $tags,
         page
       });
+      const user = (0, _auth.getDefaultActor)();
+      process.env.actorInfo = JSON.stringify(user);
       await use(page);
     } else {
       await context.clearCookies();
-      await (0, _loginSteps.default)({
+      const {
+        email,
+        password
+      } = testPortalDetails;
+      await (0, _auth.performLoginSteps)({
         page,
-        role: `${customAccountDetails.role}-${customAccountDetails.edition}`,
-        useremail: customAccountDetails.email,
-        password: customAccountDetails.password
+        authFilePrefix: email,
+        useremail: email,
+        password: password
       }, async () => page.url().includes(process.env.domain));
+      process.env.actorInfo = JSON.stringify(testPortalDetails);
       await performDefaultPageSteps({
         context,
         $tags,

package/build/core/playwright/clear-caches.js

@@ -10,9 +10,10 @@ var _fileUtils = require("../../utils/fileUtils");
 var _logger = require("../../utils/logger");
 var _readConfigFile = require("./readConfigFile");
 function deleteAuthFiles(authFilePath) {
-  authFilePath.split('/').pop();
-  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting auth files present in ${authFilePath}`);
-  (0, _fileUtils.deleteFolder)(_path.default.resolve(process.cwd(), authFilePath));
+  authFilePath = _path.default.resolve(process.cwd(), authFilePath);
+  const authFileFolder = _path.default.dirname(authFilePath);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting auth files present in ${authFileFolder}`);
+  (0, _fileUtils.deleteFolder)(authFileFolder);
 }
 function deletePlaywrightReport(reportPath) {
   _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting Playwright report ${reportPath}`);
@@ -34,6 +35,7 @@ function clearCaches() {
     deleteGeneratedFeatures();
     _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Caches Cleared. Now you can try running npm run uat');
   } catch (err) {
+    _logger.Logger.error(err);
     _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Error While clearing cookies. Try manually delete folder uat/playwright and uat/playwright-report');
   }
 }

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

@@ -8,18 +8,34 @@ exports.initializeEnvConfig = initializeEnvConfig;
 var _fs = require("fs");
 var _path = _interopRequireDefault(require("path"));
 var _configFileNameProvider = require("./helpers/configFileNameProvider");
+var _logger = require("../../utils/logger");
+var _getUsers = require("./helpers/auth/getUsers");
 function setEnvironmentVariables(mode, configJSON) {
   process.env.mode = mode;
-  for (const key in configJSON[mode]) {
-    process.env[key] = configJSON[mode][key];
+  for (const key in configJSON) {
+    process.env[key] = configJSON[key];
   }
 }
-function initializeEnvConfig(mode = 'dev') {
+function addHelperLogsForEnvInitialization() {
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Mode under which test cases should run has not been specified in args.`);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Please specify --mode='dev/prod' while running ZDTestingFramework test`);
+  _logger.Logger.log(_logger.Logger.INFO_TYPE, `Going to use default mode as dev`);
+}
+function initializeEnvConfig(mode) {
   try {
-    const configFile = (0, _fs.readFileSync)(_path.default.resolve(process.cwd(), `./${(0, _configFileNameProvider.getEnvConfigFilePath)()}`));
+    if (!mode) {
+      addHelperLogsForEnvInitialization();
+      mode = 'dev';
+    }
+    const configFile = (0, _fs.readFileSync)(_path.default.resolve(process.cwd(), `./${(0, _configFileNameProvider.getEnvConfigFilePath)(mode)}`));
     const configJSON = JSON.parse(configFile);
-    setEnvironmentVariables(mode, configJSON);
+    const defaultActorConfiguration = (0, _getUsers.getDefaultActorConf)();
+    setEnvironmentVariables(mode, {
+      ...configJSON,
+      ...defaultActorConfiguration
+    });
   } catch (err) {
-    throw new Error(`Config File Not Exists. Please provide a config file ${(0, _configFileNameProvider.getEnvConfigFilePath)()} to intiailize the environment variables`);
+    _logger.Logger.error(err);
+    throw new Error(`Config File Not Exists. Please provide a config file ${(0, _configFileNameProvider.getEnvConfigFilePath)(mode)} to intiailize the environment variables `);
   }
 }

package/build/core/playwright/helpers/auth/checkAuthCookies.js

@@ -4,22 +4,26 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.authDirectory = void 0;
+exports.getAuthFileDirectory = getAuthFileDirectory;
 exports.loadCookiesIfPresent = loadCookiesIfPresent;
 exports.verifyIfCookieFileExists = verifyIfCookieFileExists;
 var _path = _interopRequireDefault(require("path"));
 var _fs = require("fs");
 var _readConfigFile = require("../../readConfigFile");
+var _logger = require("../../../../utils/logger");
 /* eslint-disable no-console */
 
-const {
-  uatDirectory
-} = (0, _readConfigFile.generateConfigFromFile)();
-const authDirectory = exports.authDirectory = _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.auth'));
 const authContent = {
   cookies: []
 };
+function getAuthFileDirectory() {
+  const {
+    uatDirectory
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  return _path.default.resolve(_path.default.join(uatDirectory, 'playwright', '.auth'));
+}
 function verifyIfCookieFileExists(authFile) {
+  const authDirectory = getAuthFileDirectory();
   if (!(0, _fs.existsSync)(authDirectory)) {
     console.log('Creating auth directory for the first time setup...');
     (0, _fs.mkdirSync)(authDirectory, {
@@ -35,6 +39,7 @@ function convertCookiesToParse(cookies, authFilePath) {
   try {
     return JSON.parse(cookies);
   } catch (err) {
+    _logger.Logger.error(err);
     throw new Error(` Error while parsing cookies ${err} \n${_path.default.resolve(process.cwd(), authFilePath)} File is Empty`);
     // process.exit()
   }