@zohodesk/testinglibrary 0.1.8-exp.4 → 0.1.8-stb-bdd-v1

package/build/bdd-poc/test/cucumber/featureFileParer.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseFeature = parseFeature;
+var _parserCucumber = _interopRequireDefault(require("./parserCucumber"));
+function parseFeature(featureFileContent) {
+  var _gherkinDocument$feat;
+  var gherkinDocument = (0, _parserCucumber.default)(featureFileContent);
+  var currentFeature = {
+    feature: "",
+    featureTags: [],
+    scenarios: [],
+    featureBackGround: []
+  };
+  var isBackgroundExist;
+  currentFeature.feature = gherkinDocument.feature.name;
+  currentFeature.featureTags = (_gherkinDocument$feat = gherkinDocument.feature) === null || _gherkinDocument$feat === void 0 ? void 0 : _gherkinDocument$feat.tags.map(tag => tag.name);
+  gherkinDocument.feature.children.forEach($scenario => {
+    var _$scenario$scenario, _$scenario$scenario2, _$scenario$scenario3, _$scenario$scenario4;
+    var scenarioSteps = {
+      scenariodescription: "",
+      steps: [],
+      tablebody: false,
+      tableheader: false,
+      examples: [],
+      scenarioTags: [],
+      background: []
+    };
+    scenarioSteps.scenariodescription = (_$scenario$scenario = $scenario.scenario) === null || _$scenario$scenario === void 0 ? void 0 : _$scenario$scenario.name;
+    if ($scenario !== null && $scenario !== void 0 && $scenario.background) {
+      isBackgroundExist = $scenario.background.steps.map(element => {
+        return {
+          stepDescription: element.text,
+          keyword: element.keyword
+        };
+      });
+      return;
+    }
+    (_$scenario$scenario2 = $scenario.scenario) === null || _$scenario$scenario2 === void 0 || _$scenario$scenario2.examples.map(example => {
+      var _example$tableHeader;
+      scenarioSteps.tablebody = example === null || example === void 0 ? void 0 : example.tableBody.map(cell => {
+        return cell === null || cell === void 0 ? void 0 : cell.cells.map(example => example.value);
+      });
+      scenarioSteps.tableheader = example === null || example === void 0 || (_example$tableHeader = example.tableHeader) === null || _example$tableHeader === void 0 ? void 0 : _example$tableHeader.cells.map(exampleHead => {
+        return exampleHead.value;
+      });
+    });
+    if (scenarioSteps.tablebody && scenarioSteps.tableheader) {
+      scenarioSteps.examples = testDataExtraction(scenarioSteps.tableheader, scenarioSteps.tablebody);
+    } else {
+      scenarioSteps.examples = false;
+    }
+    scenarioSteps.scenarioTags = (_$scenario$scenario3 = $scenario.scenario) === null || _$scenario$scenario3 === void 0 ? void 0 : _$scenario$scenario3.tags.map(tag => tag.name);
+    const _scenarioDescription = $scenario === null || $scenario === void 0 || (_$scenario$scenario4 = $scenario.scenario) === null || _$scenario$scenario4 === void 0 ? void 0 : _$scenario$scenario4.steps.map(step => {
+      return {
+        stepDescription: step.text,
+        keyword: step.keyword
+      };
+    });
+    scenarioSteps.steps = _scenarioDescription;
+    scenarioSteps.background = isBackgroundExist || [];
+    currentFeature.scenarios.push(scenarioSteps);
+  });
+  currentFeature.featureBackGround = currentFeature.scenarios[0].background;
+  return currentFeature;
+}
+function testDataExtraction(tableHeader, tableBody) {
+  const result = [];
+  if (tableBody && tableHeader) {
+    tableBody.forEach(array => {
+      const obj = {};
+      array.forEach((item, index) => {
+        obj[`<${tableHeader[index]}>`] = item;
+      });
+      result.push(obj);
+    });
+  } else {
+    return;
+  }
+  return result;
+}

package/build/bdd-poc/test/cucumber/parserCucumber.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = CucumberParser;
+var _gherkin = require("@cucumber/gherkin");
+var _messages = require("@cucumber/messages");
+function CucumberParser(content) {
+  var uuidFn = _messages.IdGenerator.uuid();
+  var builder = new _gherkin.AstBuilder(uuidFn);
+  var matcher = new _gherkin.GherkinClassicTokenMatcher();
+  var parser = new _gherkin.Parser(builder, matcher);
+  return parser.parse(content);
+}

