d5-testing-library 1.0.1 → 1.0.3

package/dist/d5-testing-library.legacy-esm.js

@@ -75,10 +75,9 @@ var createDriver = async (browser) => {
 // src/utils/elementIsNotPresent.ts
 import { Condition } from "selenium-webdriver";
 var elementIsNotPresent = function elementIsNotPresent2(locator) {
-  return new Condition("for no element to be located " + locator, function(driver) {
-    return driver.findElements(locator).then(function(elements) {
-      return elements.length == 0;
-    });
+  return new Condition("for no element to be located " + locator, async function(driver) {
+    const elements = await driver.findElements(locator);
+    return elements.length == 0;
   });
 };
 
@@ -123,18 +122,33 @@ var SubsystemsPanel = class extends AbstractElement {
 };
 
 // src/pageObjects/elements/Forms/AbstractForm.ts
+import { By as By4 } from "selenium-webdriver";
 var AbstractForm = class extends AbstractPage {
   containerBy;
+  popupContainerBy;
   constructor(driver) {
     super(driver);
     this.containerBy = byTestId(`form-content-wrapper-${this.formName}`);
   }
+  async isModal() {
+    const el = await this.getContainerElement();
+    const value = await el.getAttribute("data-ismodal");
+    return value === "true";
+  }
   getContainerElement = () => {
     return this.driver.findElement(this.containerBy);
   };
   get formName() {
     return "";
   }
+  /**
+   * Возвращает true если форма есть в DOM
+   * @example
+   * class MyForm extends FormEdit {}
+   * //...
+   * const formEdit = new MyForm();
+   * expect(await formEdit.exists()).toBe(true);
+   */
   async exists() {
     try {
       await this.driver.wait(elementIsNotPresent(this.containerBy), 1e3);
@@ -143,13 +157,30 @@ var AbstractForm = class extends AbstractPage {
       return true;
     }
   }
+  /**
+   * Получение заголовка на формы
+   * @example
+   * const listForm = new MyForm();
+   * //...
+   * expect(await listForm.getTitleText()).toBe('MyFormTitle');
+   */
+  async getTitleText() {
+    if (await this.isModal()) {
+      const popupEl = await this.driver.findElement(this.popupContainerBy);
+      const titleEl2 = await popupEl.findElement(By4.className("popup-title"));
+      return titleEl2.getText();
+    }
+    let container = await this.getContainerElement();
+    let titleEl = await container.findElement(By4.className("form-toolbar-name-container"));
+    return titleEl.getText();
+  }
 };
 
 // src/pageObjects/elements/Forms/FormEdit.ts
-import { By as By5 } from "selenium-webdriver";
+import { By as By7 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Editors/AbstractEditor.ts
-import { By as By4, Key } from "selenium-webdriver";
+import { By as By5, Key } from "selenium-webdriver";
 
 // src/pageObjects/AbstractFormElement.ts
 var AbstractFormElement = class extends AbstractElementWithParent {
@@ -163,7 +194,7 @@ var AbstractFormElement = class extends AbstractElementWithParent {
 var AbstractDXEditorWithInput = class extends AbstractFormElement {
   async getInputElement() {
     const controlEl = await this.getElement();
-    return controlEl.findElement(By4.className("dx-texteditor-input"));
+    return controlEl.findElement(By5.className("dx-texteditor-input"));
   }
   async getInputValue() {
     const inputEl = await this.getInputElement();
@@ -197,6 +228,67 @@ var NumberEditor = class extends AbstractDXEditorWithInput {
   }
 };
 
+// src/pageObjects/elements/Editors/CheckBox.ts
+var CheckBox = class extends AbstractFormElement {
+  async getValue() {
+    const inputEl = await this.getElement();
+    const result = await inputEl.getAttribute("aria-checked");
+    if (result === "true")
+      return true;
+    if (result === "false")
+      return false;
+    return void 0;
+  }
+  async setValue(value) {
+    const inputEl = await this.getElement();
+    const currentValue = await this.getValue();
+    if (currentValue !== value) {
+      await inputEl.click();
+    }
+  }
+};
+
+// src/pageObjects/elements/Editors/SelectBoxEditor.ts
+import { By as By6, Key as Key2 } from "selenium-webdriver";
+
+// src/utils/xpathHelper.ts
+var XPathHelper = class {
+  static getRoleXpath(role) {
+    return `//div[@role='${role}']`;
+  }
+  static getClassAndValueXpath(cssClass, value) {
+    return `//div[contains(@class, '${cssClass}') and contains(.,'${value}')]`;
+  }
+};
+
+// src/pageObjects/elements/Editors/SelectBoxEditor.ts
+var SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS = "d5-multi-select-item";
+var SELECT_BOX_ELEMENT_ROLE = "option";
+var SelectBoxEditor = class extends AbstractDXEditorWithInput {
+  async setSelectInputValue(value) {
+    const inputEl = await this.getInputElement();
+    await inputEl.click();
+    await inputEl.sendKeys(value, Key2.ENTER);
+    const combinedValueXpath = XPathHelper.getRoleXpath(SELECT_BOX_ELEMENT_ROLE) + XPathHelper.getClassAndValueXpath(SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS, value);
+    await this.driver.wait(async () => {
+      try {
+        const optElement = await inputEl.findElement(By6.xpath(combinedValueXpath));
+        await optElement.click();
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }, 2e3);
+  }
+  async getValue() {
+    const value = await super.getInputValue();
+    return value == "" ? null : value;
+  }
+  setValue(value) {
+    return this.setSelectInputValue(value);
+  }
+};
+
 // src/pageObjects/elements/Editors/editorFactory.ts
 var editorFactory = async (getParentElement, elementBy, driver) => {
   const elementInstance = new AbstractFormElement(getParentElement, elementBy, driver);
@@ -206,6 +298,10 @@ var editorFactory = async (getParentElement, elementBy, driver) => {
     return new TextEditor(getParentElement, elementBy, driver);
   if (classSting.includes("number-control"))
     return new NumberEditor(getParentElement, elementBy, driver);
+  if (classSting.includes("check-box"))
+    return new CheckBox(getParentElement, elementBy, driver);
+  if (classSting.includes("select-control"))
+    return new SelectBoxEditor(getParentElement, elementBy, driver);
   throw new Error("Unknown type of editor. Please write ticket to the support");
 };
 
@@ -216,6 +312,9 @@ function createDataTestId(formName, itemType, itemName) {
 function createFieldTestId(formName, itemName) {
   return createDataTestId(formName, "form_field" /* FORM_FIELD */, itemName);
 }
+function createTableId(formName) {
+  return `${"table" /* TABLE */}-${formName}`;
+}
 
 // src/pageObjects/elements/FormField.ts
 var FormField = class extends AbstractElementWithParent {
@@ -229,10 +328,22 @@ var FormField = class extends AbstractElementWithParent {
       this.editor = await editorFactory(this.getParentElement, this.elementBy, this.driver);
     }
   }
+  /**
+   * Возвращает значение в поле
+   * @example
+   * expect(await formEdit.field('NumberFld').getValue()).toBe(10);
+   * expect(await formEdit.field('TextFld').getValue()).toBe('TestValue');
+   */
   async getValue() {
     await this.initEditor();
     return this.editor.getValue();
   }
+  /**
+   * Устанавливает значение в поле
+   * @example
+   * await formEdit.field('NumberFld').setValue(123);
+   * await formEdit.field('TextFld').setValue('TestValue');
+   */
   async setValue(value) {
     await this.initEditor();
     return this.editor.setValue(value);
@@ -241,21 +352,284 @@ var FormField = class extends AbstractElementWithParent {
 
 // src/pageObjects/elements/Forms/FormEdit.ts
 var FormEdit = class extends AbstractForm {
-  saveButtonBy = By5.id("button-save");
+  saveButtonBy = By7.id("button-save");
+  constructor(driver) {
+    super(driver);
+    this.popupContainerBy = By7.className(`popup form-edit-${this.formName}`);
+  }
+  /**
+   * Находит поле формы редактирования по имени
+   * @example
+   * const formEdit = new MyForm();
+   * //...
+   * expect(await formEdit.field('Name').getValue()).toBe('test value');
+   */
   field(name) {
     return new FormField(this.getContainerElement, this.formName, name, this.driver);
   }
+  /**
+   * Нажатие на кнопку Сохранить
+   * @example
+   * const formEdit = new MyForm();
+   * //...
+   * await formEdit.saveButtonClick();
+   */
   async saveButtonClick() {
     await this.driver.findElement(this.saveButtonBy).click();
   }
 };
 
 // src/pageObjects/elements/Forms/ListForm.ts
-import { By as By6 } from "selenium-webdriver";
+import { By as By13 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Table/Table.ts
+import { By as By10 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Table/utils.ts
+import { By as By8 } from "selenium-webdriver";
+var getRowPathByIndex = (index) => {
+  return By8.xpath(`//tr[@aria-rowindex="${transformInputIndex(index)}"]`);
+};
+var getColumnPathByIndex = (index) => {
+  return By8.xpath(`//td[@aria-colindex="${transformInputIndex(index)}"]`);
+};
+var getColumnPathByCaption = (caption) => {
+  return By8.xpath(`//td[@role="columnheader"][@aria-label="Column ${caption}"]`);
+};
+var getCellPathByIndex = (index) => {
+  return By8.xpath(`//td[@role="gridcell"][@aria-colindex="${transformInputIndex(index)}"]`);
+};
+var transformInputIndex = (index) => index + 1;
+var transformOutputIndex = (index) => +index - 1;
+
+// src/pageObjects/elements/Table/elements/Row.ts
+import { By as By9 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Table/elements/Cell.ts
+var Cell = class extends AbstractElementWithParent {
+  index;
+  constructor(getParentElement, index, driver) {
+    super(getParentElement, driver);
+    this.index = index;
+    this.elementBy = getCellPathByIndex(index);
+  }
+  async getValue() {
+    const cellEl = await this.getElement();
+    return cellEl.getText();
+  }
+  getIndex() {
+    return this.index;
+  }
+};
+
+// src/pageObjects/elements/Table/elements/Row.ts
+var Row = class extends AbstractElementWithParent {
+  index;
+  getColumnByCaption;
+  constructor(getParentElement, index, driver, getColumnByCaption) {
+    super(getParentElement, driver);
+    this.index = index;
+    this.elementBy = getRowPathByIndex(index);
+    this.getColumnByCaption = getColumnByCaption;
+  }
+  getRowElement = () => {
+    return this.driver.findElement(this.elementBy);
+  };
+  async getCellByIndex(index) {
+    const rowEl = await this.getElement();
+    const cell = rowEl.findElement(getCellPathByIndex(index));
+    if (cell) {
+      return new Cell(this.getRowElement, index, this.driver);
+    }
+    throw new Error(`Cannot find cell by index: ${index}`);
+  }
+  async getCell(caption) {
+    const column = await this.getColumnByCaption(caption);
+    if (column) {
+      const index = column.getIndex();
+      return this.getCellByIndex(index);
+    }
+    throw new Error("Unknown caption of cell");
+  }
+  async select() {
+    const rowEl = await this.getElement();
+    await rowEl.click();
+  }
+  async isSelected() {
+    const rowEl = await this.getElement();
+    const result = await rowEl.getAttribute("aria-selected");
+    return result === "true";
+  }
+  getIndex() {
+    return this.index;
+  }
+  async getCells() {
+    const rowEl = await this.getElement();
+    const cells = await rowEl.findElements(By9.css(`td[role="gridcell"]`));
+    const result = [];
+    cells.forEach((_, index) => {
+      const newCell = new Cell(this.getRowElement, index, this.driver);
+      result.push(newCell);
+    });
+    return result;
+  }
+};
+
+// src/pageObjects/elements/Table/elements/Column.ts
+var Column = class extends AbstractElementWithParent {
+  index;
+  constructor(getParentElement, index, driver) {
+    super(getParentElement, driver);
+    this.index = index;
+    this.elementBy = getColumnPathByIndex(index);
+  }
+  async caption() {
+    const el = await this.getElement();
+    return el.getText();
+  }
+  getIndex() {
+    return this.index;
+  }
+};
+
+// src/pageObjects/elements/Table/Table.ts
+var Table = class extends AbstractElementWithParent {
+  constructor(getParentElement, formName, driver) {
+    super(getParentElement, driver);
+    this.elementBy = By10.id(createTableId(formName));
+  }
+  async getHeaderElement() {
+    const parentEl = await this.getElement();
+    return parentEl.findElement(By10.className("dx-header-row"));
+  }
+  async getDataGrid() {
+    const parentEl = await this.getElement();
+    return parentEl.findElement(By10.css(`div[role="grid"]`));
+  }
+  getTableElement = () => {
+    return this.driver.findElement(this.elementBy);
+  };
+  async getRowByIndex(index) {
+    const gridContainer = await this.getDataGrid();
+    const row = await gridContainer.findElement(getRowPathByIndex(index));
+    if (row) {
+      return new Row(this.getTableElement, index, this.driver, this.getColumnByCaption.bind(this));
+    }
+    throw new Error(`Cannot find row by index: ${index}`);
+  }
+  async getColumnByIndex(index) {
+    const headerContainer = await this.getHeaderElement();
+    const column = await headerContainer.findElement(getColumnPathByIndex(index));
+    if (column) {
+      return new Column(this.getTableElement, index, this.driver);
+    }
+    throw new Error(`Cannot find column by index: ${index}`);
+  }
+  async getColumnByCaption(caption) {
+    const headerContainer = await this.getHeaderElement();
+    const column = await headerContainer.findElement(getColumnPathByCaption(caption));
+    if (column) {
+      const index = await column.getAttribute("aria-colindex");
+      return new Column(this.getTableElement, transformOutputIndex(index), this.driver);
+    }
+    throw new Error(`Cannot find column by caption: ${caption}`);
+  }
+  async selectRowByIndex(index) {
+    const row = await this.getRowByIndex(index);
+    if (row) {
+      await row.select();
+    } else {
+      throw new Error(`Cannot find row by index: ${index}`);
+    }
+  }
+  async getRows() {
+    const gridContainer = await this.getDataGrid();
+    const rows = await gridContainer.findElements(By10.className("dx-row dx-data-row"));
+    const result = [];
+    rows.forEach((_, index) => {
+      const newRow = new Row(this.getTableElement, index, this.driver, this.getColumnByCaption.bind(this));
+      result.push(newRow);
+    });
+    return result;
+  }
+  async getColumns() {
+    const headerContainer = await this.getHeaderElement();
+    const columns = await headerContainer.findElements(By10.css(`td[role="columnheader"]`));
+    const result = [];
+    columns.forEach((_, index) => {
+      const newCol = new Column(this.getTableElement, index, this.driver);
+      result.push(newCol);
+    });
+    return result;
+  }
+  async element() {
+    return this.getElement();
+  }
+};
+
+// src/pageObjects/elements/TableToolbar/TableToolbar.ts
+import { By as By12 } from "selenium-webdriver";
+
+// src/pageObjects/elements/TableToolbar/TableToolbarButton.ts
+import { By as By11 } from "selenium-webdriver";
+var TOOLBAR_BUTTON_CLASS = "toolbar-button";
+var TableToolbarButton = class extends AbstractElementWithParent {
+  constructor(getParentElement, name, driver) {
+    super(getParentElement, driver);
+    this.elementBy = By11.id(`${TOOLBAR_BUTTON_CLASS}-${name}`);
+  }
+  async click() {
+    const button = await this.getElement();
+    return button.click();
+  }
+};
+
+// src/pageObjects/elements/TableToolbar/TableToolbar.ts
+var TABLE_TOOLBAR_CLASS = "d5-table-toolbar";
+var TableToolbar = class extends AbstractElementWithParent {
+  constructor(getParentElement, formName, driver) {
+    super(getParentElement, driver);
+    this.elementBy = By12.id(`${TABLE_TOOLBAR_CLASS}-${formName}`);
+  }
+  getTableToolbarElement = () => {
+    return this.driver.findElement(this.elementBy);
+  };
+  async button(name) {
+    const toolbar = await this.getTableToolbarElement();
+    const button = await toolbar.findElement(By12.id(`${TOOLBAR_BUTTON_CLASS}-${name}`));
+    if (button) {
+      return new TableToolbarButton(this.getTableToolbarElement, name, this.driver);
+    }
+    throw new Error(`Cannot find button by name: ${name}`);
+  }
+};
+
+// src/pageObjects/elements/Forms/ListForm.ts
 var ListForm = class extends AbstractForm {
-  titleBy = By6.className("form-toolbar-name-container");
-  getTitleText() {
-    return this.getContainerElement().then((el) => el.findElement(this.titleBy)).then((el) => el.getText());
+  constructor(driver) {
+    super(driver);
+    this.popupContainerBy = By13.className(`popup form-inline-${this.formName}`);
+  }
+  /**
+   * Находит таблицу
+   * @example
+   * const listForm = new MyForm();
+   * //...
+   * expect(listForm.table());
+   */
+  table() {
+    return new Table(this.getContainerElement, this.formName, this.driver);
+  }
+  /**
+   * Находит таблицу
+   * @example
+   * const listForm = new MyForm();
+   * //...
+   * expect(listForm.toolbarButton());
+   */
+  toolbarButton(name) {
+    const toolbar = new TableToolbar(this.getContainerElement, this.formName, this.driver);
+    return toolbar.button(name);
   }
 };