d5-testing-library 1.8.0-alpha.0 → 1.8.0-alpha.10

package/dist/{chunk-WUPIBFH7.mjs → chunk-PS3VVRTQ.mjs}

@@ -16,7 +16,7 @@ import {
   wait,
   waitElementIsClickable,
   waitElementIsVisible
-} from "./chunk-JITTN2NY.mjs";
+} from "./chunk-NXQ4TYFN.mjs";
 
 // src/pageObjects/elements/Table/Table.ts
 import { By as By5 } from "selenium-webdriver";
@@ -94,10 +94,12 @@ var DX_DATA_ROW_CLASS = "dx-data-row";
 var Row = class extends AbstractElementWithParent {
   index;
   getColumnBy;
-  constructor(parentCssSelector, index, driver, getColumnBy) {
+  fixedTableContentCssSelector;
+  constructor(parentCssSelector, fixedTableContentCssSelector, index, driver, getColumnBy) {
     super(parentCssSelector, getCssRowByIndexSelector(index), driver);
     this.index = index;
     this.getColumnBy = getColumnBy;
+    this.fixedTableContentCssSelector = fixedTableContentCssSelector;
   }
   _getCell({ index, name, title }) {
     return new Cell(
@@ -147,12 +149,11 @@ var Row = class extends AbstractElementWithParent {
     return result;
   }
   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 fixElementStaleError(
-      By3.css(`${this.parentCssSelector} ${FIXED_TABLE_CSS_SELECTOR} ${buttonCssSelector}`),
+      By3.css(`${this.parentCssSelector} ${this.fixedTableContentCssSelector} ${buttonCssSelector}`),
       this.driver
     );
     return click(button, this.driver);
@@ -239,10 +240,14 @@ var Column = class extends AbstractElementWithParent {
 var Table = class extends AbstractElementWithParent {
   formName;
   headerCssSelector;
-  constructor(parentCssSelector, headerCssSelector, formName, driver) {
+  fixedTableContentCssSelector;
+  tableContentCssSelector;
+  constructor(parentCssSelector, headerCssSelector, tableContentCssSelector, fixedTableContentCssSelector, formName, driver) {
     super(parentCssSelector, `#${createTableId(formName)}`, driver);
     this.formName = formName;
     this.headerCssSelector = headerCssSelector;
+    this.fixedTableContentCssSelector = fixedTableContentCssSelector;
+    this.tableContentCssSelector = tableContentCssSelector;
   }
   getColumnBy = (args) => {
     if (args.title) {
@@ -251,7 +256,7 @@ var Table = class extends AbstractElementWithParent {
     return this.getColumnByName(args.name);
   };
   getRowByIndex(index) {
-    return new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
+    return new Row(this.getFullCssSelector(), this.fixedTableContentCssSelector, index, this.driver, this.getColumnBy);
   }
   getColumnByIndex(index) {
     return new Column({
@@ -280,10 +285,17 @@ var Table = class extends AbstractElementWithParent {
     return this.getRowByIndex(index).select();
   }
   async getRows() {
-    const rows = await this.driver.findElements(By5.css(`${this.getFullCssSelector()} .dx-row.dx-data-row`));
+    const rowsFullCssSelector = `${this.getFullCssSelector()} ${this.tableContentCssSelector} .dx-row.dx-data-row`;
+    const rows = await this.driver.findElements(By5.css(rowsFullCssSelector));
     const result = [];
     rows.forEach((_, index) => {
-      const newRow = new Row(this.getFullCssSelector(), index, this.driver, this.getColumnBy);
+      const newRow = new Row(
+        this.getFullCssSelector(),
+        this.fixedTableContentCssSelector,
+        index,
+        this.driver,
+        this.getColumnBy
+      );
       result.push(newRow);
     });
     return result;
@@ -367,9 +379,10 @@ var isString = function(object) {
 
 // src/pageObjects/elements/TableToolbar/ToolbarMenu.ts
 var SPINDOWN_CLASS = ".dx-icon-spindown";
+var CONTEXT_MENU_CLASS = "dx-context-menu";
 var buttonGroupItemSelector = (formName, name) => byTestIdCssSelector(`ftb-${formName}-${name}`);
 var getFullCssSelector = (formName, name) => `${buttonGroupItemSelector(formName, name)} ${SPINDOWN_CLASS}`;
-var buttonByTextXpath = (text) => `.//span[contains(@class, "dx-menu-item-text") and contains(text(), "${text}")]`;
+var buttonByTextXpath = (text) => `//div[contains(@class, '${CONTEXT_MENU_CLASS}')]//span[contains(@class, 'dx-menu-item-text') and text()='${text}']`;
 var ToolbarMenu = class extends AbstractElementWithParent {
   _formName;
   constructor(parentCssSelector, formName, name, driver) {
@@ -445,6 +458,14 @@ var ToolbarItem = class extends AbstractElementWithParent {
     await this.init();
     return await this._button.isDisabled();
   }
+  async isDisplayed() {
+    try {
+      await this.init();
+      return this._button.isDisplayed();
+    } catch (error) {
+      return false;
+    }
+  }
   get menu() {
     return new ToolbarMenu(this.parentCssSelector, this._formName, this._itemName, this.driver);
   }
@@ -463,10 +484,105 @@ var FormToolbar = class extends AbstractElementWithParent {
   }
 };
 
+// src/pageObjects/elements/Filters/FilterOperation.ts
+import { By as By7 } from "selenium-webdriver";
+var FILTER_OPERATIONS = [
+  "=",
+  "<>",
+  "<",
+  ">",
+  "<=",
+  ">=",
+  "contains",
+  "between",
+  "isanyof",
+  "isnotanyof",
+  "isblank",
+  "isnotblank",
+  "startwith",
+  "bywords"
+];
+var BUTTON_OPERATION_WIDGET = "operation-widget";
+var OPERATIONS_WIDGET_POPUP = "operation-type-widget-popup";
+var getWidgetInPopupSelector = (operationName) => `.dx-list-item [data-operation="${operationName}"]`;
+var FilterOperation = class extends AbstractElementWithParent {
+  _testId;
+  constructor({ parentCssSelector, filterTestID, driver }) {
+    super(parentCssSelector, `${byTestIdCssSelector(`${BUTTON_OPERATION_WIDGET}-${filterTestID}`)}`, driver);
+    this._testId = filterTestID;
+  }
+  async initOperationWidget() {
+    const widgetButtonEl = await this.getElement();
+    await waitElementIsClickable({
+      element: widgetButtonEl,
+      errorMessage: "Widget operation is not clickable",
+      driver: this.driver
+    });
+    const clickableElement = await widgetButtonEl.findElement(By7.className("dx-icon"));
+    await click(clickableElement, this.driver);
+    try {
+      const widgetPopupEl = await this.driver.findElement(By7.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)}`));
+      await waitElementIsVisible({
+        element: widgetPopupEl,
+        errorMessage: `Operation widget popup is not visible`,
+        driver: this.driver
+      });
+    } catch (_) {
+      throw `Operation widget popup is not visible`;
+    }
+  }
+  async setOperation(operationName) {
+    if (!FILTER_OPERATIONS.includes(operationName)) {
+      throw new Error(`Operation with name "${operationName}" is not correct.`);
+    }
+    await this.initOperationWidget();
+    const operationEl = await fixElementStaleError(By7.css(`${byTestIdCssSelector(`${OPERATIONS_WIDGET_POPUP}-${this._testId}`)} ${getWidgetInPopupSelector(operationName)}`), this.driver);
+    await click(operationEl, this.driver);
+    await wait(
+      async () => {
+        const currOperationName = await this.getAttribute("data-operation");
+        if (operationName === "isblank")
+          return true;
+        return currOperationName === operationName;
+      },
+      this.driver,
+      "Operation is not changed"
+    );
+  }
+  async getOperation() {
+    const result = await this.getAttribute("data-operation");
+    if (!result)
+      throw new Error("Operation not found");
+    return result;
+  }
+  async setIsBlank(value) {
+    const currValue = await this.getIsBlank();
+    if (currValue !== value) {
+      await this.setOperation("isblank");
+      await wait(
+        async () => {
+          const currIsBlank = await this.getIsBlank();
+          return currIsBlank === value;
+        },
+        this.driver,
+        "Operation is not changed"
+      );
+    }
+  }
+  async getIsBlank() {
+    const result = await this.getAttribute("data-hasblank");
+    return result === "true";
+  }
+};
+
 // src/pageObjects/elements/Filters/FormFilterField.ts
 var FormFilterField = class extends AbstractEditor {
+  formName;
+  name;
   constructor(parentCssSelector, formName, name, driver) {
     super(parentCssSelector, byTestIdCssSelector(createLayoutFilterTestId(formName, name)), driver);
+    this.formName = formName;
+    this.name = name;
   }
   /**
    * Возвращает значение в поле
@@ -482,8 +598,15 @@ var FormFilterField = class extends AbstractEditor {
    * @example
    * await form.formFilter('NumberFld').setValue(123);
    * await form.formFilter('TextFld').setValue('TestValue');
+   * await form.formFilter('TextFld').setValue('TestValue', '=', true);
    */
-  async setValue(value) {
+  async setValue(value, operation, isBlank) {
+    if (typeof operation === "string") {
+      await this.setOperation(operation);
+    }
+    if (typeof isBlank === "boolean") {
+      await this.setIsBlank(isBlank);
+    }
     return super.setValue(value);
   }
   /**
@@ -502,15 +625,64 @@ var FormFilterField = class extends AbstractEditor {
   async remove(itemText) {
     return super.remove(itemText);
   }
+  /**
+   * Инициализация операции фильтра
+   */
+  async initOperation() {
+    return new FilterOperation({
+      parentCssSelector: this.parentCssSelector,
+      filterTestID: createLayoutFilterTestId(this.formName, this.name)
+    });
+  }
+  /**
+   * Устанавливает операцию для фильтра
+   * @example
+   * await form.formFilter('TagBox').setOperation("=");
+   */
+  async setOperation(operationName) {
+    const filterOperation = await this.initOperation();
+    await filterOperation.setOperation(operationName);
+  }
+  /**
+   * Возвращает операцию фильтра
+   * @example
+   * expect(await form.formFilter('NumberFld').getOperation()).toBe("=");
+   */
+  async getOperation() {
+    const filterOperation = await this.initOperation();
+    return await filterOperation.getOperation();
+  }
+  /**
+   * Устанавливает операцию 'isblank' для фильтра
+   * @example
+   * await form.formFilter('TagBox').setIsBlank(true);
+   */
+  async setIsBlank(value) {
+    const filterOperation = await this.initOperation();
+    await filterOperation.setIsBlank(value);
+  }
+  /**
+   * Возвращает true|false, если операция 'isblank' установлена для фильтра
+   * @example
+   * expect(await form.formFilter('NumberFld').getIsBlank()).toBe(false);
+   */
+  async getIsBlank() {
+    const filterOperation = await this.initOperation();
+    return await filterOperation.getIsBlank();
+  }
 };
 
 // src/pageObjects/elements/Filters/FilterPanel.ts
-import { By as By7 } from "selenium-webdriver";
+import { By as By8 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Filters/PanelFilterField.ts
 var PanelFilterField = class extends AbstractEditor {
+  formName;
+  name;
   constructor(parentCssSelector, formName, name, driver) {
     super(parentCssSelector, byTestIdCssSelector(createDocFilterTestId(formName, name)), driver);
+    this.formName = formName;
+    this.name = name;
   }
   /**
    * Возвращает значение в поле
@@ -526,8 +698,15 @@ var PanelFilterField = class extends AbstractEditor {
    * @example
    * await form.filterPanel.filterField('NumberFld').setValue(123);
    * await form.filterPanel.filterField('TextFld').setValue('TestValue');
+   * await form.filterPanel.filterField('TextFld').setValue('TestValue', '=', true);
    */
-  async setValue(value) {
+  async setValue(value, operation, isBlank) {
+    if (typeof operation === "string") {
+      await this.setOperation(operation);
+    }
+    if (typeof isBlank === "boolean") {
+      await this.setIsBlank(isBlank);
+    }
     return super.setValue(value);
   }
   /**
@@ -546,6 +725,51 @@ var PanelFilterField = class extends AbstractEditor {
   async remove(itemText) {
     return super.remove(itemText);
   }
+  /**
+   * Инициализация операции фильтра
+   */
+  async initOperation() {
+    return new FilterOperation({
+      parentCssSelector: this.parentCssSelector,
+      filterTestID: createDocFilterTestId(this.formName, this.name)
+    });
+  }
+  /**
+   * Устанавливает операцию для фильтра
+   * @example
+   * await form.filterPanel.filterField('TagBox').setOperation("=");
+   */
+  async setOperation(operationName) {
+    const filterOperation = await this.initOperation();
+    await filterOperation.setOperation(operationName);
+  }
+  /**
+   * Возвращает операцию фильтра
+   * @example
+   * expect(await form.filterPanel.filterField('NumberFld').getOperation()).toBe("=");
+   */
+  async getOperation() {
+    const filterOperation = await this.initOperation();
+    return await filterOperation.getOperation();
+  }
+  /**
+   * Устанавливает операцию 'isblank' для фильтра
+   * @example
+   * await form.filterPanel.filterField('TagBox').setIsBlank(true);
+   */
+  async setIsBlank(value) {
+    const filterOperation = await this.initOperation();
+    await filterOperation.setIsBlank(value);
+  }
+  /**
+   * Возвращает true|false, если операция 'isblank' установлена для фильтра
+   * @example
+   * expect(await form.filterPanel.filterField('NumberFld').getIsBlank()).toBe(false);
+   */
+  async getIsBlank() {
+    const filterOperation = await this.initOperation();
+    return await filterOperation.getIsBlank();
+  }
 };
 
 // src/pageObjects/elements/Filters/FilterPanel.ts
@@ -560,7 +784,7 @@ var FilterPanel = class extends AbstractElement {
   async filterPanelButtons() {
     const selector = `${this.elementCssSelector} ${FILTER_PANEL_SELECTOR} .filter-panel__buttons-panel .dx-button-text`;
     const el = await this.getElement();
-    return el.findElements(By7.css(selector));
+    return el.findElements(By8.css(selector));
   }
   constructor(formName, driver) {
     super(driver, drawerSelector(formName));
@@ -593,13 +817,13 @@ var FilterPanel = class extends AbstractElement {
     await this.driver.sleep(300);
   }
   async close() {
-    const btn = await this.driver.findElement(By7.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
+    const btn = await this.driver.findElement(By8.css(`${this.elementCssSelector} ${CLOSE_SELECTOR}`));
     await click(btn, this.driver);
   }
 };
 
 // src/pageObjects/elements/Filters/ColumnFilter.ts
-import { By as By8 } from "selenium-webdriver";
+import { By as By9 } from "selenium-webdriver";
 
 // src/pageObjects/elements/Filters/HeaderFilterField.ts
 var HeaderFilterField = class extends AbstractEditor {
@@ -639,11 +863,11 @@ var ColumnFilter = class extends AbstractElement {
   }
   async getApplyButton() {
     const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${APPLY_SELECTOR}`;
-    return this.driver.findElement(By8.css(selector));
+    return this.driver.findElement(By9.css(selector));
   }
   async getCancelButton() {
     const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${CANCEL_SELECTOR}`;
-    return this.driver.findElement(By8.css(selector));
+    return this.driver.findElement(By9.css(selector));
   }
   async apply() {
     const btn = await this.getApplyButton();
@@ -657,17 +881,34 @@ var ColumnFilter = class extends AbstractElement {
     const columnEl = await this._column.getElement();
     const actions = this.driver.actions({ async: true });
     await actions.move({ origin: columnEl }).perform();
-    const elements = await columnEl.findElements(By8.css(HEADER_FILTER_ICON));
-    const headerFilterIcon = elements[1];
-    await waitElementIsVisible({
-      element: headerFilterIcon,
-      driver: this.driver,
-      errorMessage: `HeaderFilter "${this._name}" is not visible`
-    });
+    const elements = await columnEl.findElements(By9.css(HEADER_FILTER_ICON));
+    let headerFilterIcon = null;
+    await wait(
+      async () => {
+        let result = false;
+        for (let element of elements) {
+          if (await element.isDisplayed()) {
+            headerFilterIcon = element;
+            result = true;
+            break;
+          }
+        }
+        return result;
+      },
+      this.driver,
+      `HeaderFilter "${this._name}" is not visible`
+    );
     if (!headerFilterIcon)
       throw new Error(`HeaderFilter "${this._name}" is not visible`);
     await headerFilterIcon.click();
-    return new HeaderFilterField("", this._formName, this._name, this.driver);
+    const filter = new HeaderFilterField("", this._formName, this._name, this.driver);
+    const filterEl = await filter.getElement();
+    await waitElementIsVisible({
+      element: filterEl,
+      driver: this.driver,
+      errorMessage: `Header filter is not visible`
+    });
+    return filter;
   }
   /**
    * Возвращает значение в поле
@@ -686,9 +927,22 @@ var ColumnFilter = class extends AbstractElement {
    * @example
    * await form.columnFilter('NumberFld').setValue(123);
    * await form.columnFilter('TextFld').setValue('TestValue');
+   * await form.columnFilter('TextFld').setValue('TestValue', '=', true);
    */
-  async setValue(value) {
+  async setValue(value, operation, isBlank) {
     const filter = await this.initFilter();
+    const inputEl = await filter.getElement();
+    await inputEl.click();
+    const filterOperation = new FilterOperation({
+      parentCssSelector: HEADER_FILTER_CONTAINER,
+      filterTestID: createHeaderFilterTestId(this._formName, this._name)
+    });
+    if (typeof operation === "string") {
+      await filterOperation.setOperation(operation);
+    }
+    if (typeof isBlank === "boolean") {
+      await filterOperation.setIsBlank(isBlank);
+    }
     await filter.setValue(value);
     return this.apply();
   }
@@ -712,16 +966,72 @@ var ColumnFilter = class extends AbstractElement {
     await filter.remove(itemText);
     return this.apply();
   }
+  /**
+   * Инициализация операции фильтра
+   */
+  async initOperation() {
+    const filter = await this.initFilter();
+    const inputEl = await filter.getElement();
+    await inputEl.click();
+    return new FilterOperation({
+      parentCssSelector: HEADER_FILTER_CONTAINER,
+      filterTestID: createHeaderFilterTestId(this._formName, this._name)
+    });
+  }
+  /**
+   * Устанавливает операцию для фильтра
+   * @example
+   * await form.columnFilter('TagBox').setOperation("=");
+   */
+  async setOperation(operationName) {
+    const filterOperation = await this.initOperation();
+    await filterOperation.setOperation(operationName);
+    await this.apply();
+  }
+  /**
+   * Возвращает операцию фильтра
+   * @example
+   * expect(await form.columnFilter('NumberFld').getOperation()).toBe("=");
+   */
+  async getOperation() {
+    const filterOperation = await this.initOperation();
+    return await filterOperation.getOperation();
+  }
+  /**
+   * Устанавливает операцию 'isblank' для фильтра
+   * @example
+   * await form.columnFilter('TagBox').setIsBlank(true);
+   */
+  async setIsBlank(value) {
+    const filterOperation = await this.initOperation();
+    await filterOperation.setIsBlank(value);
+    await this.apply();
+  }
+  /**
+   * Возвращает true|false, если операция 'isblank' установлена для фильтра
+   * @example
+   * expect(await form.columnFilter('NumberFld').getIsBlank()).toBe(false);
+   */
+  async getIsBlank() {
+    const filterOperation = await this.initOperation();
+    return await filterOperation.getIsBlank();
+  }
 };
 
 // src/pageObjects/elements/Forms/ListForm.ts
 var DATAGRID_HEADER_CSS_SELECTOR = ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
+var DATAGRID_CONTENT_CSS_SELECTOR = ".dx-datagrid-content:not(.dx-datagrid-content-fixed)";
+var FIXED_DATAGRID_CONTENT_CSS_SELECTOR = ".dx-fixed-columns .dx-datagrid-content.dx-datagrid-content-fixed";
 var ListForm = class extends Form {
   headerCssSelector;
+  fixedTableContentCssSelector;
+  tableContentCssSelector;
   constructor(driver) {
     super(driver);
-    this.popupContainerCssSelector = `.popup .form-inline-${this.formName}`;
+    this.popupContainerCssSelector = `.popup.form-inline-${this.formName}`;
     this.headerCssSelector = DATAGRID_HEADER_CSS_SELECTOR;
+    this.fixedTableContentCssSelector = FIXED_DATAGRID_CONTENT_CSS_SELECTOR;
+    this.tableContentCssSelector = DATAGRID_CONTENT_CSS_SELECTOR;
   }
   /**
    * Находит таблицу
@@ -731,7 +1041,14 @@ var ListForm = class extends Form {
    * expect(listForm.table());
    */
   table() {
-    return new Table(this.containerCssSelector, this.headerCssSelector, this.formName, this.driver);
+    return new Table(
+      this.containerCssSelector,
+      this.headerCssSelector,
+      this.tableContentCssSelector,
+      this.fixedTableContentCssSelector,
+      this.formName,
+      this.driver
+    );
   }
   /**
    * Находит таблицу