@zeesoft/i18n-verify 1.0.0

package/dist/driver/adapters/cypress.js

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _cypress = require("../../utils/cypress.js");
+var _baseDriver = _interopRequireDefault(require("../baseDriver.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class CypressDriver extends _baseDriver.default {
+  /**
+   *
+   * @param {this.$driver} driver
+   */
+  constructor(driver) {
+    super(driver);
+  }
+  async getElement(el) {
+    if (typeof el !== 'string') {
+      return this.$driver.wrap(el);
+    } else if (el.startsWith('//')) {
+      return await this.xpath(el).first();
+    } else {
+      return await this.$driver.get(el).first();
+    }
+  }
+  async getElements(el) {
+    if (typeof el !== 'string') {
+      return this.$driver.wrap(el);
+    } else if (el.startsWith('//')) {
+      return await this.xpath(el);
+    } else {
+      return await this.$driver.get(el);
+    }
+  }
+  async getText(el) {
+    return typeof el === 'string' ? await this.$driver.get(el).invoke('text') : await this.$driver.wrap(el).invoke('text');
+  }
+  async getTitle(el) {
+    return typeof el === 'string' ? await this.$driver.get(el).title() : this.$driver.wrap().title();
+  }
+  async getPlaceholderText(el) {
+    if (typeof el === 'string') {
+      return this.$driver.get(el).filter('input').invoke('attr', 'placeholder').then(placeholder => {
+        return placeholder;
+      });
+    } else {
+      return this.$driver.$$(el).attr('placeholder');
+    }
+  }
+  async getAltText(locator) {
+    return this.$driver.get(locator).invoke('attr', 'alt');
+  }
+  async getWidth(el) {
+    if (typeof el === 'string') {
+      return this.$driver.get(el).invoke('width');
+    } else {
+      return this.$driver.$$(el).width();
+    }
+  }
+  async getHeight(el) {
+    if (typeof el === 'string') {
+      return this.$driver.get(el).invoke('height');
+    } else {
+      return this.$driver.$$(el).height();
+    }
+  }
+  async getTagName(el) {
+    if (typeof el === 'string') {
+      return this.$driver.get(el).invoke('prop', 'tagName').then(tagName => tagName.toLowerCase());
+    } else {
+      return this.$driver.$$(el).tagName; // zTodo
+    }
+  }
+  async getValue(el) {
+    if (typeof el === 'string') {
+      return this.$driver.get(el).invoke('val');
+    } else {
+      return this.$driver.wrap(el).invoke('val');
+    }
+  }
+  async getLocation(el) {
+    if (typeof el === 'string') {
+      return this.$driver.get(el).invoke('offset').then(offset => {
+        return {
+          x: offset.left,
+          y: offset.top
+        };
+      });
+    } else {
+      const offset = this.$driver.$$(el).offset();
+      return {
+        x: offset.left,
+        y: offset.top
+      };
+    }
+  }
+  async isElementDisplayed(el) {
+    if (typeof el === 'string') {
+      return this.$driver.get(el).then($element => {
+        return $element.is(':visible');
+      });
+    } else {
+      return this.$driver.$$(el).is(':visible');
+    }
+  }
+  async captureScreenshot(file) {
+    this.$driver.screenshot(file);
+  }
+  async getElementsCount(el) {
+    return new Promise(res => {
+      if (typeof el === 'string') {
+        return this.$driver.get(el).its('length').then(l => res(l));
+      } else {
+        return this.$driver.wrap(el, {
+          timeout: 8000
+        }).its('length').then(l => res(l));
+      }
+    });
+  }
+  async getElementStrings(el) {
+    const elementStrings = [];
+    try {
+      const textFields = [{
+        type: 'eleTxt',
+        value: await this.getText(el)
+      }, {
+        type: 'altTxt',
+        value: await this.getAltText(el)
+      },
+      //  { type: 'titleTxt', value: await this.getTitle(el) },
+      {
+        type: 'placetxt',
+        value: await this.getPlaceholderText(el)
+      }];
+      textFields.forEach(({
+        value
+      }) => {
+        if (this.checkIfNullOrEmpty(value)) {
+          elementStrings.push(value);
+        }
+      });
+    } catch (textError) {
+      console.error('Error getting text of element:', textError);
+    }
+    return elementStrings;
+  }
+  printOnConsole(str) {
+    this.$driver.log(str);
+  }
+  xpath(subject, selector, options = {}) {
+    return (0, _cypress.xpath)({
+      subject,
+      selector,
+      options,
+      driver: this.$driver
+    });
+  }
+}
+exports.default = CypressDriver;

package/dist/driver/adapters/nightwatch.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _baseDriver = _interopRequireDefault(require("../baseDriver.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class NightWatchDriver extends _baseDriver.default {
+  constructor(driver) {
+    super(driver);
+  }
+  getElement(locator) {
+    return this.$driver.element.find({
+      selector: locator,
+      locateStrategy: locator.startsWith('/') ? 'xpath' : 'css selector'
+    });
+  }
+  async getElements(locator) {
+    return await this.$driver.element.findAll({
+      selector: locator,
+      locateStrategy: locator.startsWith('/') ? 'xpath' : 'css selector'
+    });
+  }
+  async getText(element) {
+    return await element.getText();
+  }
+  async getTitle(element) {
+    return await element.getAttribute('title');
+  }
+  async getPlaceholderText(element) {
+    return await element.getAttribute('placeholder');
+  }
+  async getAltText(element) {
+    return await element.getAttribute('alt');
+  }
+  async getTagName(element) {
+    return await element.getTagName();
+  }
+  async getValue(element) {
+    return await element.getAttribute('value');
+  }
+  async getElementDimension(element) {
+    const eleSize = await element.getRect();
+    if (![null, '', undefined].includes(eleSize)) {
+      return [eleSize.x, eleSize.y, eleSize.height, eleSize.width];
+    }
+  }
+  isElementDisplayed(element) {
+    return this.$driver.isVisible(element);
+  }
+  async getElementStrings(element) {
+    const elementStrings = [];
+    const textFields = [{
+      type: 'eleTxt',
+      value: await this.getText(element)
+    }, {
+      type: 'altTxt',
+      value: await this.getAltText(element)
+    }, {
+      type: 'titleTxt',
+      value: await this.getTitle(element)
+    }, {
+      type: 'placeTxt',
+      value: await this.getPlaceholderText(element)
+    }, {
+      type: 'valueTxt',
+      value: await this.getValue(element)
+    }];
+    textFields.forEach(({
+      value
+    }) => {
+      if (this.checkIfNullOrEmpty(value)) {
+        elementStrings.push(value);
+      }
+    });
+    return elementStrings;
+  }
+  async getElementString(element) {
+    let eleStr = null;
+    const textFunctions = [this.getText, this.getAltText, this.getTitle, this.getPlaceholderText, this.getValue];
+    for (const func of textFunctions) {
+      eleStr = await func(element);
+      if (eleStr !== null) return eleStr;
+    }
+    return eleStr;
+  }
+  async captureScreenshot(file) {
+    await this.$driver.saveScreenshot(file);
+  }
+  async getElementsCount(elements) {
+    return elements.length;
+  }
+}
+exports.default = NightWatchDriver;

package/dist/driver/adapters/selenium.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _baseDriver = _interopRequireDefault(require("../baseDriver.js"));
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class SeleniumDriver extends _baseDriver.default {
+  constructor(driver) {
+    super(driver);
+  }
+  async getElement(locator) {
+    return await this.driver.findElement(locator);
+  }
+  async getElements(locator) {
+    return await this.driver.findElements(locator);
+  }
+  async getText(element) {
+    return await element.getText();
+  }
+  async getTitle() {
+    return await this.driver.getTitle();
+  }
+
+  // async getTitle(element) {
+  //   return await element.getAttribute('title');
+  // }
+
+  // async getPlaceholderText(element, placeholder) {
+  //   return await element.getAttribute(placeholder);
+  // }
+
+  // async getAltText(element, alt) {
+  //   return await element.getAttribute(alt);
+  // }
+
+  async getAttribute(element, attributeName) {
+    return await element.getAttribute(attributeName);
+  }
+  async getTagName(element) {
+    return await element.getTagName();
+  }
+
+  // async getValue(element, value) {
+  //   return await element.getAttribute(value);
+  // }
+
+  async getElementDimension(element) {
+    const eleSize = await element.getRect();
+    if (![null, '', undefined].includes(eleSize)) {
+      return [eleSize.x, eleSize.y, eleSize.height, eleSize.width];
+    }
+  }
+  async isElementDisplayed(element) {
+    return await element.isDisplayed();
+  }
+  async getElementStrings(element) {
+    const elementStrings = [];
+    const textFields = [{
+      type: 'eleTxt',
+      value: await this.getText(element)
+    }, {
+      type: 'altTxt',
+      value: await this.getAttribute(element, 'alt')
+    }, {
+      type: 'titleTxt',
+      value: await this.getAttribute(element, 'title')
+    }, {
+      type: 'placeTxt',
+      value: await this.getAttribute(element, 'placeholder')
+    }, {
+      type: 'valueTxt',
+      value: await this.getAttribute(element, 'value')
+    }];
+    textFields.forEach(({
+      value
+    }) => {
+      if (this.checkIfNullOrEmpty(value)) {
+        elementStrings.push(value);
+      }
+    });
+    return elementStrings;
+  }
+  async captureScreenshot(file) {
+    const screenshot = await this.driver.takeScreenshot();
+    _fs.default.writeFileSync(file, screenshot, 'base64');
+  }
+  async getElementsCount(elements) {
+    return elements.length;
+  }
+}
+exports.default = SeleniumDriver;

package/dist/driver/adapters/webdriver.io.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _baseDriver = _interopRequireDefault(require("../baseDriver.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class WebDriverIoDriver extends _baseDriver.default {
+  constructor(driver) {
+    super(driver);
+  }
+  getElement(locator) {
+    return this.$driver.findElement('xpath', locator);
+  }
+  async getElements(locator) {
+    const eleArray = await this.$driver.findElements('xpath', locator);
+    return eleArray;
+  }
+  async getText(element) {
+    return await $(element).getText();
+  }
+  async getTitle(element) {
+    return await $(element).getAttribute('title');
+  }
+  async getPlaceholderText(element) {
+    return await $(element).getAttribute('placeholder');
+  }
+  async getAltText(element) {
+    return await $(element).getAttribute('alt');
+  }
+  async getTagName(element) {
+    return await $(element).getTagName();
+  }
+  async getValue(element) {
+    return await $(element).getValue();
+  }
+  async getElementDimension(element) {
+    const eleSize = await this.$driver.getElementRect(element['element-6066-11e4-a52e-4f735466cecf']);
+    if (![null, '', undefined].includes(eleSize)) {
+      return [eleSize.x, eleSize.y, eleSize.height, eleSize.width];
+    }
+  }
+  isElementDisplayed(element) {
+    return $(element).isDisplayed();
+  }
+  async getElementStrings(element) {
+    const elementStrings = [];
+    const textFields = [{
+      type: 'eleTxt',
+      value: await this.getText(element)
+    }, {
+      type: 'altTxt',
+      value: await this.getAltText(element)
+    }, {
+      type: 'titleTxt',
+      value: await this.getTitle(element)
+    }, {
+      type: 'placeTxt',
+      value: await this.getPlaceholderText(element)
+    }, {
+      type: 'valueTxt',
+      value: await this.getValue(element)
+    }];
+    textFields.forEach(({
+      value
+    }) => {
+      if (this.checkIfNullOrEmpty(value)) {
+        elementStrings.push(value);
+      }
+    });
+    return elementStrings;
+  }
+  async captureScreenshot(file) {
+    await this.$driver.saveScreenshot(file);
+  }
+  async getElementsCount(elements) {
+    return elements.length;
+  }
+}
+exports.default = WebDriverIoDriver;

package/dist/driver/baseDriver.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class BaseDriver {
+  constructor(driver) {
+    this.$driver = driver;
+  }
+  checkIfNullOrEmpty(value) {
+    return ![null, '', undefined].includes(value);
+  }
+  getElement() {
+    throw new Error('implementation is missing');
+  }
+  getElements() {
+    throw new Error('implementation is missing');
+  }
+  getText() {
+    throw new Error('implementation is missing');
+  }
+  getTitle() {
+    throw new Error('implementation is missing');
+  }
+  getPlaceholderText() {
+    throw new Error('implementation is missing');
+  }
+  getAltText() {
+    throw new Error('implementation is missing');
+  }
+  getWidth() {
+    throw new Error('implementation is missing');
+  }
+  getHeight() {
+    throw new Error('implementation is missing');
+  }
+  getTagName() {
+    throw new Error('implementation is missing');
+  }
+  getValue() {
+    throw new Error('implementation is missing');
+  }
+  getLocation() {
+    throw new Error('implementation is missing');
+  }
+  getElementDimension() {
+    throw new Error('implementation is missing');
+  }
+  isElementDisplayed() {
+    throw new Error('implementation is missing');
+  }
+  getElementString() {
+    throw new Error('implementation is missing');
+  }
+  getElementStrings() {
+    throw new Error('implementation is missing');
+  }
+  captureScreenshot() {
+    throw new Error('implementation is missing');
+  }
+  getElementsCount() {
+    throw new Error('implementation is missing');
+  }
+  printOnConsole(str) {
+    console.log(str);
+  }
+}
+exports.default = BaseDriver;

package/dist/driver/factory.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.build = void 0;
+var _constants = require("../utils/constants.js");
+var _nightwatch = _interopRequireDefault(require("./adapters/nightwatch.js"));
+var _webdriverIo = _interopRequireDefault(require("./adapters/webdriver.io.js"));
+var _cypress = _interopRequireDefault(require("./adapters/cypress.js"));
+var _selenium = _interopRequireDefault(require("./adapters/selenium.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const build = (type, driver) => {
+  switch (type) {
+    case _constants.SYSTEM_TYPES.NIGHT_WATCH:
+      return new _nightwatch.default(driver);
+    case _constants.SYSTEM_TYPES.WEB_DRIVER_IO:
+      return new _webdriverIo.default(driver);
+    case _constants.SYSTEM_TYPES.CYPRESS:
+      return new _cypress.default(driver);
+    case _constants.SYSTEM_TYPES.SELENIUMJS:
+      return new _selenium.default(driver);
+    default:
+      throw new Error("Unsupported framework");
+  }
+};
+exports.build = build;

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.verify = exports.systems = exports.setLocale = exports.getReportCounts = exports.getLocale = exports.config = void 0;
+var _i18n = _interopRequireDefault(require("./lib/i18n.js"));
+var _constants = require("./utils/constants.js");
+var _config = _interopRequireDefault(require("./lib/config.js"));
+var _runtime = require("./utils/runtime.js");
+var _reportsTable = _interopRequireDefault(require("./utils/reportsTable.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const config = (driver, locale) => {
+  _config.default.set(driver, locale);
+  (0, _runtime.loadDependencies)();
+};
+exports.config = config;
+const setLocale = locale => {
+  _config.default.setLocale(locale);
+};
+exports.setLocale = setLocale;
+const getReportCounts = () => {
+  _reportsTable.default.generateTable();
+};
+exports.getReportCounts = getReportCounts;
+const getLocale = () => {
+  return _config.default.getLocale();
+};
+exports.getLocale = getLocale;
+const verify = async ({
+  verificationArea,
+  staticLocators,
+  description
+}) => {
+  const runner = _config.default.getRunner();
+  if (!runner || !(runner instanceof _i18n.default)) {
+    throw new Error('I18n runner is missing, make sure to set configuration');
+  }
+  await runner.verify({
+    verificationArea,
+    staticLocators,
+    description
+  });
+};
+exports.verify = verify;
+_config.default.init();
+const systems = exports.systems = _constants.SYSTEM_TYPES;

package/dist/lib/config.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _factory = require("../driver/factory.js");
+var _i18n = _interopRequireDefault(require("./i18n.js"));
+var _constants = require("../utils/constants.js");
+var _configFile = require("../utils/configFile.js");
+var _logs = _interopRequireDefault(require("../utils/logs.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Config {
+  static #driver;
+  static #runner;
+  static #type;
+  static #locale;
+  static #qaLocale;
+  static #options;
+  static #resources;
+  static #ssCount;
+  static init() {
+    try {
+      const config = (0, _configFile.readConfigFile)();
+      (0, _configFile.validateConfig)(config);
+      this.#type = config?.type;
+      this.#qaLocale = config?.qaLocale;
+      this.#options = config;
+      this.#ssCount = 0;
+      this.getGarbledChars();
+    } catch (ex) {
+      _logs.default.error(ex.message);
+      throw ex;
+    }
+  }
+  static set(driver, locale) {
+    this.#locale = locale;
+    this.#driver = (0, _factory.build)(this.#type, driver);
+  }
+  static getGarbledChars() {
+    return [...(this.#options.garbledChars || []), ..._constants.GARBLED_CHARACTERS];
+  }
+  static setDriver(driver) {
+    this.#driver = driver;
+  }
+  static setType(type) {
+    this.#type = type;
+  }
+  static setLocale(locale) {
+    this.#locale = locale;
+  }
+  static setOptions(options) {
+    this.#options = options;
+  }
+  static getRunner() {
+    if (Config.#runner) {
+      return Config.#runner;
+    }
+    if (!Config.#driver) {
+      throw new Error('Unable to initialize I18n Runner');
+    }
+    this.#runner = new _i18n.default(this.#driver);
+    return this.#runner;
+  }
+  static getDriver() {
+    return this.#driver;
+  }
+  static getLocale() {
+    return this.#locale;
+  }
+  static getDefaultLocale() {
+    return this.#options.defaultLocale;
+  }
+  static getType() {
+    return this.#type;
+  }
+  static getOptions() {
+    return this.#options;
+  }
+  static setQALocale(locale) {
+    this.#qaLocale = locale;
+  }
+  static getQALocale() {
+    return this.#qaLocale;
+  }
+  static setResourceBundle(resources) {
+    this.#resources = resources;
+  }
+  static getResourceBundle(value) {
+    return this.#resources?.[value] || this.#resources || [];
+  }
+  static incrementCounter() {
+    this.#ssCount++;
+  }
+  static getSSCount() {
+    return this.#ssCount;
+  }
+}
+exports.default = Config;