d5-testing-library 1.5.0 → 1.7.0-alpha.0

package/dist/FormEdit-2OXEIJRD.mjs

@@ -0,0 +1,7 @@
+import {
+  FormEdit
+} from "./chunk-H6LCUGIP.mjs";
+import "./chunk-ISIVPVER.mjs";
+export {
+  FormEdit as default
+};

package/dist/ListForm-NWULJ2P6.mjs

@@ -0,0 +1,7 @@
+import {
+  ListForm
+} from "./chunk-PVVYHCDQ.mjs";
+import "./chunk-ISIVPVER.mjs";
+export {
+  ListForm as default
+};

package/dist/TreeView-USLYNLBL.mjs

@@ -0,0 +1,8 @@
+import {
+  TreeView
+} from "./chunk-M7ZEJQ34.mjs";
+import "./chunk-PVVYHCDQ.mjs";
+import "./chunk-ISIVPVER.mjs";
+export {
+  TreeView as default
+};

package/dist/{chunk-FP26UOTI.mjs → chunk-H6LCUGIP.mjs}

@@ -3,7 +3,7 @@ import {
   FormField,
   click,
   wait
-} from "./chunk-VWNH6HVN.mjs";
+} from "./chunk-ISIVPVER.mjs";
 
 // src/pageObjects/elements/Forms/FormEdit.ts
 import { By } from "selenium-webdriver";

package/dist/{chunk-VWNH6HVN.mjs → chunk-ISIVPVER.mjs}