package/build/bdd-poc/test/stepGenerate/extractTestInputs.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readStepFile = readStepFile;
+var _fastGlob = _interopRequireDefault(require("fast-glob"));
+var _fileUtils = require("../../../utils/fileUtils");
+var _path = _interopRequireDefault(require("path"));
+var _pathConfig = require("../../config/pathConfig");
+globalThis.inputsParamterMap = new Map();
+async function readStepFile() {
+  const stepFilePath = (0, _pathConfig.getStepFilePath)();
+  const processedSpecFile = [];
+  return new Promise(resolve => {
+    _fastGlob.default.globSync(stepFilePath, {
+      dot: true,
+      cwd: process.cwd()
+    }).forEach(filePath => {
+      processedSpecFile.push(extractBrowserObjects(filePath));
+    });
+    Promise.all(processedSpecFile);
+    resolve(inputsParamterMap);
+  });
+}
+function extractBrowserObjects(filePath) {
+  const code = (0, _fileUtils.readFileContents)(_path.default.resolve(process.cwd(), filePath), 'utf-8');
+  code.split('\n').forEach(step => {
+    const trimmedStep = step.trim();
+    if (trimmedStep.startsWith('Given') || trimmedStep.startsWith('When') || trimmedStep.startsWith('Then') || trimmedStep.startsWith('And') || trimmedStep.startsWith('Step')) {
+      var sortedSpecInput = trimmedStep.split(' ').slice(1).join('').match(/\((.*?)\)/)[1].match(/\{(.*?)\}/g) || [];
+      inputsParamterMap.set(trimmedStep.replace(/"/g, `'`).match(/'(.*?)'/g).pop(), sortedSpecInput.pop());
+    }
+  });
+}

package/build/bdd-poc/test/stepGenerate/stepFileGenerate.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateSpecFiles = generateSpecFiles;
+var _fastGlob = _interopRequireDefault(require("fast-glob"));
+var _path = _interopRequireDefault(require("path"));
+var _featureFileParer = require("../cucumber/featureFileParer");
+var _testStructure = require("../testStructure");
+var _fileUtils = require("../../../utils/fileUtils");
+var _extractTestInputs = require("./extractTestInputs");
+var _pathConfig = require("../../config/pathConfig");
+function stepFileCreation(featureContent, stepFilename, featureFilePath) {
+  const stepsFilePath = _path.default.resolve(process.cwd(), 'uat', 'feature-gen', stepFilename);
+  const stepsSnippets = (0, _testStructure.testSnippet)(featureContent, featureFilePath);
+  (0, _fileUtils.writeFileContents)(stepsFilePath, stepsSnippets);
+}
+async function generateSpecFiles() {
+  const featureFilePattern = (0, _pathConfig.getFeatureFilePath)();
+  const generatedFolderPath = _path.default.resolve(process.cwd(), 'uat', 'feature-gen');
+  if (!(0, _fileUtils.checkIfFileExists)(generatedFolderPath)) {
+    (0, _fileUtils.createFolderSync)(generatedFolderPath, {
+      recursive: true
+    });
+  }
+  await (0, _extractTestInputs.readStepFile)();
+  _fastGlob.default.globSync(featureFilePattern, {
+    dot: true,
+    cwd: process.cwd()
+  }).forEach(filePath => {
+    const featurefilePath = _path.default.resolve(process.cwd(), filePath);
+    const featureContent = (0, _featureFileParer.parseFeature)((0, _fileUtils.readFileContents)(featurefilePath, 'utf-8'));
+    const fileName = _path.default.basename(filePath).replace('.feature', '.spec.js');
+    stepFileCreation(featureContent, fileName, filePath);
+  });
+}

package/build/bdd-poc/test/stepGenerate/stepsnippets.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TESTING_LIBRARY = void 0;
+exports.testBackGround = testBackGround;
+exports.testCase = testCase;
+exports.testFile = testFile;
+exports.testStep = testStep;
+exports.testSuite = testSuite;
+const TESTING_LIBRARY = exports.TESTING_LIBRARY = '@zohodesk/testinglibrary';
+function testStep(keyword, description, browserObject, testData, options) {
+  return `await $${keyword}('${description}')(${browserObject},${testData})\n`;
+}
+function testSuite(description, scenariotestBlock, tags, options = null) {
+  return `\ntest.describe('${description}${tags.join(" ")}', () => {
+    ${scenariotestBlock}
+  })`;
+}
+function testCase(steps, examples, description, browserObjects, tags, option) {
+  if (examples.length >= 1) {
+    const exmapleScenario = examples.map(($ele, index) => {
+      var exampleDescription = Object.values($ele).map(val => {
+        return val.concat('-');
+      });
+      let avoidRepitationDescription = exampleDescription.join('').concat(`Example-${index + 1}`);
+      return testBlock(avoidRepitationDescription, steps, browserObjects);
+    });
+    return testSuite(description, exmapleScenario.join('\n'), tags);
+  }
+  return testSuite(`${description}-title`, testBlock(description, steps, browserObjects), tags);
+}
+function testBlock(description, steps, browserObjects) {
+  return `\ntest("${description}", async({${browserObjects.join(',')}}) => {
+    ${steps.join(`\n\t`)}
+  })`;
+}
+function testFile(testCase, relativeFilePath, $tags, backgroundScenario = " ", options = null) {
+  return ` // ${relativeFilePath}
+    import { test, createNativeBDD } from "${TESTING_LIBRARY}";
+    const {$Given,$When,$Then,$And} = createNativeBDD()  
+    \n
+    test.use({
+      $test: ({}, use) => use(test),
+      $tags: ({}, use, testInfo) => use(${JSON.stringify($tags)} \n [testInfo.titlePath.slice(2).join("|")] || [])
+     })
+     \n
+     ${backgroundScenario}
+     \n
+     ${testCase.join('')}
+    `;
+}
+function testBackGround(backgroundSteps, inputs) {
+  return ` test.beforeEach(async ({${inputs.join(',')}}) => { \n
+      ${backgroundSteps.join(`\n`)}
+    });`;
+}

package/build/bdd-poc/test/tagsHandle.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.allowedTags = allowedTags;
+exports.expressionHandle = expressionHandle;
+var _tagProcessor = require("../../core/playwright/tag-processor");
+const editionOrder = ['Free', 'Express', 'Standard', 'Professional', 'Enterprise'];
+function allowedTags(userArgs) {
+  let tags = (userArgs === null || userArgs === void 0 ? void 0 : userArgs.tags) || null;
+  if (tags !== null) {
+    if (Array.isArray(tags)) {
+      return buildGrepTags(tags, '|');
+    }
+    return tags;
+  }
+  let edition = (userArgs === null || userArgs === void 0 ? void 0 : userArgs.edition) || null;
+  if (edition !== null) {
+    const editionFrmCli = edition.split(',');
+    if (editionFrmCli.length === 1) {
+      // const sortedEdition = editionPreprocessing(editionOrder,editionFrmCli)
+      return (0, _tagProcessor.buildEditionTags)(expressionHandle(editionFrmCli, editionOrder), '|');
+    }
+  }
+  return;
+}
+function buildGrepTags(tags, operator) {
+  return tags.join(`${operator}`);
+}
+function expressionHandle(editionFrmCli, editionOrder) {
+  var expression;
+  var $edition;
+  if (editionFrmCli.split('=').length !== 1) {
+    expression = editionFrmCli.split('').slice(0, 2).join('');
+    $edition = editionFrmCli.split('=').pop();
+  } else if (editionFrmCli.split('>').length !== 1) {
+    expression = editionFrmCli.split('').slice(0, 1).join('');
+    $edition = editionFrmCli.split('>').pop();
+  } else {
+    expression = editionFrmCli.split('').slice(0, 1).join('');
+    $edition = editionFrmCli.split('<').pop();
+  }
+  const index_Edition = editionOrder.indexOf($edition);
+  switch (expression) {
+    case '>=':
+      if ($edition == editionOrder[editionOrder.length - 1]) {
+        return editionOrder[editionOrder.length - 1];
+      }
+      return editionOrder.slice(0, index_Edition);
+    case '<=':
+      if ($edition == editionOrder[0]) {
+        return editionOrder.slice(1, editionOrder.length + 1);
+      }
+      return editionOrder.slice(index_Edition + 1, editionOrder.length + 1);
+    case '<':
+      if ($edition == editionOrder[0]) {
+        return editionOrder;
+      }
+      return editionOrder.slice(index_Edition, editionOrder.length + 1);
+    case '>':
+      if ($edition == editionOrder[editionOrder.length - 1]) {
+        return editionOrder;
+      }
+      return editionOrder.slice(0, index_Edition + 1);
+    default:
+      break;
+  }
+}

package/build/bdd-poc/test/testDataMap.js

@@ -0,0 +1,97 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.testDataCreation = testDataCreation;
+var _fastGlob = _interopRequireDefault(require("fast-glob"));
+var _testStructure = require("./testStructure");
+var _fileUtils = require("../../utils/fileUtils");
+var _path = _interopRequireDefault(require("path"));
+var _parserCucumber = _interopRequireDefault(require("./cucumber/parserCucumber"));
+var _pathConfig = require("../config/pathConfig");
+async function testDataCreation() {
+  var exampleSteps = [];
+  const globalTestdata = new Map();
+  const testDataFeatureFilePath = (0, _pathConfig.getFeatureFilePath)();
+  await _fastGlob.default.globSync(testDataFeatureFilePath, {
+    dot: true,
+    cwd: process.cwd()
+  }).forEach(filePath => {
+    var body, header;
+    var gherkinDocument = (0, _parserCucumber.default)((0, _fileUtils.readFileContents)(_path.default.resolve(process.cwd(), filePath), 'utf-8'));
+    gherkinDocument.feature.children.forEach($scenario => {
+      var _$scenario$scenario, _$scenario$scenario2;
+      const $currentScenario = {
+        currentArgument: '',
+        dataTableStep: '',
+        inputParameter: '',
+        input: false,
+        steptable: false,
+        scenarioTable: false
+      };
+      (_$scenario$scenario = $scenario.scenario) === null || _$scenario$scenario === void 0 || _$scenario$scenario.steps.forEach(step => {
+        var _step$dataTable;
+        const {
+          refactoredStep,
+          currentArgument
+        } = (0, _testStructure.extactStepArgs)(step.text);
+        if (Object.values(currentArgument).length && !$scenario.scenario.examples.length) {
+          $currentScenario.currentArgument = currentArgument;
+          $currentScenario.input = true;
+        } else {
+          globalTestdata.set(refactoredStep, {});
+        }
+        const dataTableStep = [];
+        step === null || step === void 0 || (_step$dataTable = step.dataTable) === null || _step$dataTable === void 0 || _step$dataTable.rows.forEach(cell => {
+          const Table = cell.cells.map(element => element.value);
+          dataTableStep.push(Table);
+        });
+        if (step.dataTable) {
+          $currentScenario.dataTableStep = dataTableStep;
+          $currentScenario.steptable = true;
+        }
+        globalTestdata.set(refactoredStep, Object.assign({}, $currentScenario));
+      });
+      if (typeof $scenario.background === Object) {
+        return;
+      }
+      if ((_$scenario$scenario2 = $scenario.scenario) !== null && _$scenario$scenario2 !== void 0 && (_$scenario$scenario2 = _$scenario$scenario2.examples) !== null && _$scenario$scenario2 !== void 0 && _$scenario$scenario2.length) {
+        var _$scenario$scenario3;
+        exampleSteps = $scenario.scenario.steps.map(element => (0, _testStructure.extactStepArgs)(element.text).refactoredStep);
+        (_$scenario$scenario3 = $scenario.scenario) === null || _$scenario$scenario3 === void 0 || _$scenario$scenario3.examples.map(example => {
+          var _example$tableHeader;
+          body = example === null || example === void 0 ? void 0 : example.tableBody.map(cell => {
+            return cell === null || cell === void 0 ? void 0 : cell.cells.map(example => example.value);
+          });
+          header = example === null || example === void 0 || (_example$tableHeader = example.tableHeader) === null || _example$tableHeader === void 0 ? void 0 : _example$tableHeader.cells.map(exampleHead => {
+            return exampleHead.value;
+          });
+        });
+        const inputParameter = testDataExtraction(header, body);
+        exampleSteps.forEach(step => {
+          $currentScenario.inputParameter = Object.assign([], inputParameter);
+          $currentScenario.scenarioTable = true;
+          globalTestdata.set(step, Object.assign({}, $currentScenario));
+        });
+      }
+    });
+  });
+  return globalTestdata;
+}
+function testDataExtraction(tableHeader, tableBody) {
+  const result = [];
+  if (tableBody && tableHeader) {
+    tableBody.forEach(array => {
+      const obj = {};
+      array.forEach((item, index) => {
+        obj[`${tableHeader[index].replace(/\s/g, '')}`] = item;
+      });
+      result.push(obj);
+    });
+  } else {
+    return;
+  }
+  return [...result];
+}

package/build/bdd-poc/test/testStructure.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extactStepArgs = extactStepArgs;
+exports.testSnippet = testSnippet;
+var _stringManipulation = require("../utils/stringManipulation");
+var _stepsnippets = require("./stepGenerate/stepsnippets");
+function testSnippet(featureContent, featureFilePath) {
+  var _featureContent$featu;
+  var currentScenarios = [];
+  var $tags = {};
+  featureContent.scenarios.forEach(scenario => {
+    scenario.scenarioTags = [...scenario.scenarioTags, ...featureContent.featureTags];
+    $tags = Object.assign($tags, handleInputTags(scenario));
+    const _constructStep = scenarioSnippet(scenario);
+    currentScenarios.push(_constructStep);
+  });
+  if ((_featureContent$featu = featureContent.featureBackGround) !== null && _featureContent$featu !== void 0 && _featureContent$featu.length) {
+    return (0, _stepsnippets.testFile)(currentScenarios, featureFilePath, $tags, backgroundHandle(featureContent.featureBackGround));
+  }
+  return (0, _stepsnippets.testFile)(currentScenarios, featureFilePath, $tags);
+}
+function extactStepArgs(step) {
+  var inputParam = [];
+  var currentArgument = {};
+  var refactoredStep = step.replace(/"([^"]+)"/g, (match, word) => {
+    if (!isNaN(Number(word))) {
+      inputParam.push(word.toString());
+      return '{int}';
+    } else {
+      inputParam.push(word.toString());
+      return '{string}';
+    }
+  });
+  currentArgument = inputParam.map(inputs => `"${(0, _stringManipulation.removeAll)(inputs, ['<', '>'], /\s/g)}"`);
+  return {
+    refactoredStep,
+    currentArgument
+  };
+}
+function scenarioSnippet(scenario) {
+  var currentStep = [];
+  var currentInputs = [];
+  scenario.steps.forEach(step => {
+    var {
+      refactoredStep,
+      currentArgument
+    } = extactStepArgs(step.stepDescription);
+    var input = inputsParamterMap.get(`'${refactoredStep}'`);
+    currentInputs.push(input);
+    currentStep.push((0, _stepsnippets.testStep)(step.keyword, refactoredStep, input, currentArgument.join(',')));
+    return;
+  });
+  const pageObject = browserObjectHandle(currentInputs);
+  return (0, _stepsnippets.testCase)(currentStep, scenario === null || scenario === void 0 ? void 0 : scenario.examples, scenario === null || scenario === void 0 ? void 0 : scenario.scenariodescription, pageObject, scenario.scenarioTags);
+}
+function browserObjectHandle(arrayofBrowserObjects) {
+  var browserInputs = [];
+  arrayofBrowserObjects.forEach(pageObject => {
+    browserInputs = [...browserInputs, ...(0, _stringManipulation.removeAll)(pageObject, ['{', '}']).split(',')];
+  });
+  return (0, _stringManipulation.avoidDuplicate)(browserInputs);
+}
+function handleInputTags(scenario) {
+  var _scenario$examples;
+  if (((_scenario$examples = scenario.examples) === null || _scenario$examples === void 0 ? void 0 : _scenario$examples.length) >= 1) {
+    var _tagsObjects = {};
+    scenario.examples.forEach(($ele, index) => {
+      var exampleDescription = Object.values($ele).map(val => {
+        return val.concat('-');
+      });
+      Object.assign(_tagsObjects, {
+        [exampleDescription.join('').concat(`Example-${index + 1}`)]: scenario.scenarioTags
+      });
+    });
+    return _tagsObjects;
+  }
+  return {
+    [scenario.scenariodescription]: scenario.scenarioTags
+  };
+}
+function backgroundHandle(background) {
+  const currentBackground = [];
+  const backgroundInput = [];
+  background.forEach(b_scenario => {
+    var {
+      refactoredStep,
+      currentArgument
+    } = extactStepArgs(b_scenario.stepDescription);
+    var input = inputsParamterMap.get(`'${refactoredStep}'`);
+    backgroundInput.push(input);
+    currentBackground.push((0, _stepsnippets.testStep)(b_scenario.keyword, refactoredStep, input, currentArgument.join(',')));
+    return;
+  });
+  return (0, _stepsnippets.testBackGround)(currentBackground, browserObjectHandle(backgroundInput));
+}

