@zohodesk/testinglibrary 0.0.7 → 0.0.8-n20-experimental

package/build/core/playwright/helpers/customFixturesHelper.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extractTagInfo = extractTagInfo;
+exports.getCustomAccountDetails = getCustomAccountDetails;
+var _auth = require("../helpers/auth");
+var _logger = require("../../../utils/logger");
+/* eslint-disable global-require */
+
+function getTagInputFromSelectedTags(tags, inputString) {
+  const selectedTag = [...tags].reverse().find(tag => tag.startsWith(inputString));
+  let tagInput = null;
+  if (selectedTag) {
+    tagInput = selectedTag.split(`${inputString}_`).pop().toLowerCase();
+  }
+  return tagInput;
+}
+function extractTagInfo(tags) {
+  const tagsTobeFiltered = ['@profile', '@edition', '@beta', '@portal'];
+  const filteredTags = tags.filter(tag => tagsTobeFiltered.some(prefix => tag.startsWith(prefix)));
+  if (!filteredTags.length) {
+    return {
+      portalInfo: null,
+      betaFeature: null,
+      profileInfo: null,
+      editionInfo: null
+    };
+  }
+  const portalInfo = getTagInputFromSelectedTags(filteredTags, '@portal');
+  const betaFeature = getTagInputFromSelectedTags(filteredTags, '@beta');
+  const profileInfo = getTagInputFromSelectedTags(filteredTags, '@profile');
+  const editionInfo = getTagInputFromSelectedTags(filteredTags, '@edition');
+  return {
+    portalInfo,
+    betaFeature,
+    profileInfo,
+    editionInfo
+  };
+}
+function getCustomAccountDetails(tags) {
+  try {
+    const {
+      portalInfo,
+      betaFeature,
+      profileInfo,
+      editionInfo
+    } = extractTagInfo(tags);
+    if (portalInfo || betaFeature || profileInfo || editionInfo) {
+      const user = (0, _auth.getUserForSelectedEditionAndProfile)(editionInfo, profileInfo, betaFeature, portalInfo);
+      return user;
+    }
+    return (0, _auth.getDefaultActor)();
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Error while getting accounts details:', err);
+  }
+}