@@ -420,8 +420,7 @@ var TagBox = class extends AbstractDXEditorWithInput {
     await this.confirmSelection();
   }
   async waitOptionSelection() {
-    const option = await this.driver.findElement(By6.css(TAG_BOX_LIST_ITEM_SELECTOR));
-    await wait(() => option.isDisplayed(), this.driver);
+    await fixElementStaleError(By6.css(TAG_BOX_LIST_ITEM_SELECTOR), this.driver);
   }
   async selectOption(inputEl, value, lastElement) {
     try {
@@ -436,7 +435,7 @@ var TagBox = class extends AbstractDXEditorWithInput {
     }
   }
   async confirmSelection() {
-    const btnOk = await this.driver.findElement(By6.css(BTN_OK_SELECTOR));
+    const btnOk = await fixElementStaleError(By6.css(BTN_OK_SELECTOR), this.driver);
     await click(btnOk, this.driver);
   }
   async getTagBoxInputValue() {
@@ -722,6 +721,9 @@ function createFilterTestId(formName, itemName, layout) {
 function createDocFilterTestId(formName, itemName) {
   return createFilterTestId(formName, itemName, "dock-panel-filter" /* DOCK_PANEL */);
 }
+function createHeaderFilterTestId(formName, itemName) {
+  return createFilterTestId(formName, itemName, "header-filter" /* HEADER_FILTER */);
+}
 function createLayoutFilterTestId(formName, itemName) {
   return createFilterTestId(formName, itemName, "layout-filter" /* LAYOUT */);
 }
@@ -731,6 +733,9 @@ function createTableId(formName) {
 function createFormButtonTestId(formName, itemName) {
   return createDataTestId(formName, "button" /* BUTTON */, itemName);
 }
+function createSubSystemTestId(itemName) {
+  return `${"subsystem-item" /* SUBSYSTEM_ITEM */}-${itemName}`;
+}
 
 // src/pageObjects/elements/AbstractEditor.ts
 var AbstractEditor = class extends AbstractElementWithParent {
@@ -807,7 +812,7 @@ var FormField = class extends AbstractEditor {
 };
 
 // src/pageObjects/elements/Forms/Form.ts
-import { By as By13 } from "selenium-webdriver";
+import { By as By14 } from "selenium-webdriver";
 
 // src/utils/waitElementIsClickable.ts
 async function waitElementIsClickable({
@@ -881,19 +886,79 @@ var AbstractGroup = class extends AbstractElementWithParent {
 var Panel = class extends AbstractGroup {
 };
 
-// src/pageObjects/elements/Groups/TabPanel/TabPanel.ts
+// src/pageObjects/elements/Groups/TabPanel.ts
 import { By as By12 } from "selenium-webdriver";
-var getTabTestIdByName = (name) => `tab-caption-${name}`;
+var TabPanelItem = class extends AbstractGroup {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+  }
+  async click() {
+    await click(await this.getElement(), this.driver);
+  }
+  async isActive() {
+    const tabPanelItemElement = await this.getElement();
+    const grandparentTab = await tabPanelItemElement.findElement(By12.xpath('ancestor::div[@role="tab"][1]'));
+    return await grandparentTab.getAttribute("aria-selected") === "true";
+  }
+  async getTitle() {
+    return "";
+  }
+};
 var TabPanel = class extends AbstractGroup {
+  item(name) {
+    return new TabPanelItem(this.getFullCssSelector(), `.tab-panel-item[data-groupname="${name}"]`, this.driver);
+  }
+  async getTitle() {
+    return "";
+  }
+};
+
+// src/pageObjects/elements/Groups/Accordion/AccordionItem.ts
+import { By as By13 } from "selenium-webdriver";
+var ACCORDION_TITLE_CONTAINER = "accordion-title-container";
+var AccordionItem = class extends AbstractGroup {
   constructor(parentCssSelector, elementCssSelector, driver) {
     super(parentCssSelector, elementCssSelector, driver);
   }
-  _getTab(name) {
-    return this.driver.findElement(By12.css(`${this.getFullCssSelector()} ${byTestIdCssSelector(getTabTestIdByName(name))}`));
+  async getDataOpenedAccordItemAttr() {
+    const accordionElement = await this.getElement();
+    return await accordionElement.getAttribute("data-opened");
+  }
+  async clickAccordionItemTitle() {
+    const accordionElement = await this.getElement();
+    const accordTitleElement = await accordionElement.findElement(By13.className(ACCORDION_TITLE_CONTAINER));
+    await accordTitleElement.click();
+  }
+  async click() {
+    await click(await this.getElement(), this.driver);
+  }
+  async isExpanded() {
+    const dataOpened = await this.getDataOpenedAccordItemAttr();
+    return dataOpened === "true";
+  }
+  async isCollapsed() {
+    const dataOpened = await this.getDataOpenedAccordItemAttr();
+    return dataOpened === "false" || !dataOpened;
+  }
+  async expand() {
+    if (!await this.isExpanded()) {
+      await this.clickAccordionItemTitle();
+    }
   }
-  async tabClick(name) {
-    const tabEl = this._getTab(name);
-    await tabEl.click();
+  async collapse() {
+    if (await this.isExpanded()) {
+      await this.clickAccordionItemTitle();
+    }
+  }
+};
+
+// src/pageObjects/elements/Groups/Accordion/Accordion.ts
+var Accordion = class extends AbstractGroup {
+  constructor(parentCssSelector, elementCssSelector, driver) {
+    super(parentCssSelector, elementCssSelector, driver);
+  }
+  item(name) {
+    return new AccordionItem(this.getFullCssSelector(), `.d5-accordion-item[data-groupname="${name}"]`, this.driver);
   }
 };
 
@@ -903,20 +968,26 @@ var groupFactory = async (parentCssSelector, elementCssSelector, driver) => {
   const classSting = await elementInstance.getClasses();
   if (classSting.includes("tab-panel-group"))
     return new TabPanel(parentCssSelector, elementCssSelector, driver);
+  if (classSting.includes("tab-panel-item"))
+    return new TabPanelItem(parentCssSelector, elementCssSelector, driver);
   if (classSting.includes("panel-group"))
     return new Panel(parentCssSelector, elementCssSelector, driver);
+  if (classSting.includes("accordion-group"))
+    return new Accordion(parentCssSelector, elementCssSelector, driver);
+  if (classSting.includes("d5-accordion-item"))
+    return new AccordionItem(parentCssSelector, elementCssSelector, 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;
+  groupInstance;
   constructor(parentCssSelector, formName, name, driver) {
     super(parentCssSelector, byTestIdCssSelector(createGroupTestId(formName, name)), driver);
   }
-  async initEditor() {
-    if (!this.editor) {
-      this.editor = await groupFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
+  async initInstance() {
+    if (!this.groupInstance) {
+      this.groupInstance = await groupFactory(this.parentCssSelector, this.elementCssSelector, this.driver);
     }
   }
   /**
@@ -926,20 +997,66 @@ var FormGroup = class extends AbstractElementWithParent {
    */
   async isDisplayed() {
     try {
-      await this.initEditor();
-      return this.editor.isDisplayed();
+      await this.initInstance();
+      return this.groupInstance.isDisplayed();
     } catch {
       return false;
     }
   }
   /**
-   * Происходит клик по табе
+   * Клик по элементам группы.
+   * Метод работает если у группы есть дочерние элементы, например элементы аккордеона или вкладки таб панели.
    * @example
-   * expect(await tableList.group('TabPanel').tabClick(tabName);
+   * expect(await tableList.group('TabPanel').itemClick('Tab');
+   * expect(await tableList.group('Accordion').itemClick('AccordionItem');
    */
-  async tabClick(name) {
-    await this.initEditor();
-    await this.editor.tabClick(name);
+  async itemClick(name) {
+    await this.initInstance();
+    const item = this.groupInstance.item?.(name);
+    await item?.click();
+  }
+  /**
+   * Метод работает если группа - это элемент аккордеона или вкладка таб панели
+   * @example
+   * expect(await tableList.group('Tab').click();
+   * expect(await tableList.group('AccordionItem').click();
+   */
+  async click() {
+    await this.initInstance();
+    await this.groupInstance.click?.();
+  }
+  async collapse() {
+    await this.initInstance();
+    if (this.groupInstance instanceof AccordionItem) {
+      await this.groupInstance.collapse();
+    }
+  }
+  async expand() {
+    await this.initInstance();
+    if (this.groupInstance instanceof AccordionItem) {
+      await this.groupInstance.expand();
+    }
+  }
+  async isExpanded() {
+    await this.initInstance();
+    if (this.groupInstance instanceof AccordionItem) {
+      return await this.groupInstance.isExpanded();
+    }
+    return false;
+  }
+  async isCollapsed() {
+    await this.initInstance();
+    if (this.groupInstance instanceof AccordionItem) {
+      return await this.groupInstance.isCollapsed();
+    }
+    return false;
+  }
+  async isActive() {
+    await this.initInstance();
+    if (this.groupInstance instanceof TabPanelItem) {
+      return await this.groupInstance.isActive();
+    }
+    return false;
   }
 };
 
@@ -997,15 +1114,15 @@ async function classDependencyInjector(formType) {
   let SubFormFactoryClass;
   switch (formType) {
     case "1" /* LIST */:
-      SubFormFactoryClass = (await import("./ListForm-HDVXB6CG.mjs")).default;
+      SubFormFactoryClass = (await import("./ListForm-NWULJ2P6.mjs")).default;
       break;
     case "3" /* TREE */:
-      SubFormFactoryClass = (await import("./TreeView-DE5RBMDD.mjs")).default;
+      SubFormFactoryClass = (await import("./TreeView-USLYNLBL.mjs")).default;
       break;
     case "2" /* EDIT */:
     case "99" /* FREE_FORM */:
     case "4" /* REPORT */:
-      SubFormFactoryClass = (await import("./FormEdit-MZJH5R5H.mjs")).default;
+      SubFormFactoryClass = (await import("./FormEdit-2OXEIJRD.mjs")).default;
       break;
     default:
       throw new Error(`Unsupported form type ${formType}`);
@@ -1035,10 +1152,10 @@ var Form = class extends AbstractForm {
    */
   async getTitleText() {
     if (await this.isModal()) {
-      const titleEl2 = await this.driver.findElement(By13.css(`${this.popupContainerCssSelector} .popup-title`));
+      const titleEl2 = await this.driver.findElement(By14.css(`${this.popupContainerCssSelector} .popup-title`));
       return titleEl2.getText();
     }
-    let titleEl = await this.driver.findElement(By13.className("main-toolbar-form-title"));
+    let titleEl = await this.driver.findElement(By14.className("main-toolbar-form-title"));
     return titleEl.getText();
   }
   setSubFormMode() {
@@ -1056,7 +1173,7 @@ var Form = class extends AbstractForm {
    */
   async subForm(name) {
     const cssSelector = subformCssSelector(this.containerCssSelector, subFormTestId(name));
-    const byCssSelector = By13.css(cssSelector);
+    const byCssSelector = By14.css(cssSelector);
     const subFormEl = await this.driver.findElement(byCssSelector);
     await waitElementIsVisible({
       element: subFormEl,
@@ -1091,15 +1208,18 @@ export {
   byTestId,
   readonlyLocator,
   AbstractElementWithParent,
+  TextEditor,
+  NumberEditor,
+  ControlClass,
+  DX_CLEAR_BUTTON_AREA,
+  editorFactory,
   createDocFilterTestId,
+  createHeaderFilterTestId,
   createLayoutFilterTestId,
   createTableId,
+  createSubSystemTestId,
   waitElementIsClickable,
   AbstractButton,
-  TextEditor,
-  NumberEditor,
-  ControlClass,
-  editorFactory,
   AbstractEditor,
   FormField,
   Form

package/dist/{chunk-44JIUIEW.mjs → chunk-M7ZEJQ34.mjs}

@@ -1,6 +1,6 @@
 import {
   ListForm
-} from "./chunk-NWWYF43G.mjs";
+} from "./chunk-PVVYHCDQ.mjs";
 
 // src/pageObjects/elements/Forms/TreeView.ts
 var TREELIST_HEADER_CSS_SELECTOR = ".dx-treelist-headers .dx-treelist-content:not(.dx-datagrid-content-fixed)";

package/dist/{chunk-NWWYF43G.mjs → chunk-PVVYHCDQ.mjs}

@@ -9,12 +9,14 @@ import {
   byTestIdCssSelector,
   click,
   createDocFilterTestId,
+  createHeaderFilterTestId,
   createLayoutFilterTestId,
   createTableId,
   fixElementStaleError,
   wait,
-  waitElementIsClickable
-} from "./chunk-VWNH6HVN.mjs";
+  waitElementIsClickable,
+  waitElementIsVisible
+} from "./chunk-ISIVPVER.mjs";
 
 // src/pageObjects/elements/Table/Table.ts
 import { By as By5 } from "selenium-webdriver";
@@ -595,6 +597,122 @@ var FilterPanel = class extends AbstractElement {
   }
 };
 
+// src/pageObjects/elements/Filters/ColumnFilter.ts
+import { By as By8 } from "selenium-webdriver";
+
+// src/pageObjects/elements/Filters/HeaderFilterField.ts
+var HeaderFilterField = class extends AbstractEditor {
+  constructor(parentCssSelector, formName, name, driver) {
+    super(parentCssSelector, byTestIdCssSelector(createHeaderFilterTestId(formName, name)), driver);
+  }
+  async getValue() {
+    return super.getValue();
+  }
+  async setValue(value) {
+    return super.setValue(value);
+  }
+  async clear() {
+    return super.clear();
+  }
+  async remove(itemText) {
+    return super.remove(itemText);
+  }
+};
+
+// src/pageObjects/elements/Filters/ColumnFilter.ts
+var APPLY_SELECTOR = ".apply-button";
+var CANCEL_SELECTOR = ".cancel-button";
+var HEADER_FILTER_ICON = ".dx-column-indicators .dx-header-filter";
+var HEADER_FILTER_CONTAINER = ".header-filter";
+var HEADER_FILTER_BUTTONS = ".header-filter-buttons";
+var ColumnFilter = class extends AbstractElement {
+  _formName;
+  _name;
+  _column;
+  constructor(formName, name, column, driver) {
+    super(driver, HEADER_FILTER_CONTAINER);
+    this._formName = formName;
+    this._name = name;
+    this._column = column;
+    this.driver = driver;
+  }
+  async getApplyButton() {
+    const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${APPLY_SELECTOR}`;
+    return this.driver.findElement(By8.css(selector));
+  }
+  async getCancelButton() {
+    const selector = `${HEADER_FILTER_CONTAINER} ${HEADER_FILTER_BUTTONS} ${CANCEL_SELECTOR}`;
+    return this.driver.findElement(By8.css(selector));
+  }
+  async apply() {
+    const btn = await this.getApplyButton();
+    await click(btn, this.driver);
+  }
+  async cancel() {
+    const btn = await this.getCancelButton();
+    await click(btn, this.driver);
+  }
+  async initFilter() {
+    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`
+    });
+    if (!headerFilterIcon)
+      throw new Error(`HeaderFilter "${this._name}" is not visible`);
+    await headerFilterIcon.click();
+    return new HeaderFilterField("", this._formName, this._name, this.driver);
+  }
+  /**
+   * Возвращает значение в поле
+   * @example
+   * expect(await form.columnFilter('NumberFld').getValue()).toBe(10);
+   * expect(await form.columnFilter('TextFld').getValue()).toBe('TestValue');
+   */
+  async getValue() {
+    const filter = await this.initFilter();
+    const result = await filter.getValue();
+    await this.cancel();
+    return result;
+  }
+  /**
+   * Устанавливает значение в поле
+   * @example
+   * await form.columnFilter('NumberFld').setValue(123);
+   * await form.columnFilter('TextFld').setValue('TestValue');
+   */
+  async setValue(value) {
+    const filter = await this.initFilter();
+    await filter.setValue(value);
+    return this.apply();
+  }
+  /**
+   * Очищает значение в поле
+   * @example
+   * await form.columnFilter('NumberFld').clear();
+   */
+  async clear() {
+    const filter = await this.initFilter();
+    await filter.clear();
+    return this.apply();
+  }
+  /**
+   * Удаляет тег по переданному тексту
+   * @example
+   * await form.columnFilter('TagBox').remove('test');
+   */
+  async remove(itemText) {
+    const filter = await this.initFilter();
+    await filter.remove(itemText);
+    return this.apply();
+  }
+};
+
 // src/pageObjects/elements/Forms/ListForm.ts
 var DATAGRID_HEADER_CSS_SELECTOR = ".dx-datagrid-headers .dx-datagrid-content:not(.dx-datagrid-content-fixed)";
 var ListForm = class extends Form {
@@ -635,6 +753,10 @@ var ListForm = class extends Form {
   formFilter(name) {
     return new FormFilterField(this.containerCssSelector, this.formName, name, this.driver);
   }
+  columnFilter(name) {
+    const column = this.table().getColumnByName(name);
+    return new ColumnFilter(this.formName, name, column, this.driver);
+  }
   /**
    * Модель панели фильтрации
    * @returns {FilterPanel}