@zohodesk/testinglibrary 0.0.4 → 0.0.5-exp.10

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

@@ -0,0 +1,110 @@
+"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");
+/**
+ * Define steps via decorators.
+ */
+
+/* eslint-disable @typescript-eslint/ban-types */
+
+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/defineStep.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCucumberStepFn = buildCucumberStepFn;
+exports.defineStep = defineStep;
+exports.getStepConfig = getStepConfig;
+exports.isPlaywrightStyle = isPlaywrightStyle;
+var _cucumber = require("@cucumber/cucumber");
+var _utils = require("../utils");
+function defineStep(stepConfig) {
+  const {
+    keyword,
+    pattern
+  } = stepConfig;
+  const cucumberDefineStepFn = getCucumberDefineStepFn(keyword);
+  const code = buildCucumberStepFn(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 buildCucumberStepFn(stepConfig) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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 getStepConfig(step) {
+  return step.code.stepConfig;
+}
+function isPlaywrightStyle(step) {
+  return Boolean(getStepConfig(step));
+}
+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/utils/index.js

@@ -0,0 +1,52 @@
+"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);
+  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,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = void 0;
+/**
+ * Simple logger
+ */
+
+const logger = {
+  log: (...args) => {
+    // eslint-disable-next-line no-console
+    console.log(...args);
+  },
+  error: (...args) => {
+    // eslint-disable-next-line no-console
+    console.error(...args);
+  }
+};
+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,7 +1,17 @@
+"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");
 // import { run } from 'jest';
 
 // function createJestRunner() {
-//   let config = require('../configs/jest.config');
+//   let config  from '../configs/jest.config');
 
 //   let argv = process.argv.slice(2);
 
@@ -9,25 +19,19 @@
 //   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'));
+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 = spawn(command, args, { stdio: 'inherit' });
-
+  const childProcess = (0, _child_process.spawn)(command, args, {
+    stdio: 'inherit'
+  });
 
   // Handling the 'exit' event of the child process
   // childProcess.on('exit', (code, signal) => {
@@ -38,7 +42,4 @@ function createJestRunner() {
   // childProcess.on('error', (err) => {
   //   console.error(`Error while spawning child process: ${err.message}`);
   // });
-}
-
-
-module.exports = createJestRunner;
+}

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,56 @@
+"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 _test = require("@playwright/test");
+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');
+  }
+}

package/{src → build}/core/playwright/index.js

@@ -1,4 +1,25 @@
-const { expect, test: base } = require('@playwright/test');
+"use strict";
+
+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 () {
+    return _test.expect;
+  }
+});
+exports.test = void 0;
+var _bddFramework = require("../../bdd-framework");
+var _test = require("@playwright/test");
+var _readConfigFile = require("./readConfigFile");
 // function test(descrition, callback) {
 //   return test(descrition, ({ page }) => {
 //     const { locator, ...custompage } = page
@@ -17,13 +38,11 @@ const { expect, test: base } = require('@playwright/test');
 //     return this.page['goto'](...args);
 //   }
 
-
 //   getByRole(...args) {
 //     return this.page['getByRole'](...args);
 //   }
 // }
 
-
 // function FilteredPage(page) {
 //   return {
 //     getByRole: () => {
@@ -31,9 +50,16 @@ const { expect, test: base } = require('@playwright/test');
 //     }
 //   }
 // }
-
+const {
+  additionalPages = {},
+  bddMode
+} = (0, _readConfigFile.generateConfigFromFile)();
+let base = bddMode ? _bddFramework.test : _test.test;
 const test = base.extend({
-  page: async ({ baseURL, page }, use) => {
+  page: async ({
+    baseURL,
+    page
+  }, use) => {
     // const proxyPage = new Proxy(page, {
     //   get: function (obj, prop) {
     //     console.log('Gettig Priop', prop);
@@ -50,33 +76,37 @@ const test = base.extend({
         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}?devURL=${process.env.devUrl}`;
       }
-      return `${process.env.domain}/${url}`
-    }
+      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) => {
+
+  context: async ({
+    context
+  }, use) => {
     await context.addInitScript(() => window.localStorage.setItem('isDnBannerHide', true));
     await use(context);
-  }
-})
-
-
-module.exports = {
-  expect,
-  test
-}
+  },
+  ...additionalPages
+});
+exports.test = test;
+const {
+  Given,
+  When,
+  Then
+} = (0, _bddFramework.createBdd)();
+exports.Then = Then;
+exports.When = When;
+exports.Given = Given;

package/build/core/playwright/readConfigFile.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fileName = void 0;
+exports.generateConfigFromFile = generateConfigFromFile;
+exports.getAuthFilePath = getAuthFilePath;
+exports.isUserConfigFileAvailable = isUserConfigFileAvailable;
+var _fs = require("fs");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+const fileName = 'uat.config.js';
+
+/**
+ * Represents the user configuration object.
+ * @typedef {Object} UserConfig
+ * @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 {any} browsers: List of browsers
+ * @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
+ * @property {number} testTimeout: time in milliseconds which the test should fail
+ * @property {Object} additionalPages: custom pages configuration
+ */
+
+/**
+ * Generates a configuration object from a file, if it exists.
+ *
+ * @returns {UserConfig}
+*/
+exports.fileName = fileName;
+function generateConfigFromFile() {
+  const filePath = _path.default.resolve(process.cwd(), fileName);
+  if ((0, _fs.existsSync)(filePath)) {
+    /** @type {UserConfig} */
+    const config = require(filePath);
+    return config;
+  }
+  return {};
+}
+function isUserConfigFileAvailable() {
+  const filePath = _path.default.resolve(process.cwd(), fileName);
+  if ((0, _fs.existsSync)(filePath)) {
+    return true;
+  }
+  return false;
+}
+function getAuthFilePath(filePath) {
+  try {
+    if ((0, _fs.existsSync)(filePath)) {
+      return filePath;
+    }
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, `Founded Path - ${filePath} Authetication file not Exist ...`);
+  }
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateReport;
+var _child_process = require("child_process");
+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(), './playwright-report')
+} = (0, _readConfigFile.generateConfigFromFile)();
+const reportPath = htmlPath;
+const args = ['show-report', htmlPath].concat(userArgs);
+function generateReport() {
+  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();
+  });
+}