package/build/core/playwright/helpers/fileMutex.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+var _FileMutex_brand = /*#__PURE__*/new WeakSet();
+class FileMutex {
+  constructor(directory, lockFileName, fileDeletionTimeoutConfig) {
+    _classPrivateMethodInitSpec(this, _FileMutex_brand);
+    this.directory = directory;
+    this.lockFileName = lockFileName + ".lock";
+    this.fileDeletionTimeout = fileDeletionTimeoutConfig.timeout;
+    this.lockFilePath = _assertClassBrand(_FileMutex_brand, this, _getLockFilePath).call(this);
+    _assertClassBrand(_FileMutex_brand, this, _createDirectoryIfNotExist).call(this);
+  }
+  async acquire() {
+    return new Promise((resolve, reject) => {
+      if (!(0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.writeFileSync)(this.lockFilePath, 'locked');
+        console.log(`Lock file created: ${this.lockFilePath}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+        return resolve();
+      }
+      const timeout = setTimeout(() => {
+        watcher.close();
+        reject(new Error('Watch timeout exceeded'));
+      }, this.fileDeletionTimeout);
+      const watcher = (0, _fs.watch)(this.directory, (eventType, filename) => {
+        try {
+          if (eventType === 'rename' && filename === this.lockFileName) {
+            clearTimeout(timeout);
+            console.log(`Lock file deleted! Proceeding, worker index - ${process.env.TEST_WORKER_INDEX}`);
+            watcher.close();
+            resolve();
+          }
+        } catch (err) {
+          console.error(`Error watching for lock file deletion: ${err.message}`);
+          watcher.close();
+        }
+      });
+    });
+  }
+  async release() {
+    try {
+      if ((0, _fs.existsSync)(this.lockFilePath)) {
+        (0, _fs.unlinkSync)(this.lockFilePath);
+        console.log(`Lock file deleted: ${this.lockFilePath}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      }
+    } catch (err) {
+      console.error(`Error deleting lock file: ${err.message}, worker index - ${process.env.TEST_WORKER_INDEX}`);
+      throw err;
+    }
+  }
+}
+function _getLockFilePath() {
+  return _path.default.resolve(_path.default.join(this.directory, this.lockFileName));
+}
+async function _createDirectoryIfNotExist() {
+  if (!(0, _fs.existsSync)(this.directory)) {
+    (0, _fs.mkdirSync)(this.directory, {
+      recursive: true
+    });
+  }
+}
+var _default = exports.default = FileMutex;

package/build/core/playwright/helpers/getUserFixtures.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _logger = require("../../../utils/logger");
+var _readConfigFile = require("../readConfigFile");
+function getUserFixtures() {
+  const {
+    additionalPages
+  } = (0, _readConfigFile.generateConfigFromFile)();
+
+  // if (additionalPages.page || additionalPages.context) {
+  //   // Logger.log(
+  //   //   Logger.INFO_TYPE,
+  //   //   'Not allowed to override the page and context fixture. Use Test Setup in uat configuration'
+  //   // );
+  // }
+
+  return additionalPages;
+}
+var _default = exports.default = getUserFixtures;

package/build/core/playwright/helpers/mergeObjects.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeObjects = mergeObjects;
+// Utility function to merge objects using spread operator
+function mergeObjects(obj1, obj2) {
+  return {
+    ...obj1,
+    ...obj2
+  };
+}

package/build/core/playwright/helpers/parseUserArgs.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseUserArgs = parseUserArgs;
+var _cliArgsToObject = require("../../../utils/cliArgsToObject");
+function parseUserArgs() {
+  return (0, _cliArgsToObject.cliArgsToObject)(process.argv.slice(2));
+}

package/build/core/playwright/index.js

@@ -3,110 +3,22 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.When = exports.Then = exports.Given = void 0;
-Object.defineProperty(exports, "createBdd", {
+exports.createBdd = void 0;
+Object.defineProperty(exports, "expect", {
   enumerable: true,
   get: function () {
-    return _bddFramework.createBdd;
+    return _test.expect;
   }
 });
-Object.defineProperty(exports, "expect", {
+Object.defineProperty(exports, "test", {
   enumerable: true,
   get: function () {
-    return _test.expect;
+    return _playwrightBdd.test;
   }
 });
-exports.test = void 0;
-var _bddFramework = require("../../bdd-framework");
+var _playwrightBdd = require("playwright-bdd");
 var _test = require("@playwright/test");
-var _readConfigFile = require("./readConfigFile");
-// function test(descrition, callback) {
-//   return test(descrition, ({ page }) => {
-//     const { locator, ...custompage } = page
-//     callback({ page: custompage })
-//   })
-// }
-
-// class FilteredPage {
-//   constructor(page) {
-//     this.page = page;
-//     this.allowedMethods = ['getByText', 'getByTitle'];
-//     this.context = page.context;
-//   }
-
-//   goto(...args) {
-//     return this.page['goto'](...args);
-//   }
-
-//   getByRole(...args) {
-//     return this.page['getByRole'](...args);
-//   }
-// }
-
-// function FilteredPage(page) {
-//   return {
-//     getByRole: () => {
-//       throw new Error('You cannnot use getByRole property')
-//     }
-//   }
-// }
-const {
-  additionalPages = {},
-  bddMode
-} = (0, _readConfigFile.generateConfigFromFile)();
-let base = bddMode ? _bddFramework.test : _test.test;
-const test = base.extend({
-  page: async ({
-    page
-  }, use) => {
-    // const proxyPage = new Proxy(page, {
-    //   get: function (obj, prop) {
-    //     console.log('Gettig Priop', prop);
-    //     let filterMethod = FilteredPage(page)[prop];
-    //     if (filterMethod) {
-    //       return filterMethod;
-    //     } else {
-    //       return obj[prop] ? obj[prop] : 'property does not exist';
-    //     }
-    //   }
-    // })
-    page.getBaseUrl = function () {
-      if (process.env.mode === 'dev') {
-        return `${process.env.domain}?devURL=${process.env.devUrl}`;
-      }
-      return `${process.env.domain}`;
-    };
-    page.getCustomPageUrl = function (url) {
-      if (process.env.mode === 'dev') {
-        return `${process.env.domain}/${url}?devURL=${process.env.devUrl}`;
-      }
-      return `${process.env.domain}/${url}`;
-    };
-    await use(page);
-
-    //await use(new FilteredPage(page));
-
-    // await use(async (page) => {
-    //   delete page.getByTestId;
-    //   await page;
-    // });
-  },
-
-  context: async ({
-    context
-  }, use) => {
-    // eslint-disable-next-line no-undef
-    await context.addInitScript(() => window.localStorage.setItem('isDnBannerHide', true));
-    await use(context);
-  },
-  ...additionalPages
-});
-exports.test = test;
-const {
-  Given,
-  When,
-  Then
-} = (0, _bddFramework.createBdd)();
-exports.Then = Then;
-exports.When = When;
-exports.Given = Given;
+let createBdd = function () {
+  return (0, _playwrightBdd.createBdd)(_playwrightBdd.test);
+};
+exports.createBdd = createBdd;

package/build/core/playwright/readConfigFile.js

@@ -4,27 +4,93 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.fileName = void 0;
 exports.generateConfigFromFile = generateConfigFromFile;
 exports.getAuthFilePath = getAuthFilePath;
+exports.getDefaultConfig = getDefaultConfig;
 exports.isUserConfigFileAvailable = isUserConfigFileAvailable;
 var _fs = require("fs");
 var _path = _interopRequireDefault(require("path"));
 var _logger = require("../../utils/logger");
-const fileName = 'uat.config.js';
+var _configFileNameProvider = require("./helpers/configFileNameProvider");
+var _mergeObjects = require("./helpers/mergeObjects");
+var _Configuration = _interopRequireDefault(require("./configuration/Configuration"));
+var _UserArgs = _interopRequireDefault(require("./configuration/UserArgs"));
+var _ConfigurationHelper = require("./configuration/ConfigurationHelper");
+let cachedConfig = null;
+function getDefaultConfig() {
+  return {
+    isTearDown: true,
+    uatDirectory: _path.default.join(process.cwd(), 'uat'),
+    headless: false,
+    browsers: ['Chrome'],
+    forbidOnly: false,
+    retries: 0,
+    trace: false,
+    video: false,
+    isAuthMode: false,
+    openReportOn: 'never',
+    reportPath: _path.default.join(process.cwd(), 'uat', 'playwright-report'),
+    bddMode: false,
+    expectTimeout: 5 * 1000,
+    testTimeout: 60 * 1000,
+    authFilePath: 'uat/playwright/.auth/user.json',
+    viewport: {
+      width: 1280,
+      height: 720
+    },
+    debug: false,
+    testIdAttribute: 'data-testid',
+    additionalPages: {},
+    featureFilesFolder: 'feature-files',
+    stepDefinitionsFolder: 'steps',
+    testSetup: {},
+    editionOrder: ['Free', 'Express', 'Standard', 'Professional', 'Enterprise']
+  };
+}
+function combineDefaultConfigWithUserConfig(userConfiguration) {
+  let defaultConfig = getDefaultConfig();
+  let configurationObj = {};
+  Object.keys(userConfiguration).forEach(configKey => {
+    let configValue = userConfiguration[configKey];
+    if (configValue !== null && configValue !== undefined) {
+      configurationObj[configKey] = configValue;
+    } else if (defaultConfig[configKey]) {
+      configurationObj[configKey] = defaultConfig[configKey];
+    } else {
+      _logger.Logger.log(_logger.Logger.INFO_TYPE, `key - ${configKey} is not yet supported in uat configuration. This will not be used while creating playwright configuration`);
+    }
+  });
+  return (0, _mergeObjects.mergeObjects)(defaultConfig, configurationObj);
+}
+/**
+ * @typedef {Object|null} viewportConfig
+ * @property {number} width - width of the viewport
+ * @property {number} height - height of the viewport
+ */
+/**
+ * @typedef {Object|null} viewportConfig
+ * @property {number} width - width of the viewport
+ * @property {number} height - height of the viewport
+ */
+
+/**
+ * @typedef {Object|null} testSetupConfig
+ * @property {any} page - Function that will be called while setting up page fixtures
+ * @property {any} context - Function that will be called while setting up context fixtures
+ */
 
 /**
  * Represents the user configuration object.
  * @typedef {Object} UserConfig
+ * @property {string} uatDirectory - Directory in which uat configuration is places.
  * @property {string} headless - Headless Browsers mode.
  * @property {number} trace - trace for test cases.
  * @property {boolean} video - video for test cases,
  * @property {boolean} debug - debug mode
- * @property {string} mode: mode in which the test cases needs to run
- * @property {boolean} isAuthMode -  Auth Mode
+ * @property {boolean} isAuthMode -  Auth Mode. config whether authentication step needed before running test cases
  * @property {string} authFilePath - File Path where the cookies stored
  * @property {any} browsers: List of browsers
- * @property {string} openReportOn: default Option value (never, on-failure and always) 
+ * @property {string} openReportOn: default Option value (never, on-failure and always)
  * @property {any} reportPath : directory where report is generate
  * @property {boolean} bddMode: Feature files needs to be processed
  * @property {number} expectTimeout: time in milliseconds which the expect condition should fail
@@ -32,25 +98,37 @@ const fileName = 'uat.config.js';
  * @property {Object} additionalPages: custom pages configuration
  * @property {string} featureFilesFolder: folder name under which feature-files will be placed. Default is feature-files
  * @property {string} stepDefinitionsFolder: folder name under which step implementations will be placed. Default is steps
+ * @property {viewportConfig} viewport: viewport configuration for the browser. Default is { width: 1280, height: 720 }
+ * @property {string} testIdAttribute: Change the default data-testid attribute. configure what attribute to search while calling getByTestId
+ * @property {Array} editionOrder: Order in the form of larger editions in the back. Edition with the most privelages should be last
+ * @property {testSetupConfig} testSetup: Specify page and context functions that will be called while intilaizing fixtures.
  */
 
 /**
  * Generates a configuration object from a file, if it exists.
  *
  * @returns {UserConfig}
-*/
-exports.fileName = fileName;
+ */
+
+function getConfigFilePath() {
+  return _path.default.resolve(process.cwd(), (0, _configFileNameProvider.getUATFileName)());
+}
 function generateConfigFromFile() {
-  const filePath = _path.default.resolve(process.cwd(), fileName);
-  if ((0, _fs.existsSync)(filePath)) {
-    /** @type {UserConfig} */
-    const config = require(filePath);
-    return config;
+  if (cachedConfig === null) {
+    // Getting the default config's from framework
+    const uatConfig = new _Configuration.default(getDefaultConfig());
+    // overriding the application config's from project
+    const appConfig = new _Configuration.default((0, _ConfigurationHelper.getApplicationConfig)());
+    const userArgConfig = new _Configuration.default(_UserArgs.default.parseToObject(process.argv.slice(2)));
+    // overriding the user config's from CLI
+    uatConfig.addAll(appConfig);
+    uatConfig.addAll(userArgConfig);
+    cachedConfig = uatConfig.getAll();
   }
-  return {};
+  return cachedConfig;
 }
 function isUserConfigFileAvailable() {
-  const filePath = _path.default.resolve(process.cwd(), fileName);
+  const filePath = getConfigFilePath();
   if ((0, _fs.existsSync)(filePath)) {
     return true;
   }
@@ -65,5 +143,6 @@ function getAuthFilePath(filePath) {
     }
   } catch (err) {
     _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Founded Path - ${filePath} Authetication file not Exist ...`);
+    _logger.Logger.error(err);
   }
 }

package/build/core/playwright/report-generator.js

@@ -10,14 +10,15 @@ var _path = _interopRequireDefault(require("path"));
 var _logger = require("../../utils/logger");
 var _rootPath = require("../../utils/rootPath");
 var _readConfigFile = require("./readConfigFile");
-const userArgs = process.argv.slice(3);
-const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
-const command = playwrightPath;
-const {
-  reportPath: htmlPath = _path.default.resolve(process.cwd(), 'uat', './playwright-report')
-} = (0, _readConfigFile.generateConfigFromFile)();
-const args = ['show-report', htmlPath].concat(userArgs);
-function generateReport() {
+async function generateReport() {
+  // await preProcessReport()
+  const userArgs = process.argv.slice(3);
+  const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+  const command = playwrightPath;
+  const {
+    reportPath: htmlPath
+  } = (0, _readConfigFile.generateConfigFromFile)();
+  const args = ['show-report', htmlPath].concat(userArgs);
   const childProcess = (0, _child_process.spawn)(command, args, {
     stdio: 'inherit'
   });

package/build/core/playwright/runner/Runner.js

@@ -0,0 +1,22 @@
+"use strict";
+
+class Runner {
+  constructor(config) {
+    this.tagArgs = "";
+    this.userArgs = "";
+    this.config = config;
+  }
+  setUserArgs(userArgs) {
+    this.userArgs = userArgs;
+  }
+  setTagArgs(tagArgs) {
+    this.tagArgs = tagArgs;
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  run() {
+    throw new Error("Method 'run()' must be implemented.");
+  }
+}
+module.exports = Runner;

package/build/core/playwright/runner/RunnerHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _RunnerTypes = _interopRequireDefault(require("./RunnerTypes"));
+var _configUtils = require("../setup/config-utils");
+var _cliArgsToObject = require("../../../utils/cliArgsToObject");
+var _browserTypes = require("../constants/browserTypes");
+var _customCommands = require("../custom-commands");
+class RunnerHelper {
+  static createRunner(type, runnerObj) {
+    const runnerClass = _RunnerTypes.default.getRunnerClass(type, runnerObj);
+    if (!runnerClass) {
+      throw new Error("Invalid runner type");
+    }
+    return runnerClass;
+  }
+  static getPlaywrightArgs(userArgsObject, debug, bddMode, tagArgs, headless) {
+    const {
+      browsers = null
+    } = userArgsObject;
+    let browserList = (0, _configUtils.getBrowsersList)(browsers);
+    const playwrightArgs = (0, _cliArgsToObject.objectToCliArgs)(userArgsObject, key => !_customCommands.CUSTOM_COMMANDS.includes(key));
+    if (debug) {
+      playwrightArgs.push('--debug');
+    }
+    if (!bddMode && tagArgs) {
+      playwrightArgs.push('--grep');
+      playwrightArgs.push(tagArgs);
+    }
+    if (!headless && !userArgsObject.headed) {
+      playwrightArgs.push('--headed');
+    }
+    if (browserList && browserList.length > 0) {
+      browserList.map(browser => playwrightArgs.push(`--project=${_browserTypes.BROWSER_PROJECT_MAPPING[browser.toUpperCase()]}`));
+    }
+    return playwrightArgs;
+  }
+}
+var _default = exports.default = RunnerHelper;

package/build/core/playwright/runner/RunnerTypes.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _SpawnRunner = _interopRequireDefault(require("./SpawnRunner"));
+class RunnerTypes {
+  static getRunnerClass(type, runnerObj) {
+    const RunnerClass = this.runnerTypes[type];
+    if (!RunnerClass) {
+      throw new Error("Invalid runner type");
+    }
+    return new RunnerClass(runnerObj);
+  }
+  static runnerTypes = {
+    spawn: _SpawnRunner.default //require("./SpawnRunner"), // used lazy loading to reduce circular dependencies 
+  };
+}
+module.exports = RunnerTypes;

package/build/core/playwright/runner/SpawnRunner.js

@@ -0,0 +1,113 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _readConfigFile = require("../readConfigFile");
+var _rootPath = require("../../../utils/rootPath");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../../utils/logger");
+var _child_process = require("child_process");
+var _RunnerHelper = _interopRequireDefault(require("./RunnerHelper"));
+var _Runner = _interopRequireDefault(require("./Runner"));
+var _commonUtils = require("../../../utils/commonUtils");
+class SpawnRunner extends _Runner.default {
+  constructor(runnerObj) {
+    super(runnerObj);
+    this.runnerObj = runnerObj;
+  }
+  run() {
+    const {
+      config
+    } = this.runnerObj;
+    let promises = [];
+    const {
+      bddMode
+    } = config.getAll();
+    if (bddMode) {
+      promises.push(this.runPreprocessing());
+    }
+    Promise.all(promises).then(() => this.runPlaywright()).catch(err => {
+      _logger.Logger.error(err);
+      process.exit();
+    });
+  }
+  runPreprocessing() {
+    //This below functoin is called to copy the data generator spec files to the current project
+    (0, _commonUtils.copyCommonSpecs)();
+    const {
+      tagArgs
+    } = this.runnerObj;
+    const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? _path.default.resolve(__dirname, '../', 'setup', 'config-creator.js') : _path.default.resolve(__dirname, '../', '../', '../', '../', 'playwrightConfig.js');
+    const beforeCommand = 'node';
+    const bddGenPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('bddgen'));
+    const beforeArgs = [bddGenPath, '-c', require.resolve(configPath)];
+    if (tagArgs) {
+      beforeArgs.push('--tags');
+      beforeArgs.push(tagArgs);
+    }
+    return new Promise((resolve, reject) => {
+      const childProcessForPreprocessing = (0, _child_process.spawn)(beforeCommand, beforeArgs, {
+        stdio: 'inherit',
+        env: {
+          ...process.env
+        }
+      });
+      childProcessForPreprocessing.on('error', data => {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, data);
+        reject(data);
+      });
+      childProcessForPreprocessing.on('exit', code => {
+        if (code === 0) {
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Feature Files Processed Successfully');
+          resolve();
+        } else {
+          reject(`BddGen exited with code ${code}`);
+        }
+      });
+    });
+  }
+  runPlaywright() {
+    const {
+      tagArgs,
+      config,
+      userArgs
+    } = this.runnerObj;
+    const {
+      debug,
+      bddMode = false,
+      headless = false
+    } = config.getAll();
+    const playwrightArgs = _RunnerHelper.default.getPlaywrightArgs(userArgs, debug, bddMode, tagArgs, headless);
+    const playwrightPath = _path.default.resolve((0, _rootPath.getExecutableBinaryPath)('playwright'));
+    const command = playwrightPath;
+    const configPath = (0, _readConfigFile.isUserConfigFileAvailable)() ? _path.default.resolve(__dirname, '../', 'setup', 'config-creator.js') : _path.default.resolve('../', '../', '../', '../', 'playwrightConfig.js');
+    const args = ['test', '--config', require.resolve(configPath)].concat(playwrightArgs);
+    return new Promise((resolve, reject) => {
+      const childProcessForRunningPlaywright = (0, _child_process.spawn)(command, args, {
+        stdio: 'inherit',
+        env: {
+          ...process.env
+        }
+      });
+      childProcessForRunningPlaywright.on('error', error => {
+        _logger.Logger.log(_logger.Logger.FAILURE_TYPE, error);
+      });
+      childProcessForRunningPlaywright.on('exit', (code, signal) => {
+        if (code !== 0) {
+          reject(`Child Process Exited with Code ${code} and Signal ${signal}`);
+        } else {
+          _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Test Ran Successfully');
+          resolve();
+        }
+      });
+      process.on('exit', () => {
+        childProcessForRunningPlaywright.kill();
+        reject('Terminating Playwright Process...');
+      });
+      process.on('SIGINT', () => {
+        childProcessForRunningPlaywright.kill();
+        reject('Cleaning up...');
+      });
+    });
+  }
+}
+module.exports = SpawnRunner;