package/build/bdd-poc/utils/stringManipulation.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.avoidDuplicate = avoidDuplicate;
+exports.filePathPattern = filePathPattern;
+exports.removeAll = removeAll;
+function removeAll(InputString, toRemove, regex = undefined, options = null) {
+  if (regex) {
+    InputString = InputString.replace(regex, '').trim();
+  }
+  toRemove.forEach(ele => {
+    InputString = InputString.replace(ele, '').trim();
+  });
+  return InputString;
+}
+function avoidDuplicate(arrayOfInputs) {
+  return [...new Set(arrayOfInputs)];
+}
+function filePathPattern(filePath, isWindows = true) {
+  if (isWindows) {
+    return filePath.split('\\').join('/');
+  }
+  return filePath;
+}

package/build/core/playwright/builtInFixtures/addTags.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _default = exports.default = {
   addTags: [async ({
-    $tags
+    $tags = []
   }, use, testInfo) => {
     testInfo.annotations.push({
       type: 'tags',

package/build/core/playwright/builtInFixtures/index.js

@@ -8,7 +8,8 @@ exports.default = void 0;
 var _page = _interopRequireDefault(require("./page"));
 var _context = _interopRequireDefault(require("./context"));
 var _cacheLayer = _interopRequireDefault(require("./cacheLayer"));
-var _addTags = _interopRequireDefault(require("./addTags"));
+// import addTags from './addTags';
+
 function getBuiltInFixtures(bddMode) {
   let builtInFixtures = {
     ..._page.default,
@@ -17,8 +18,8 @@ function getBuiltInFixtures(bddMode) {
   };
   if (bddMode) {
     builtInFixtures = {
-      ...builtInFixtures,
-      ..._addTags.default
+      ...builtInFixtures
+      // ...addTags
     };
   }
   return builtInFixtures;

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

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

package/build/core/playwright/index.js

@@ -4,13 +4,6 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.When = exports.Then = exports.Given = void 0;
-Object.defineProperty(exports, "createBdd", {
-  enumerable: true,
-  get: function () {
-    return _bddFramework.createBdd;
-  }
-});
 Object.defineProperty(exports, "expect", {
   enumerable: true,
   get: function () {
@@ -18,25 +11,21 @@ Object.defineProperty(exports, "expect", {
   }
 });
 exports.test = void 0;
-var _bddFramework = require("../../bdd-framework");
 var _test = require("@playwright/test");
 var _readConfigFile = require("./readConfigFile");
 var _builtInFixtures = _interopRequireDefault(require("./builtInFixtures"));
+// import { createBdd, test as bddBase } from '../../bdd-framework';
+
 const {
   additionalPages: userFixtures,
   bddMode
 } = (0, _readConfigFile.generateConfigFromFile)();
-let base = bddMode ? _bddFramework.test : _test.test;
+// In house BDD testing. so, use playwright test
+let base = _test.test;
 const buildInFixtures = (0, _builtInFixtures.default)(bddMode);
 const test = exports.test = base.extend({
   ...buildInFixtures,
   ...userFixtures
 });
-const {
-  Given,
-  When,
-  Then
-} = (0, _bddFramework.createBdd)();
-exports.Then = Then;
-exports.When = When;
-exports.Given = Given;
+
+// const { Given, When, Then } = createBdd();