d5-testing-library 1.0.4 → 1.1.0

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

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -29,15 +39,36 @@ __export(src_exports, {
   SubsystemsPanel: () => SubsystemsPanel,
   TextEditor: () => TextEditor,
   byTestId: () => byTestId,
+  click: () => click,
   config: () => config,
   createDriver: () => createDriver,
   editorFactory: () => editorFactory,
   elementIsNotPresent: () => elementIsNotPresent,
-  signIn: () => signIn
+  signIn: () => signIn,
+  waitElementIsVisible: () => waitElementIsVisible
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/config.ts
+var process = __toESM(require("process"));
+var driversMap = /* @__PURE__ */ new Map();
+var createConfigProxy = (config2) => {
+  return new Proxy(config2, {
+    get(_target, prop) {
+      if (prop === "driver") {
+        return driversMap.get(process.pid);
+      }
+      return Reflect.get(...arguments);
+    },
+    set(_target, prop, value) {
+      if (prop === "driver") {
+        driversMap.set(process.pid, value);
+        return true;
+      }
+      return Reflect.set(...arguments);
+    }
+  });
+};
 var Config = class _Config {
   static instance;
   appConfig;
@@ -49,7 +80,7 @@ var Config = class _Config {
   }
   config = (cfg) => {
     if (!cfg)
-      return this.appConfig;
+      return createConfigProxy(this.appConfig);
     this.appConfig = cfg;
   };
 };
@@ -98,7 +129,7 @@ var AbstractPage = class extends AbstractElement {
 // src/utils/locators.ts
 var import_selenium_webdriver = require("selenium-webdriver");
 var byTestId = (testId, element = "div") => {
-  return import_selenium_webdriver.By.css(`${element}[data-testid=${testId}]`);
+  return import_selenium_webdriver.By.css(`${element}[data-testid="${testId}"]`);
 };
 
 // src/utils/createDriver.ts
@@ -120,6 +151,14 @@ var elementIsNotPresent = function elementIsNotPresent2(locator) {
   });
 };
 
+// src/utils/waitElementIsVisible.ts
+var import_selenium_webdriver4 = require("selenium-webdriver");
+async function waitElementIsVisible({ element, timeout, errorMessage, driver }) {
+  driver = driver ?? config().driver;
+  const condition = import_selenium_webdriver4.until.elementIsVisible(element);
+  await driver.wait(condition.fn, timeout ?? 1e4, errorMessage ?? condition.description());
+}
+
 // src/pageObjects/AbstractElementWithParent.ts
 var AbstractElementWithParent = class extends AbstractElement {
   getParentElement;
@@ -130,7 +169,23 @@ var AbstractElementWithParent = class extends AbstractElement {
   }
   async getElement() {
     const parentEl = await this.getParentElement();
-    return parentEl.findElement(this.elementBy);
+    await waitElementIsVisible({
+      element: parentEl,
+      driver: this.driver
+    });
+    const el = await parentEl.findElement(this.elementBy);
+    await waitElementIsVisible({
+      element: el,
+      driver: this.driver
+    });
+    return el;
+  }
+  async getAttribute(attr) {
+    const el = await this.getElement();
+    return await el.getAttribute(attr);
+  }
+  async getClasses() {
+    return await this.getAttribute("class");
   }
 };
 
@@ -144,9 +199,9 @@ var SubsystemsPanelHeader = class extends AbstractElementWithParent {
 };
 
 // src/pageObjects/elements/SubsystemsPanel/SubsystemsPanel.ts
-var import_selenium_webdriver4 = require("selenium-webdriver");
+var import_selenium_webdriver5 = require("selenium-webdriver");
 var SubsystemsPanel = class extends AbstractElement {
-  panelBy = import_selenium_webdriver4.By.id("aside");
+  panelBy = import_selenium_webdriver5.By.id("aside");
   header;
   constructor(driver) {
     super(driver);
@@ -161,7 +216,7 @@ var SubsystemsPanel = class extends AbstractElement {
 };
 
 // src/pageObjects/elements/Forms/AbstractForm.ts
-var import_selenium_webdriver5 = require("selenium-webdriver");
+var import_selenium_webdriver6 = require("selenium-webdriver");
 var AbstractForm = class extends AbstractPage {
   containerBy;
   popupContainerBy;
@@ -206,20 +261,20 @@ var AbstractForm = class extends AbstractPage {
   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"));
+      const titleEl2 = await popupEl.findElement(import_selenium_webdriver6.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"));
+    let titleEl = await container.findElement(import_selenium_webdriver6.By.className("form-toolbar-name-container"));
     return titleEl.getText();
   }
 };
 
 // src/pageObjects/elements/Forms/FormEdit.ts
-var import_selenium_webdriver8 = require("selenium-webdriver");
+var import_selenium_webdriver13 = require("selenium-webdriver");
 
 // src/pageObjects/elements/Editors/AbstractEditor.ts
-var import_selenium_webdriver6 = require("selenium-webdriver");
+var import_selenium_webdriver7 = require("selenium-webdriver");
 
 // src/pageObjects/AbstractFormElement.ts
 var AbstractFormElement = class extends AbstractElementWithParent {
@@ -229,11 +284,23 @@ var AbstractFormElement = class extends AbstractElementWithParent {
   }
 };
 
+// src/pageObjects/elements/Editors/ClearStrategy/InputClearStrategy.ts
+var InputClearStrategy = class {
+  async clear(editor) {
+    const inputEl = await editor.getInputElement();
+    await inputEl.clear();
+  }
+};
+
 // src/pageObjects/elements/Editors/AbstractEditor.ts
 var AbstractDXEditorWithInput = class extends AbstractFormElement {
+  clearStrategy = new InputClearStrategy();
+  setClearStrategy(strategy) {
+    this.clearStrategy = strategy;
+  }
   async getInputElement() {
     const controlEl = await this.getElement();
-    return controlEl.findElement(import_selenium_webdriver6.By.className("dx-texteditor-input"));
+    return controlEl.findElement(import_selenium_webdriver7.By.className("dx-texteditor-input"));
   }
   async getInputValue() {
     const inputEl = await this.getInputElement();
@@ -241,13 +308,20 @@ var AbstractDXEditorWithInput = class extends AbstractFormElement {
   }
   async setInputValue(value) {
     const inputEl = await this.getInputElement();
-    await inputEl.click();
-    await inputEl.sendKeys(value, import_selenium_webdriver6.Key.ENTER);
+    await click(inputEl, this.driver);
+    await inputEl.sendKeys(value, import_selenium_webdriver7.Key.ENTER);
+  }
+  async clear() {
+    await this.clearStrategy.clear(this);
   }
 };
 
 // src/pageObjects/elements/Editors/TextEditor.ts
 var TextEditor = class extends AbstractDXEditorWithInput {
+  constructor(getParentElement, elementBy, driver) {
+    super(getParentElement, elementBy, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
   getValue() {
     return this.getInputValue();
   }
@@ -258,6 +332,10 @@ var TextEditor = class extends AbstractDXEditorWithInput {
 
 // src/pageObjects/elements/Editors/NumberEditor.ts
 var NumberEditor = class extends AbstractDXEditorWithInput {
+  constructor(getParentElement, elementBy, driver) {
+    super(getParentElement, elementBy, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
   async getValue() {
     const value = await super.getInputValue();
     return value == "" ? null : Number.parseFloat(value);
@@ -273,22 +351,22 @@ var CheckBox = class extends AbstractFormElement {
     const inputEl = await this.getElement();
     const result = await inputEl.getAttribute("aria-checked");
     if (result === "true")
-      return true;
+      return 1;
     if (result === "false")
-      return false;
-    return void 0;
+      return 0;
+    return null;
   }
   async setValue(value) {
     const inputEl = await this.getElement();
     const currentValue = await this.getValue();
     if (currentValue !== value) {
-      await inputEl.click();
+      await click(inputEl, this.driver);
     }
   }
 };
 
 // src/pageObjects/elements/Editors/SelectBoxEditor.ts
-var import_selenium_webdriver7 = require("selenium-webdriver");
+var import_selenium_webdriver9 = require("selenium-webdriver");
 
 // src/utils/xpathHelper.ts
 var XPathHelper = class {
@@ -300,19 +378,53 @@ var XPathHelper = class {
   }
 };
 
+// src/pageObjects/elements/Editors/ClearStrategy/ClearButtonStrategy.ts
+var import_selenium_webdriver8 = require("selenium-webdriver");
+var DX_TEXTEDITOR_EMPTY = "dx-texteditor-empty";
+var DX_CLEAR_BUTTON_AREA = "dx-clear-button-area";
+var ClearButtonStrategy = class {
+  editorContainerClass;
+  constructor(editorContainerClass) {
+    this.editorContainerClass = editorContainerClass;
+  }
+  async isEmptyEditorField(editor) {
+    const parentEl = await editor.getParentElement();
+    const editorContainer = await parentEl.findElement(import_selenium_webdriver8.By.className(this.editorContainerClass));
+    const classAttribute = await editorContainer.getAttribute("class");
+    return classAttribute.includes(DX_TEXTEDITOR_EMPTY);
+  }
+  async clear(editor) {
+    if (await this.isEmptyEditorField(editor)) {
+      throw new Error("This field is already empty");
+    }
+    const clearBtnSelector = `.${this.editorContainerClass} .${DX_CLEAR_BUTTON_AREA}`;
+    const parentEl = await editor.getParentElement();
+    const clearBtn = await parentEl.findElement(import_selenium_webdriver8.By.css(clearBtnSelector));
+    await click(clearBtn, editor.driver);
+  }
+};
+
 // src/pageObjects/elements/Editors/SelectBoxEditor.ts
 var SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS = "d5-multi-select-item";
 var SELECT_BOX_ELEMENT_ROLE = "option";
+var combinedValueXpath = (value) => `${XPathHelper.getRoleXpath(SELECT_BOX_ELEMENT_ROLE)}${XPathHelper.getClassAndValueXpath(
+  SELECT_BOX_OPTION_TEXT_CONTAINER_CLASS,
+  value
+)}`;
+var DX_SELECTBOX = "dx-selectbox";
 var SelectBoxEditor = class extends AbstractDXEditorWithInput {
+  constructor(getParentElement, elementBy, driver) {
+    super(getParentElement, elementBy, driver);
+    this.setClearStrategy(new ClearButtonStrategy(DX_SELECTBOX));
+  }
   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 click(inputEl, this.driver);
+    await inputEl.sendKeys(value, import_selenium_webdriver9.Key.ENTER);
     await this.driver.wait(async () => {
       try {
-        const optElement = await inputEl.findElement(import_selenium_webdriver7.By.xpath(combinedValueXpath));
-        await optElement.click();
+        const optElement = await inputEl.findElement(import_selenium_webdriver9.By.xpath(combinedValueXpath(value)));
+        await click(optElement, this.driver);
         return true;
       } catch (e) {
         return false;
@@ -337,7 +449,7 @@ var SwitchEditor = class extends AbstractFormElement {
       return 1;
     if (result === "OFF")
       return 0;
-    return void 0;
+    return null;
   }
   async setValue(value) {
     if (value !== 0 && value !== 1) {
@@ -346,7 +458,7 @@ var SwitchEditor = class extends AbstractFormElement {
     const inputEl = await this.getElement();
     const currentValue = await this.getValue();
     if (currentValue !== value) {
-      await inputEl.click();
+      await click(inputEl, this.driver);
       await this.driver.wait(async () => {
         const updatedValue = await this.getValue();
         return updatedValue !== currentValue;
@@ -355,21 +467,205 @@ var SwitchEditor = class extends AbstractFormElement {
   }
 };
 
+// src/pageObjects/elements/Editors/TagBox.ts
+var import_selenium_webdriver10 = require("selenium-webdriver");
+var TAGS_SELECTOR = ".dx-tag .tag-text";
+var DX_TAG_CONTAINER = "dx-tag-container";
+var DX_TAGBOX = "dx-tagbox";
+var DX_TEXTEDITOR_EMPTY2 = "dx-texteditor-empty";
+var BTN_OK_SELECTOR = ".dx-tagbox-popup-wrapper .dx-popup-bottom .dx-button.dx-popup-done";
+var TagBox = class extends AbstractDXEditorWithInput {
+  constructor(getParentElement, elementBy, driver) {
+    super(getParentElement, elementBy, driver);
+    this.setClearStrategy(new ClearButtonStrategy(DX_TAGBOX));
+  }
+  async setTagBoxInputValue(values) {
+    const lastElement = values[values.length - 1];
+    const inputEl = await this.getInputElement();
+    await inputEl.click();
+    for (const value of values) {
+      await this.selectOption(inputEl, value, lastElement);
+    }
+    await this.confirmSelection();
+  }
+  async selectOption(inputEl, value, lastElement) {
+    await inputEl.sendKeys(value);
+    await this.driver.wait(async () => {
+      try {
+        const optElement = await inputEl.findElement(import_selenium_webdriver10.By.xpath(combinedValueXpath(value)));
+        await click(optElement, this.driver);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    });
+    if (value !== lastElement) {
+      await inputEl.clear();
+    }
+  }
+  async confirmSelection() {
+    const inputEl = await this.getInputElement();
+    const option = await inputEl.findElement(import_selenium_webdriver10.By.xpath(XPathHelper.getRoleXpath(SELECT_BOX_ELEMENT_ROLE)));
+    const btnOk = await this.driver.findElement(import_selenium_webdriver10.By.css(BTN_OK_SELECTOR));
+    await this.driver.wait(async () => {
+      return await option.getAttribute("aria-selected") === "true";
+    });
+    await click(btnOk, this.driver);
+  }
+  async getTagBoxInputValue() {
+    if (await this.isTagBoxEmpty()) {
+      return [];
+    }
+    const parentEl = await this.getParentElement();
+    const inputEl = await parentEl.findElement(import_selenium_webdriver10.By.className(DX_TAG_CONTAINER));
+    const tags = await inputEl.findElements(import_selenium_webdriver10.By.css(TAGS_SELECTOR));
+    const values = [];
+    for (const tag of tags) {
+      const text = await tag.getText();
+      values.push(text);
+    }
+    return values;
+  }
+  async isTagBoxEmpty() {
+    const parentEl = await this.getParentElement();
+    const tagboxContainer = await parentEl.findElement(import_selenium_webdriver10.By.className(DX_TAGBOX));
+    const classAttribute = await tagboxContainer.getAttribute("class");
+    return classAttribute.includes(DX_TEXTEDITOR_EMPTY2);
+  }
+  async getValue() {
+    const value = await this.getTagBoxInputValue();
+    return value.length ? value : null;
+  }
+  async setValue(values) {
+    if (!Array.isArray(values)) {
+      throw new Error("The provided value is not an array");
+    }
+    await this.setTagBoxInputValue(values);
+  }
+  async remove(itemText) {
+    const tagValues = await this.getValue();
+    const tagExists = tagValues.includes(itemText);
+    if (!tagExists) {
+      throw new Error(`The tag with the text: ${itemText} was not found`);
+    }
+    const parentEl = await this.getParentElement();
+    const inputEl = await parentEl.findElement(import_selenium_webdriver10.By.className(DX_TAG_CONTAINER));
+    const clearBtnTestId = byTestId(`clear-button-${itemText}`);
+    const clearBtn = await inputEl.findElement(clearBtnTestId);
+    await click(clearBtn, this.driver);
+  }
+};
+
+// src/pageObjects/elements/Editors/ButtonGroup.ts
+var import_selenium_webdriver11 = require("selenium-webdriver");
+var ITEM_CLASS = "dx-buttongroup-item";
+var SELECTED_CLASS = "dx-state-selected";
+var ButtonGroup = class extends AbstractFormElement {
+  async getItems() {
+    return (await this.getElement()).findElements(import_selenium_webdriver11.By.className(ITEM_CLASS));
+  }
+  getDataValue(el) {
+    return el.getAttribute("data-value");
+  }
+  async getValue() {
+    const inputEl = await this.getElement();
+    const selectedEl = await inputEl.findElement(import_selenium_webdriver11.By.className(`${ITEM_CLASS} ${SELECTED_CLASS}`));
+    return this.getDataValue(selectedEl);
+  }
+  async setValue(value) {
+    const items = await this.getItems();
+    let buttonEl = void 0;
+    for (const item of items) {
+      const text = await this.getDataValue(item);
+      if (text == value) {
+        buttonEl = item;
+        break;
+      }
+    }
+    if (!buttonEl)
+      throw new Error(`Cannot find item in button group with text: ${value}`);
+    await click(buttonEl, this.driver);
+  }
+};
+
+// src/pageObjects/elements/Editors/BooleanSelector.ts
+var BooleanSelector = class extends ButtonGroup {
+  // @ts-ignore
+  async getValue() {
+    const value = await super.getValue();
+    return value === "null" ? null : value === "1" ? 1 : 0;
+  }
+  // @ts-ignore
+  async setValue(value) {
+    const val = value == null ? "null" : value ? "1" : "0";
+    await super.setValue(val);
+  }
+};
+
+// src/pageObjects/elements/Editors/DateEditor.ts
+var import_selenium_webdriver12 = require("selenium-webdriver");
+var DateEditor = class extends AbstractDXEditorWithInput {
+  constructor(getParentElement, elementBy, driver) {
+    super(getParentElement, elementBy, driver);
+    this.setClearStrategy(new InputClearStrategy());
+  }
+  async getControlElement() {
+    const controlEl = await this.getElement();
+    return controlEl.findElement(import_selenium_webdriver12.By.className("dx-dropdowneditor-input-wrapper"));
+  }
+  async getDateElement() {
+    const controlEl = await this.getControlElement();
+    return controlEl.findElement(import_selenium_webdriver12.By.css("input[type=hidden]"));
+  }
+  async setDateValue(value) {
+    const dateEl = await this.getInputElement();
+    const stringDate = value.toJSON().split("T")[0];
+    const dateArr = stringDate.split("-");
+    const [year, month, day] = dateArr;
+    const keys = day + month + year;
+    await click(dateEl, this.driver);
+    const actions = this.driver.actions({ async: true });
+    await actions.move({ origin: dateEl }).sendKeys(import_selenium_webdriver12.Key.HOME).perform();
+    await actions.move({ origin: dateEl }).sendKeys(keys, import_selenium_webdriver12.Key.ENTER).perform();
+  }
+  async getDateValue() {
+    const inputEl = await this.getDateElement();
+    return inputEl.getAttribute("value");
+  }
+  async getValue() {
+    const value = await this.getDateValue();
+    return value == "" ? null : new Date(value);
+  }
+  setValue(value) {
+    if (typeof value === "object") {
+      return this.setDateValue(value);
+    }
+    throw new Error(`Value is incorrect. It should be Object`);
+  }
+};
+
 // src/pageObjects/elements/Editors/editorFactory.ts
 var editorFactory = async (getParentElement, elementBy, driver) => {
   const elementInstance = new AbstractFormElement(getParentElement, elementBy, driver);
-  const element = await elementInstance.getElement();
-  const classSting = await element.getAttribute("class");
+  const classSting = await elementInstance.getClasses();
   if (classSting.includes("text-control"))
     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("multi-select-control"))
+    return new TagBox(getParentElement, elementBy, driver);
   if (classSting.includes("select-control"))
     return new SelectBoxEditor(getParentElement, elementBy, driver);
   if (classSting.includes("switch-control"))
     return new SwitchEditor(getParentElement, elementBy, driver);
+  if (classSting.includes("date-control"))
+    return new DateEditor(getParentElement, elementBy, driver);
+  if (classSting.includes("buttons-group"))
+    return new BooleanSelector(getParentElement, elementBy, driver);
+  if (classSting.includes("button-group-field"))
+    return new ButtonGroup(getParentElement, elementBy, driver);
   throw new Error("Unknown type of editor. Please write ticket to the support");
 };
 
@@ -380,6 +676,9 @@ function createDataTestId(formName, itemType, itemName) {
 function createFieldTestId(formName, itemName) {
   return createDataTestId(formName, "form_field" /* FORM_FIELD */, itemName);
 }
+function createGroupTestId(formName, itemName) {
+  return createDataTestId(formName, "group" /* GROUP */, itemName);
+}
 function createTableId(formName) {
   return `${"table" /* TABLE */}-${formName}`;
 }
@@ -416,14 +715,82 @@ var FormField = class extends AbstractElementWithParent {
     await this.initEditor();
     return this.editor.setValue(value);
   }
+  /**
+   * Очищает значение в поле
+   * @example
+   * await formEdit.field('NumberFld').clear();
+   */
+  async clear() {
+    await this.initEditor();
+    if (!this.editor.clear) {
+      throw new Error("The clear method is not available for this field type.");
+    }
+    return this.editor.clear();
+  }
+  /**
+   * Удаляет тег по переданному тексту
+   * @example
+   * await formEdit.field('TagBox').remove('test');
+   */
+  async remove(itemText) {
+    await this.initEditor();
+    if (!this.editor.remove) {
+      throw new Error("This method is only available for the TagBox field.");
+    }
+    return this.editor.remove(itemText);
+  }
+};
+
+// src/pageObjects/elements/Groups/AbstractGroup.ts
+var AbstractDXGroup = class extends AbstractFormElement {
+};
+
+// src/pageObjects/elements/Groups/Panel.ts
+var Panel = class extends AbstractDXGroup {
+  async isDisplayed() {
+    const groupElement = await this.getElement();
+    return await groupElement.isDisplayed();
+  }
+};
+
+// src/pageObjects/elements/Groups/groupFactory.ts
+var groupFactory = async (getParentElement, elementBy, driver) => {
+  const elementInstance = new AbstractFormElement(getParentElement, elementBy, driver);
+  const classSting = await elementInstance.getClasses();
+  if (classSting.includes("panel-group"))
+    return new Panel(getParentElement, elementBy, driver);
+  throw new Error("Unknown type of group. Please write ticket to the support");
+};
+
+// src/pageObjects/elements/FormGroup.ts
+var FormGroup = class extends AbstractElementWithParent {
+  editor;
+  constructor(getParentElement, formName, name, driver) {
+    super(getParentElement, driver);
+    this.elementBy = byTestId(createGroupTestId(formName, name));
+  }
+  async initEditor() {
+    if (!this.editor) {
+      this.editor = await groupFactory(this.getParentElement, this.elementBy, this.driver);
+    }
+  }
+  /**
+   * Возвращает булевое значение доступна ли группа
+   * @example
+   * expect(await tableList.group('MainSuperPanel').isDisplayed();
+   */
+  async isDisplayed() {
+    await this.initEditor();
+    return this.editor.isDisplayed();
+  }
 };
 
 // src/pageObjects/elements/Forms/FormEdit.ts
 var FormEdit = class extends AbstractForm {
-  saveButtonBy = import_selenium_webdriver8.By.id("button-save");
+  saveButtonBy = import_selenium_webdriver13.By.id("button-save");
   constructor(driver) {
     super(driver);
-    this.popupContainerBy = import_selenium_webdriver8.By.className(`popup form-edit-${this.formName}`);
+    this.popupContainerBy = import_selenium_webdriver13.By.className(`popup form-edit-${this.formName}`);
   }
   /**
    * Находит поле формы редактирования по имени
@@ -435,6 +802,28 @@ var FormEdit = class extends AbstractForm {
   field(name) {
     return new FormField(this.getContainerElement, this.formName, name, this.driver);
   }
+  /**
+   * Проверяет не отключена ли кнопка Сохранить
+   * @example
+   * const formEdit = new MyForm();
+   * //...
+   * await formEdit.isSaveButtonDisabled();
+   */
+  async isSaveButtonDisabled() {
+    const saveButton = await this.driver.findElement(this.saveButtonBy);
+    const result = await saveButton.getAttribute("aria-disabled");
+    return result === "true";
+  }
+  /**
+   * Находит группу формы редактирования по имени
+   * @example
+   * const formEdit = new MyForm();
+   * //...
+   * expect(await formEdit.group('Name');
+   */
+  group(name) {
+    return new FormGroup(this.getContainerElement, this.formName, name, this.driver);
+  }
   /**
    * Нажатие на кнопку Сохранить
    * @example
@@ -443,41 +832,42 @@ var FormEdit = class extends AbstractForm {
    * await formEdit.saveButtonClick();
    */
   async saveButtonClick() {
-    await this.driver.findElement(this.saveButtonBy).click();
+    const saveButton = await this.driver.findElement(this.saveButtonBy);
+    await this.driver.wait(async () => !await this.isSaveButtonDisabled(), void 0, "Button is disabled");
+    await click(saveButton, this.driver);
   }
 };
 
 // src/pageObjects/elements/Forms/ListForm.ts
-var import_selenium_webdriver14 = require("selenium-webdriver");
+var import_selenium_webdriver19 = require("selenium-webdriver");
 
 // src/pageObjects/elements/Table/Table.ts
-var import_selenium_webdriver11 = require("selenium-webdriver");
+var import_selenium_webdriver16 = require("selenium-webdriver");
 
 // src/pageObjects/elements/Table/utils.ts
-var import_selenium_webdriver9 = require("selenium-webdriver");
+var import_selenium_webdriver14 = require("selenium-webdriver");
 var getRowPathByIndex = (index) => {
-  return import_selenium_webdriver9.By.xpath(`//tr[@aria-rowindex="${transformInputIndex(index)}"]`);
+  return import_selenium_webdriver14.By.css(`tr[aria-rowindex="${transformInputIndex(index)}"]`);
 };
+var getColumnByIndexCssSelector = (columnIndex) => `td[aria-colindex="${transformInputIndex(columnIndex)}"]`;
 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}"]`);
+  return import_selenium_webdriver14.By.css(getColumnByIndexCssSelector(index));
 };
+var getColumnByCaptionCssSelector = (caption) => `td[role="columnheader"][aria-label="Column ${caption}"]`;
 var getCellPathByIndex = (index) => {
-  return import_selenium_webdriver9.By.xpath(`//td[@role="gridcell"][@aria-colindex="${transformInputIndex(index)}"]`);
+  return import_selenium_webdriver14.By.css(`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");
+var import_selenium_webdriver15 = require("selenium-webdriver");
 
 // src/pageObjects/elements/Table/elements/Cell.ts
 var Cell = class extends AbstractElementWithParent {
   index;
-  constructor(getParentElement, index, driver) {
-    super(getParentElement, driver);
+  constructor(rowEl, index, driver) {
+    super(() => Promise.resolve(rowEl), driver);
     this.index = index;
     this.elementBy = getCellPathByIndex(index);
   }
@@ -491,6 +881,9 @@ var Cell = class extends AbstractElementWithParent {
 };
 
 // src/pageObjects/elements/Table/elements/Row.ts
+var DX_SELECTION_CLASS = "dx-selection";
+var DX_ROW_EDIT_CLASS = "dx-edit-row";
+var DX_DATA_ROW_CLASS = "dx-data-row";
 var Row = class extends AbstractElementWithParent {
   index;
   getColumnByCaption;
@@ -500,14 +893,11 @@ var Row = class extends AbstractElementWithParent {
     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);
+      return new Cell(rowEl, index, this.driver);
     }
     throw new Error(`Cannot find cell by index: ${index}`);
   }
@@ -521,7 +911,11 @@ var Row = class extends AbstractElementWithParent {
   }
   async select() {
     const rowEl = await this.getElement();
-    await rowEl.click();
+    await click(rowEl, this.driver);
+    await this.driver.wait(async () => {
+      const classes = await rowEl.getAttribute("class");
+      return classes.includes(DX_SELECTION_CLASS);
+    }, 500, "Cannot select row");
   }
   async isSelected() {
     const rowEl = await this.getElement();
@@ -533,34 +927,38 @@ var Row = class extends AbstractElementWithParent {
   }
   async getCells() {
     const rowEl = await this.getElement();
-    const cells = await rowEl.findElements(import_selenium_webdriver10.By.css(`td[role="gridcell"]`));
+    const cells = await rowEl.findElements(import_selenium_webdriver15.By.css(`td[role="gridcell"]`));
     const result = [];
     cells.forEach((_, index) => {
-      const newCell = new Cell(this.getRowElement, index, this.driver);
+      const newCell = new Cell(rowEl, index, this.driver);
       result.push(newCell);
     });
     return result;
   }
-  async clickInlineButton(rowClass, buttonClass) {
-    const fixedTable = await this.getParentElement().findElement(
-      import_selenium_webdriver10.By.css(".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed")
+  async clickInlineButton(buttonClass) {
+    const FIXED_TABLE_CSS_SELECTOR = ".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed";
+    const buttonCssSelector = `.${DX_DATA_ROW_CLASS}[aria-rowindex="${transformInputIndex(this.index)}"] .${buttonClass}`;
+    const button = (await this.getParentElement()).findElement(
+      import_selenium_webdriver15.By.css(`${FIXED_TABLE_CSS_SELECTOR} ${buttonCssSelector}`)
     );
-    const rowEl = await fixedTable.findElement(import_selenium_webdriver10.By.className(rowClass));
-    const button = await rowEl.findElement(import_selenium_webdriver10.By.className(buttonClass));
-    if (button) {
-      return button.click();
-    }
-    throw new Error(`Cannot find ${buttonClass} button`);
+    return click(button, this.driver);
+  }
+  async checkEditingMode(isEditing, msg) {
+    await this.driver.wait(async () => {
+      return (await this.getClasses()).includes(DX_ROW_EDIT_CLASS) === isEditing;
+    }, 2e3, msg);
   }
   async edit() {
-    await this.select();
-    return this.clickInlineButton("dx-selection", "edit");
+    await this.clickInlineButton("edit");
+    await this.checkEditingMode(true, "Row did not switch to edit mode");
   }
   async save() {
-    return this.clickInlineButton("dx-edit-row", "save");
+    await this.clickInlineButton("save");
+    await this.checkEditingMode(false, "Row did not saved");
   }
   async cancel() {
-    return this.clickInlineButton("dx-edit-row", "cancel");
+    await this.clickInlineButton("cancel");
+    await this.checkEditingMode(false, "Row did not switch to normal mode");
   }
 };
 
@@ -583,20 +981,21 @@ var Column = class extends AbstractElementWithParent {
 
 // src/pageObjects/elements/Table/Table.ts
 var Table = class extends AbstractElementWithParent {
+  formName;
   constructor(getParentElement, formName, driver) {
     super(getParentElement, driver);
-    this.elementBy = import_selenium_webdriver11.By.id(createTableId(formName));
+    this.elementBy = import_selenium_webdriver16.By.id(createTableId(formName));
+    this.formName = formName;
   }
-  async getHeaderElement() {
-    const parentEl = await this.getElement();
-    return parentEl.findElement(import_selenium_webdriver11.By.className("dx-header-row"));
+  getHeaderCssSelector() {
+    return ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
   }
   async getDataGrid() {
     const parentEl = await this.getElement();
-    return parentEl.findElement(import_selenium_webdriver11.By.css(`div[role="grid"]`));
+    return parentEl.findElement(import_selenium_webdriver16.By.css(`div[role="grid"]`));
   }
   getTableElement = () => {
-    return this.driver.findElement(this.elementBy);
+    return this.getElement();
   };
   async getRowByIndex(index) {
     const gridContainer = await this.getDataGrid();
@@ -607,16 +1006,14 @@ var Table = class extends AbstractElementWithParent {
     throw new Error(`Cannot find row by index: ${index}`);
   }
   async getColumnByIndex(index) {
-    const headerContainer = await this.getHeaderElement();
-    const column = await headerContainer.findElement(getColumnPathByIndex(index));
+    const column = await (await this.getElement()).findElement(import_selenium_webdriver16.By.css(`${this.getHeaderCssSelector()} ${getColumnByIndexCssSelector(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));
+    const column = await (await this.getElement()).findElement(import_selenium_webdriver16.By.css(`${this.getHeaderCssSelector()} ${getColumnByCaptionCssSelector(caption)}`));
     if (column) {
       const index = await column.getAttribute("aria-colindex");
       return new Column(this.getTableElement, transformOutputIndex(index), this.driver);
@@ -633,7 +1030,7 @@ var Table = class extends AbstractElementWithParent {
   }
   async getRows() {
     const gridContainer = await this.getDataGrid();
-    const rows = await gridContainer.findElements(import_selenium_webdriver11.By.className("dx-row dx-data-row"));
+    const rows = await gridContainer.findElements(import_selenium_webdriver16.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));
@@ -642,8 +1039,7 @@ var Table = class extends AbstractElementWithParent {
     return result;
   }
   async getColumns() {
-    const headerContainer = await this.getHeaderElement();
-    const columns = await headerContainer.findElements(import_selenium_webdriver11.By.css(`td[role="columnheader"]`));
+    const columns = await (await this.getElement()).findElements(import_selenium_webdriver16.By.css(`${this.getHeaderCssSelector()} td[role="columnheader"]`));
     const result = [];
     columns.forEach((_, index) => {
       const newCol = new Column(this.getTableElement, index, this.driver);
@@ -651,25 +1047,40 @@ var Table = class extends AbstractElementWithParent {
     });
     return result;
   }
-  async element() {
+  element() {
     return this.getElement();
   }
+  /**
+   * Находит поле когда форма находится в состоянии редактирования
+   * @example
+   * const form = new MyForm();
+   * //...
+   * expect(await form.field('Name').getValue()).toBe('test value');
+   */
+  field(name) {
+    return new FormField(this.getTableElement, this.formName, name, this.driver);
+  }
 };
 
 // src/pageObjects/elements/TableToolbar/TableToolbar.ts
-var import_selenium_webdriver13 = require("selenium-webdriver");
+var import_selenium_webdriver18 = require("selenium-webdriver");
 
 // src/pageObjects/elements/TableToolbar/TableToolbarButton.ts
-var import_selenium_webdriver12 = require("selenium-webdriver");
+var import_selenium_webdriver17 = require("selenium-webdriver");
 var TOOLBAR_BUTTON_CLASS = "toolbar-button";
 var TableToolbarButton = class extends AbstractElementWithParent {
+  name;
   constructor(getParentElement, name, driver) {
     super(getParentElement, driver);
-    this.elementBy = import_selenium_webdriver12.By.id(`${TOOLBAR_BUTTON_CLASS}-${name}`);
+    this.name = name;
+    this.elementBy = import_selenium_webdriver17.By.id(`${TOOLBAR_BUTTON_CLASS}-${name}`);
   }
   async click() {
     const button = await this.getElement();
-    return button.click();
+    await this.driver.wait(async () => {
+      return await button.isDisplayed() && !await this.isDisabled();
+    }, 1e3, `Button ${this.name} cannot be clicked. It is not displayed or it is disabled`);
+    return click(button, this.driver);
   }
   async isDisabled() {
     const button = await this.getElement();
@@ -683,14 +1094,14 @@ 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}`);
+    this.elementBy = import_selenium_webdriver18.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}`));
+    const button = await toolbar.findElement(import_selenium_webdriver18.By.id(`${TOOLBAR_BUTTON_CLASS}-${name}`));
     if (button) {
       return new TableToolbarButton(this.getTableToolbarElement, name, this.driver);
     }
@@ -702,7 +1113,7 @@ var TableToolbar = class extends AbstractElementWithParent {
 var ListForm = class extends AbstractForm {
   constructor(driver) {
     super(driver);
-    this.popupContainerBy = import_selenium_webdriver14.By.className(`popup form-inline-${this.formName}`);
+    this.popupContainerBy = import_selenium_webdriver19.By.className(`popup form-inline-${this.formName}`);
   }
   /**
    * Находит таблицу
@@ -714,6 +1125,16 @@ var ListForm = class extends AbstractForm {
   table() {
     return new Table(this.getContainerElement, this.formName, this.driver);
   }
+  /**
+   * Находит группу на лист форме по имени
+   * @example
+   * const formEdit = new MyForm();
+   * //...
+   * expect(await formEdit.group('Name');
+   */
+  group(name) {
+    return new FormGroup(this.getContainerElement, this.formName, name, this.driver);
+  }
   /**
    * Находит таблицу
    * @example
@@ -737,12 +1158,27 @@ async function signIn(driver) {
   return webDriver;
 }
 
+// src/utils/actions.ts
+var click = async (webElement, driver) => {
+  driver = driver ?? config().driver;
+  const actions = driver.actions({ async: true });
+  await actions.move({ origin: webElement }).click().perform();
+};
+
 // src/pageObjects/pages/LoginPage.ts
 var LOGIN_PATH = "/login";
 var LoginPage = class extends AbstractPage {
   usernameField = byTestId("loginField", "input");
   passwordField = byTestId("passwordField", "input");
   loginButton = byTestId("loginButton");
+  async locate() {
+    await super.locate();
+    const login = await this.driver.findElement(this.usernameField);
+    await waitElementIsVisible({
+      element: login,
+      driver: this.driver
+    });
+  }
   get path() {
     return LOGIN_PATH;
   }
@@ -753,7 +1189,7 @@ var LoginPage = class extends AbstractPage {
     await this.driver.findElement(this.passwordField).sendKeys(password);
   }
   async clickLoginButton() {
-    await this.driver.findElement(this.loginButton).click();
+    await click(await this.driver.findElement(this.loginButton), this.driver);
   }
   async loginWith(username, password) {
     await this.enterUsername(username);
@@ -775,9 +1211,11 @@ var LoginPage = class extends AbstractPage {
   SubsystemsPanel,
   TextEditor,
   byTestId,
+  click,
   config,
   createDriver,
   editorFactory,
   elementIsNotPresent,
-  signIn
+  signIn,
+  waitElementIsVisible
 });