d5-testing-library 1.0.1 → 1.0.3

package/dist/cjs/d5-testing-library.cjs

@@ -114,10 +114,9 @@ var createDriver = async (browser) => {
 // src/utils/elementIsNotPresent.ts
 var import_selenium_webdriver3 = require("selenium-webdriver");
 var elementIsNotPresent = function elementIsNotPresent2(locator) {
-  return new import_selenium_webdriver3.Condition("for no element to be located " + locator, function(driver) {
-    return driver.findElements(locator).then(function(elements) {
-      return elements.length == 0;
-    });
+  return new import_selenium_webdriver3.Condition("for no element to be located " + locator, async function(driver) {
+    const elements = await driver.findElements(locator);
+    return elements.length == 0;
   });
 };
 
@@ -162,18 +161,33 @@ var SubsystemsPanel = class extends AbstractElement {
 };
 
 // src/pageObjects/elements/Forms/AbstractForm.ts
+var import_selenium_webdriver5 = require("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);
@@ -182,13 +196,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(import_selenium_webdriver5.By.className("popup-title"));
+      return titleEl2.getText();
+    }
+    let container = await this.getContainerElement();
+    let titleEl = await container.findElement(import_selenium_webdriver5.By.className("form-toolbar-name-container"));
+    return titleEl.getText();
+  }
 };
 
 // src/pageObjects/elements/Forms/FormEdit.ts
-var import_selenium_webdriver6 = require("selenium-webdriver");
+var import_selenium_webdriver8 = require("selenium-webdriver");
 
 // src/pageObjects/elements/Editors/AbstractEditor.ts
-var import_selenium_webdriver5 = require("selenium-webdriver");
+var import_selenium_webdriver6 = require("selenium-webdriver");
 
 // src/pageObjects/AbstractFormElement.ts
 var AbstractFormElement = class extends AbstractElementWithParent {
@@ -202,7 +233,7 @@ var AbstractFormElement = class extends AbstractElementWithParent {
 var AbstractDXEditorWithInput = class extends AbstractFormElement {
   async getInputElement() {
     const controlEl = await this.getElement();
-    return controlEl.findElement(import_selenium_webdriver5.By.className("dx-texteditor-input"));
+    return controlEl.findElement(import_selenium_webdriver6.By.className("dx-texteditor-input"));
   }
   async getInputValue() {
     const inputEl = await this.getInputElement();
@@ -211,7 +242,7 @@ var AbstractDXEditorWithInput = class extends AbstractFormElement {
   async setInputValue(value) {
     const inputEl = await this.getInputElement();
     await inputEl.click();
-    await inputEl.sendKeys(value, import_selenium_webdriver5.Key.ENTER);
+    await inputEl.sendKeys(value, import_selenium_webdriver6.Key.ENTER);
   }
 };
 
@@ -236,6 +267,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
+var import_selenium_webdriver7 = require("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, import_selenium_webdriver7.Key.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(import_selenium_webdriver7.By.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);
@@ -245,6 +337,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");
 };
 
@@ -255,6 +351,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 {
@@ -268,10 +367,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);
@@ -280,21 +391,284 @@ var FormField = class extends AbstractElementWithParent {
 
 // src/pageObjects/elements/Forms/FormEdit.ts
 var FormEdit = class extends AbstractForm {
-  saveButtonBy = import_selenium_webdriver6.By.id("button-save");
+  saveButtonBy = import_selenium_webdriver8.By.id("button-save");
+  constructor(driver) {
+    super(driver);
+    this.popupContainerBy = import_selenium_webdriver8.By.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
-var import_selenium_webdriver7 = require("selenium-webdriver");
+var import_selenium_webdriver14 = require("selenium-webdriver");
+
+// src/pageObjects/elements/Table/Table.ts
+var import_selenium_webdriver11 = require("selenium-webdriver");
+
+// src/pageObjects/elements/Table/utils.ts
+var import_selenium_webdriver9 = require("selenium-webdriver");
+var getRowPathByIndex = (index) => {
+  return import_selenium_webdriver9.By.xpath(`//tr[@aria-rowindex="${transformInputIndex(index)}"]`);
+};
+var getColumnPathByIndex = (index) => {
+  return import_selenium_webdriver9.By.xpath(`//td[@aria-colindex="${transformInputIndex(index)}"]`);
+};
+var getColumnPathByCaption = (caption) => {
+  return import_selenium_webdriver9.By.xpath(`//td[@role="columnheader"][@aria-label="Column ${caption}"]`);
+};
+var getCellPathByIndex = (index) => {
+  return import_selenium_webdriver9.By.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
+var import_selenium_webdriver10 = require("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(import_selenium_webdriver10.By.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 = import_selenium_webdriver11.By.id(createTableId(formName));
+  }
+  async getHeaderElement() {
+    const parentEl = await this.getElement();
+    return parentEl.findElement(import_selenium_webdriver11.By.className("dx-header-row"));
+  }
+  async getDataGrid() {
+    const parentEl = await this.getElement();
+    return parentEl.findElement(import_selenium_webdriver11.By.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(import_selenium_webdriver11.By.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(import_selenium_webdriver11.By.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
+var import_selenium_webdriver13 = require("selenium-webdriver");
+
+// src/pageObjects/elements/TableToolbar/TableToolbarButton.ts
+var import_selenium_webdriver12 = require("selenium-webdriver");
+var TOOLBAR_BUTTON_CLASS = "toolbar-button";
+var TableToolbarButton = class extends AbstractElementWithParent {
+  constructor(getParentElement, name, driver) {
+    super(getParentElement, driver);
+    this.elementBy = import_selenium_webdriver12.By.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 = import_selenium_webdriver13.By.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(import_selenium_webdriver13.By.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 = import_selenium_webdriver7.By.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 = import_selenium_webdriver14.By.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);
   }
 };
 

package/dist/d5-testing-library.d.ts

@@ -76,10 +76,28 @@ declare class SubsystemsPanel extends AbstractElement {
 
 declare abstract class AbstractForm extends AbstractPage {
     protected containerBy: By;
-    constructor(driver?: WebDriver);
+    protected popupContainerBy: By;
+    protected constructor(driver?: WebDriver);
+    protected isModal(): Promise<boolean>;
     protected getContainerElement: () => selenium_webdriver.WebElementPromise;
     protected get formName(): string;
+    /**
+     * Возвращает true если форма есть в DOM
+     * @example
+     * class MyForm extends FormEdit {}
+     * //...
+     * const formEdit = new MyForm();
+     * expect(await formEdit.exists()).toBe(true);
+     */
     exists(): Promise<boolean>;
+    /**
+     * Получение заголовка на формы
+     * @example
+     * const listForm = new MyForm();
+     * //...
+     * expect(await listForm.getTitleText()).toBe('MyFormTitle');
+     */
+    getTitleText(): Promise<string>;
 }
 
 declare abstract class AbstractElementWithParent extends AbstractElement {
@@ -122,19 +140,107 @@ declare class FormField extends AbstractElementWithParent implements Editor {
     editor: Editor;
     constructor(getParentElement: () => WebElementPromise, formName: string, name: string, driver?: WebDriver);
     private initEditor;
+    /**
+     * Возвращает значение в поле
+     * @example
+     * expect(await formEdit.field('NumberFld').getValue()).toBe(10);
+     * expect(await formEdit.field('TextFld').getValue()).toBe('TestValue');
+     */
     getValue(): Promise<any>;
+    /**
+     * Устанавливает значение в поле
+     * @example
+     * await formEdit.field('NumberFld').setValue(123);
+     * await formEdit.field('TextFld').setValue('TestValue');
+     */
     setValue(value: any): Promise<void>;
 }
 
 declare abstract class FormEdit extends AbstractForm {
     saveButtonBy: By;
+    protected constructor(driver?: WebDriver);
+    /**
+     * Находит поле формы редактирования по имени
+     * @example
+     * const formEdit = new MyForm();
+     * //...
+     * expect(await formEdit.field('Name').getValue()).toBe('test value');
+     */
     field(name: string): FormField;
+    /**
+     * Нажатие на кнопку Сохранить
+     * @example
+     * const formEdit = new MyForm();
+     * //...
+     * await formEdit.saveButtonClick();
+     */
     saveButtonClick(): Promise<void>;
 }
 
+declare class TableToolbarButton extends AbstractElementWithParent {
+    constructor(getParentElement: () => WebElementPromise, name: string, driver?: WebDriver);
+    click(): Promise<void>;
+}
+
+declare class Cell extends AbstractElementWithParent {
+    index: number;
+    constructor(getParentElement: () => WebElementPromise, index: number, driver?: WebDriver);
+    getValue(): Promise<string>;
+    getIndex(): number;
+}
+
+declare class Column extends AbstractElementWithParent {
+    index: number;
+    constructor(getParentElement: () => WebElementPromise, index: number, driver?: WebDriver);
+    caption(): Promise<string>;
+    getIndex(): number;
+}
+
+declare class Row extends AbstractElementWithParent {
+    index: number;
+    protected getColumnByCaption: (caption: string) => Promise<Column>;
+    constructor(getParentElement: () => WebElementPromise, index: number, driver?: WebDriver, getColumnByCaption?: (caption: string) => Promise<Column>);
+    protected getRowElement: () => WebElementPromise;
+    getCellByIndex(index: number): Promise<Cell>;
+    getCell(caption: string): Promise<Cell>;
+    select(): Promise<void>;
+    isSelected(): Promise<boolean>;
+    getIndex(): number;
+    getCells(): Promise<Cell[]>;
+}
+
+declare class Table extends AbstractElementWithParent {
+    constructor(getParentElement: () => WebElementPromise, formName: string, driver?: WebDriver);
+    protected getHeaderElement(): Promise<selenium_webdriver.WebElement>;
+    protected getDataGrid(): Promise<selenium_webdriver.WebElement>;
+    protected getTableElement: () => WebElementPromise;
+    getRowByIndex(index: number): Promise<Row>;
+    getColumnByIndex(index: number): Promise<Column>;
+    getColumnByCaption(caption: string): Promise<Column>;
+    selectRowByIndex(index: number): Promise<void>;
+    getRows(): Promise<Row[]>;
+    getColumns(): Promise<Column[]>;
+    element(): Promise<selenium_webdriver.WebElement>;
+}
+
 declare abstract class ListForm extends AbstractForm {
-    titleBy: By;
-    getTitleText(): Promise<string>;
+    protected constructor(driver?: WebDriver);
+    /**
+     * Находит таблицу
+     * @example
+     * const listForm = new MyForm();
+     * //...
+     * expect(listForm.table());
+     */
+    table(): Table;
+    /**
+     * Находит таблицу
+     * @example
+     * const listForm = new MyForm();
+     * //...
+     * expect(listForm.toolbarButton());
+     */
+    toolbarButton(name: string): Promise<TableToolbarButton>;
 }
 
 export { AbstractPage, Editor, FormEdit, FormField, ListForm, LoginPage, NumberEditor, SubsystemsPanel, TextEditor, byTestId, config, createDriver, editorFactory, elementIsNotPresent, signIn };