@umbraco/playwright-testhelpers 2.0.0-beta.9 → 2.0.0-beta.91

package/dist/lib/helpers/UiBaseLocators.js

@@ -6,73 +6,339 @@ const ConstantHelper_1 = require("./ConstantHelper");
 class UiBaseLocators {
     page;
     saveBtn;
+    chooseBtn;
     submitBtn;
     createFolderBtn;
     breadcrumbBtn;
     deleteBtn;
     confirmToDeleteBtn;
-    deleteFolderBtn;
+    deleteLabelBtn;
+    deleteExactLabelBtn;
+    deleteExactBtn;
     confirmCreateFolderBtn;
     insertBtn;
-    dictionaryInsertItemBtn;
-    caretDictionaryBtn;
-    insertValueBtn;
     modalCaretBtn;
     queryBuilderBtn;
     queryBuilderOrderedBy;
     queryBuilderCreateDate;
     folderNameTxt;
     textAreaInputArea;
+    wherePropertyAliasBtn;
+    whereOperatorBtn;
+    whereConstrainValueTxt;
+    orderByPropertyAliasBtn;
+    ascendingBtn;
+    queryBuilderShowCode;
+    createThreeDotsBtn;
+    newFolderThreeDotsBtn;
+    renameThreeDotsBtn;
+    newNameTxt;
+    renameModalBtn;
+    createBtn;
+    successState;
+    chooseModalBtn;
+    addBtn;
+    renameFolderThreeDotsBtn;
+    renameFolderBtn;
+    updateFolderBtn;
+    filterChooseBtn;
+    updateBtn;
+    changeBtn;
+    propertyNameTxt;
+    selectPropertyEditorBtn;
+    addGroupBtn;
+    iAmDoneReorderingBtn;
+    reorderBtn;
+    compositionsBtn;
+    addTabBtn;
+    descriptionBtn;
+    enterDescriptionTxt;
+    mandatorySlider;
+    validation;
+    regexTxt;
+    regexMessageTxt;
+    structureTabBtn;
+    allowAtRootBtn;
+    addPropertyBtn;
+    typeToFilterSearchTxt;
+    editorSettingsBtn;
+    labelAboveBtn;
+    unnamedTxt;
+    deleteThreeDotsBtn;
+    removeExactBtn;
+    confirmBtn;
+    disableBtn;
+    confirmDisableBtn;
+    enableBtn;
+    confirmEnableBtn;
+    iconBtn;
+    aliasLockBtn;
+    aliasNameTxt;
+    deleteFolderThreeDotsBtn;
+    createLink;
+    insertValueBtn;
+    insertPartialViewBtn;
+    insertDictionaryItemBtn;
+    chooseFieldDropDown;
+    systemFieldsOption;
+    chooseFieldValueDropDown;
+    renameBtn;
+    deleteFolderBtn;
+    returnedItemsCount;
+    chooseRootContentBtn;
+    queryResults;
+    reloadBtn;
+    confirmToRemoveBtn;
+    confirmToSubmitBtn;
+    typeGroups;
+    allowedChildNodesModal;
+    configureAsACollectionBtn;
+    errorNotification;
+    confirmRenameFolderBtn;
+    successNotification;
+    leftArrowBtn;
+    clickToUploadBtn;
+    backOfficeHeader;
+    failedStateButton;
+    sidebarModal;
+    enterAName;
+    mediaCardItems;
+    enterPropertyEditorDescriptionTxt;
+    breadcrumbsTemplateModal;
+    containerChooseBtn;
+    documentTypeNode;
+    groupLabel;
+    containerSaveAndPublishBtn;
+    confirmTrashBtn;
+    recycleBinBtn;
+    recycleBinMenuItemCaretBtn;
+    recycleBinMenuItem;
+    gridBtn;
+    listBtn;
+    viewBundleBtn;
     constructor(page) {
         this.page = page;
-        this.saveBtn = page.getByLabel('Save');
+        this.saveBtn = page.getByLabel('Save', { exact: true });
         this.submitBtn = page.getByLabel('Submit');
-        this.deleteFolderBtn = page.getByLabel('Delete');
+        this.deleteExactLabelBtn = page.getByLabel('Delete', { exact: true });
+        this.deleteExactBtn = page.getByRole('button', { name: 'Delete', exact: true });
+        this.deleteLabelBtn = page.getByLabel('Delete');
         this.deleteBtn = page.getByRole('button', { name: 'Delete' });
         this.confirmToDeleteBtn = page.locator('#confirm').getByLabel('Delete');
-        this.confirmCreateFolderBtn = page.locator('#confirm').getByLabel('Create folder');
+        this.confirmCreateFolderBtn = page.locator('#confirm').getByLabel('Create Folder');
         this.breadcrumbBtn = page.getByLabel('Breadcrumb');
         this.createFolderBtn = page.getByLabel('Create folder');
-        this.insertBtn = page.getByLabel('Choose value to insert');
-        this.dictionaryInsertItemBtn = page.getByLabel('Insert Dictionary item');
-        this.caretDictionaryBtn = page.locator('umb-tree-picker-modal').locator('#caret-button');
-        this.insertValueBtn = page.getByLabel('Choose value to insert');
-        this.modalCaretBtn = page.locator('umb-tree-picker-modal').locator('#caret-button');
+        this.insertBtn = page.locator('uui-box uui-button').filter({ hasText: 'Insert' });
+        this.sidebarModal = page.locator('uui-modal-sidebar');
+        this.modalCaretBtn = this.sidebarModal.locator('#caret-button');
+        this.enterAName = page.getByLabel('Enter a name...', { exact: true });
         this.queryBuilderBtn = page.locator('#query-builder-button').getByLabel('Query builder');
         this.queryBuilderOrderedBy = page.locator('#property-alias-dropdown').getByLabel('Property alias');
-        this.queryBuilderCreateDate = page.locator('#property-alias-dropdown').getByText('CreateDate');
-        this.folderNameTxt = page.getByRole('textbox', { name: 'Enter folder name...' });
+        this.queryBuilderCreateDate = page.locator('#property-alias-dropdown').getByText('CreateDate').locator("..");
+        this.folderNameTxt = page.getByLabel('Enter a folder name');
         this.textAreaInputArea = page.locator('textarea.inputarea');
+        this.wherePropertyAliasBtn = page.locator('#property-alias-dropdown');
+        this.whereOperatorBtn = page.locator('#operator-dropdown');
+        this.whereConstrainValueTxt = page.getByLabel('constrain value');
+        this.orderByPropertyAliasBtn = page.locator('#sort-dropdown');
+        this.ascendingBtn = page.locator('[key="template_ascending"]');
+        this.queryBuilderShowCode = page.locator('umb-code-block');
+        this.createThreeDotsBtn = page.getByText('Create...', { exact: true });
+        this.chooseBtn = page.getByLabel('Choose', { exact: true });
+        this.containerChooseBtn = page.locator('#container').getByLabel('Choose');
+        this.containerSaveAndPublishBtn = page.locator('#container').getByLabel('Save and Publish');
+        this.newFolderThreeDotsBtn = page.getByLabel('New Folder...');
+        this.renameThreeDotsBtn = page.getByLabel('Rename...', { exact: true });
+        this.newNameTxt = page.getByRole('textbox', { name: 'Enter new name...' });
+        this.renameModalBtn = page.locator('umb-rename-modal').getByLabel('Rename');
+        this.createBtn = page.getByRole('button', { name: 'Create', exact: true });
+        this.successState = page.locator('[state="success"]');
+        this.chooseModalBtn = page.locator('umb-tree-picker-modal').getByLabel('Choose');
+        this.addBtn = page.getByLabel('Add', { exact: true });
+        this.renameFolderThreeDotsBtn = page.getByLabel('Rename folder...');
+        this.renameFolderBtn = page.getByLabel('Rename folder');
+        this.confirmRenameFolderBtn = page.locator('#confirm').getByLabel('Rename folder');
+        this.updateFolderBtn = page.getByLabel('Update folder');
+        this.filterChooseBtn = page.locator('button').filter({ hasText: 'Choose' });
+        this.updateBtn = page.getByLabel('Update');
+        this.changeBtn = page.getByLabel('Change');
+        this.propertyNameTxt = page.locator('#name-input #input');
+        this.selectPropertyEditorBtn = page.getByLabel('Select Property Editor');
+        this.addGroupBtn = page.getByLabel('Add group', { exact: true });
+        this.iAmDoneReorderingBtn = page.getByLabel('I am done reordering');
+        this.reorderBtn = page.getByLabel('Reorder');
+        this.compositionsBtn = page.getByLabel('Compositions');
+        this.addTabBtn = page.getByLabel('Add tab');
+        this.descriptionBtn = page.getByLabel('Description');
+        this.enterDescriptionTxt = page.getByLabel('Enter a description...');
+        this.mandatorySlider = page.locator('#mandatory #slider');
+        this.validation = page.locator('#native');
+        this.regexTxt = page.locator('input[name="pattern"]');
+        this.regexMessageTxt = page.locator('textarea[name="pattern-message"]');
+        this.structureTabBtn = page.locator('uui-tab').filter({ hasText: 'Structure' }).locator('svg');
+        this.allowAtRootBtn = page.locator('label').filter({ hasText: 'Allow at root' });
+        this.addPropertyBtn = page.getByLabel('Add property', { exact: true });
+        this.typeToFilterSearchTxt = page.locator('[type="search"] #input');
+        this.editorSettingsBtn = page.getByLabel('Editor settings');
+        this.labelAboveBtn = page.locator('button').filter({ hasText: 'Label above' });
+        this.unnamedTxt = page.getByRole('textbox', { name: 'Unnamed' });
+        this.deleteThreeDotsBtn = page.locator('#action-modal').getByLabel('Delete...');
+        this.removeExactBtn = page.getByLabel('Remove', { exact: true });
+        this.confirmBtn = page.getByLabel('Confirm');
+        this.disableBtn = page.getByLabel('Disable', { exact: true });
+        this.confirmDisableBtn = page.locator('#confirm').getByLabel('Disable');
+        this.confirmToSubmitBtn = page.locator('#confirm').getByLabel('Submit');
+        this.enableBtn = page.getByLabel('Enable');
+        this.confirmEnableBtn = page.locator('#confirm').getByLabel('Enable');
+        this.iconBtn = page.getByLabel('icon');
+        this.aliasLockBtn = page.locator('#name #lock');
+        this.aliasNameTxt = page.locator('#name').getByLabel('alias');
+        this.deleteFolderThreeDotsBtn = page.locator('#action-modal').getByLabel('Delete Folder...');
+        this.createLink = page.getByRole('link', { name: 'Create' });
+        this.insertValueBtn = page.locator('uui-button').filter({ has: page.locator('[key="template_insertPageField"]') });
+        this.insertPartialViewBtn = page.locator('uui-button').filter({ has: page.locator('[key="template_insertPartialView"]') });
+        this.insertDictionaryItemBtn = page.locator('uui-button').filter({ has: page.locator('[key="template_insertDictionaryItem"]') });
+        this.chooseFieldDropDown = page.locator('#preview #expand-symbol-wrapper');
+        this.systemFieldsOption = page.getByText('System fields');
+        this.chooseFieldValueDropDown = page.locator('#value #expand-symbol-wrapper');
+        this.renameBtn = page.locator('#action-modal').getByLabel('Rename');
+        this.deleteFolderBtn = page.locator('#action-modal').getByLabel('Delete folder');
+        this.returnedItemsCount = page.locator('#results-count');
+        this.chooseRootContentBtn = page.getByLabel('Choose root document');
+        this.queryResults = page.locator('query-results');
+        this.reloadBtn = page.getByRole('button', { name: 'Reload', exact: true });
+        this.confirmToRemoveBtn = page.locator('#confirm').getByLabel('Remove');
+        this.typeGroups = page.locator('umb-content-type-design-editor-group');
+        this.allowedChildNodesModal = page.locator('umb-tree-picker-modal');
+        this.configureAsACollectionBtn = page.getByLabel('Configure as a collection');
+        this.errorNotification = page.locator('uui-toast-notification[open][color="danger"]');
+        this.successNotification = page.locator('uui-toast-notification[open][color="positive"]');
+        this.leftArrowBtn = page.locator('[name="icon-arrow-left"] svg');
+        this.clickToUploadBtn = page.locator('uui-file-dropzone').filter({ hasText: 'Click to upload' });
+        this.backOfficeHeader = page.locator('umb-backoffice-header');
+        this.failedStateButton = page.locator('uui-button[state="failed"]');
+        this.mediaCardItems = page.locator('uui-card-media');
+        this.enterPropertyEditorDescriptionTxt = this.sidebarModal.getByLabel('Enter a description...');
+        this.breadcrumbsTemplateModal = this.sidebarModal.locator('umb-template-workspace-editor uui-breadcrumbs');
+        this.documentTypeNode = page.locator('uui-ref-node-document-type');
+        this.groupLabel = page.getByLabel('Group', { exact: true });
+        this.confirmTrashBtn = page.locator('#confirm').getByLabel('Trash');
+        this.recycleBinBtn = page.getByLabel('Recycle Bin', { exact: true });
+        this.recycleBinMenuItem = page.locator('uui-menu-item[label="Recycle Bin"]');
+        this.recycleBinMenuItemCaretBtn = this.recycleBinMenuItem.locator('#caret-button');
+        this.gridBtn = this.page.getByLabel('Grid');
+        this.listBtn = this.page.getByLabel('List');
+        this.viewBundleBtn = this.page.locator('umb-collection-view-bundle');
     }
     async clickActionsMenuForName(name) {
-        await this.page.locator('[label="' + name + '"] >> [label="Open actions menu"]').click({ force: true });
+        await this.page.locator('[label="' + name + '"]').click();
+        await this.page.locator('[label="' + name + '"] >> [label="Open actions menu"]').first().click();
     }
     async clickCaretButtonForName(name) {
         await this.page.locator('div').filter({ hasText: name }).locator('#caret-button').click();
     }
+    async clickCaretButton() {
+        await this.page.locator('#caret-button').click();
+    }
+    async reloadTree(treeName) {
+        // Waits until the tree item is visible
+        await (0, test_1.expect)(this.page.getByLabel(treeName, { exact: true })).toBeVisible();
+        await this.page.waitForTimeout(500);
+        await this.clickActionsMenuForName(treeName);
+        await this.clickReloadButton();
+        const menuItem = this.page.locator('uui-menu-item[label="' + treeName + '"]');
+        const isCaretButtonOpen = await menuItem.getAttribute('show-children');
+        if (isCaretButtonOpen === null) {
+            // We need to wait before clicking the caret button. Because the reload might not have happend yet. 
+            // await this.page.waitForTimeout(500);
+            await this.clickCaretButtonForName(treeName);
+        }
+    }
+    async clickReloadButton() {
+        await this.reloadBtn.click();
+    }
     async clickSaveButton() {
+        // This wait is necessary to avoid the save button is ignored
+        await this.page.waitForTimeout(500);
+        await (0, test_1.expect)(this.saveBtn).toBeVisible();
         await this.saveBtn.click();
     }
+    async clickChooseButton() {
+        await this.chooseBtn.click();
+    }
+    async clickChooseContainerButton() {
+        await this.containerChooseBtn.click();
+    }
+    async clickFilterChooseButton() {
+        await this.filterChooseBtn.click();
+    }
+    async clickRenameFolderThreeDotsButton() {
+        await this.renameFolderThreeDotsBtn.click();
+    }
+    async clickRenameFolderButton() {
+        await this.renameFolderBtn.click();
+    }
+    async clickConfirmRenameFolderButton() {
+        await this.confirmRenameFolderBtn.click();
+    }
+    async clickUpdateFolderButton() {
+        await this.updateFolderBtn.click();
+    }
+    async clickUpdateButton() {
+        await this.updateBtn.click();
+    }
     async clickSubmitButton() {
+        await (0, test_1.expect)(this.submitBtn).toBeVisible();
         await this.submitBtn.click();
     }
+    async clickConfirmToSubmitButton() {
+        await this.confirmToSubmitBtn.click();
+    }
+    async clickChangeButton() {
+        await this.changeBtn.click();
+    }
+    async clickExactLinkWithName(name) {
+        await this.page.getByRole('link', { name: name, exact: true }).click();
+    }
+    async enterAliasName(aliasName) {
+        // Unlocks alias
+        await this.aliasLockBtn.click();
+        await this.aliasNameTxt.clear();
+        await this.aliasNameTxt.fill(aliasName);
+    }
+    async updateIcon(iconName) {
+        await this.iconBtn.click({ force: true });
+        await this.searchForTypeToFilterValue(iconName);
+        await this.clickLabelWithName(iconName, true, true);
+        await this.clickSubmitButton();
+    }
+    async clickTextButtonWithName(name) {
+        await (0, test_1.expect)(this.page.getByText(name, { exact: true })).toBeVisible();
+        await this.page.getByText(name, { exact: true }).click();
+    }
+    async clickSelectPropertyEditorButton() {
+        await (0, test_1.expect)(this.selectPropertyEditorBtn).toBeVisible();
+        await this.selectPropertyEditorBtn.click();
+    }
     async clickCreateFolderButton() {
         await this.createFolderBtn.click();
     }
+    async enterAPropertyName(name) {
+        await (0, test_1.expect)(this.propertyNameTxt).toBeVisible();
+        await this.propertyNameTxt.fill(name);
+    }
+    async clickConfirmButton() {
+        await this.confirmBtn.click();
+    }
     async clickBreadcrumbButton() {
         await this.breadcrumbBtn.click();
     }
     async clickInsertButton() {
+        await (0, test_1.expect)(this.insertBtn).toBeVisible();
         await this.insertBtn.click();
     }
-    async clickDictionaryInsertItemButton() {
-        await this.dictionaryInsertItemBtn.click({ force: true });
-    }
-    async clickCaretDictionaryButton() {
-        await this.caretDictionaryBtn.click();
-    }
     async clickDeleteButton() {
-        await this.deleteBtn.click();
+        await this.deleteBtn.click({ force: true });
     }
     async clickConfirmToDeleteButton() {
         await this.confirmToDeleteBtn.click();
@@ -83,34 +349,446 @@ class UiBaseLocators {
     async clickConfirmCreateFolderButton() {
         await this.confirmCreateFolderBtn.click();
     }
-    async insertDictionaryByName(dictionaryName) {
-        await this.insertValueBtn.click();
-        await this.clickDictionaryInsertItemButton();
-        await this.page.waitForTimeout(1000);
-        await this.modalCaretBtn.click({ force: true });
+    async clickDeleteThreeDotsButton() {
+        await this.deleteThreeDotsBtn.click();
+    }
+    async clickRemoveExactButton() {
+        await this.removeExactBtn.click();
+    }
+    async clickRemoveButtonForName(name) {
+        await this.page.locator('[name="' + name + '"] [Label="Remove"]').click();
+    }
+    async clickTrashIconButtonForName(name) {
+        await this.page.locator('[name="' + name + '"] [name="icon-trash"]').click();
+    }
+    async clickRemoveWithName(name) {
+        await this.page.getByLabel('Remove ' + name).click();
+    }
+    async clickDisableButton() {
+        await this.disableBtn.click();
+    }
+    async clickConfirmDisableButton() {
+        await this.confirmDisableBtn.click();
+    }
+    async clickConfirmRemoveButton() {
+        await this.confirmToRemoveBtn.click();
+    }
+    async clickEnableButton() {
+        await this.enableBtn.click();
+    }
+    async clickConfirmEnableButton() {
+        await this.confirmEnableBtn.click();
+    }
+    async insertDictionaryItem(dictionaryName) {
+        await this.clickInsertButton();
+        await (0, test_1.expect)(this.insertDictionaryItemBtn).toBeVisible();
+        await this.insertDictionaryItemBtn.click();
+        await (0, test_1.expect)(this.page.getByLabel(dictionaryName)).toBeVisible();
         await this.page.getByLabel(dictionaryName).click();
-        await this.submitBtn.click();
+        await this.chooseBtn.click();
+    }
+    async addQueryBuilderWithOrderByStatement(propertyAlias, isAscending) {
+        await (0, test_1.expect)(this.queryBuilderBtn).toBeVisible({ timeout: 10000 });
+        await this.queryBuilderBtn.click();
+        await (0, test_1.expect)(this.orderByPropertyAliasBtn).toBeVisible();
+        await this.orderByPropertyAliasBtn.click();
+        // Wait and choose property alias option 
+        await this.waitAndSelectQueryBuilderDropDownList(propertyAlias);
+        // Click to acending button if isAcsending is false
+        if (!isAscending) {
+            await this.ascendingBtn.click();
+        }
     }
-    async addQueryBuilderWithCreateDateOption() {
+    async addQueryBuilderWithWhereStatement(propertyAlias, operator, constrainValue) {
+        await (0, test_1.expect)(this.queryBuilderBtn).toBeVisible({ timeout: 10000 });
         await this.queryBuilderBtn.click({ force: true });
-        await this.page.waitForTimeout(1000);
-        await this.queryBuilderOrderedBy.click({ force: true });
-        await this.page.waitForTimeout(1000);
-        await this.queryBuilderCreateDate.click({ force: true });
-        await this.submitBtn.click({ force: true });
+        // Wait and choose property alias
+        await (0, test_1.expect)(this.wherePropertyAliasBtn).toBeVisible();
+        await this.wherePropertyAliasBtn.click();
+        await this.waitAndSelectQueryBuilderDropDownList(propertyAlias);
+        // Wait and choose operator
+        await (0, test_1.expect)(this.whereOperatorBtn).toBeVisible();
+        await this.whereOperatorBtn.click();
+        await this.waitAndSelectQueryBuilderDropDownList(operator);
+        // Wait and choose constrain value and press Enter
+        await (0, test_1.expect)(this.whereConstrainValueTxt).toBeVisible();
+        await this.whereConstrainValueTxt.clear();
+        await this.whereConstrainValueTxt.fill(constrainValue);
+        await this.whereConstrainValueTxt.press('Enter');
+    }
+    async waitAndSelectQueryBuilderDropDownList(option) {
+        const ddlOption = this.page.locator('[open]').locator('uui-combobox-list-option').filter({ hasText: option }).first();
+        await (0, test_1.expect)(ddlOption).toBeVisible({ timeout: 10000 });
+        await ddlOption.click();
+    }
+    async createFolder(folderName) {
+        await this.clickCreateButton();
+        await this.clickNewFolderThreeDotsButton();
+        await this.enterFolderName(folderName);
+        await this.clickConfirmCreateFolderButton();
+    }
+    async deletePropertyEditor(propertyEditorName) {
+        // We need to hover over the property to be able to see the delete button
+        await this.page.locator('uui-button').filter({ hasText: propertyEditorName }).getByLabel('Editor settings').hover();
+        await this.deleteLabelBtn.click();
+    }
+    async enterFolderName(folderName) {
+        await this.folderNameTxt.clear();
+        await this.folderNameTxt.fill(folderName);
+    }
+    async isTextWithExactNameVisible(name, isVisible = true) {
+        return (0, test_1.expect)(this.page.getByText(name, { exact: true })).toBeVisible({ visible: isVisible });
+    }
+    async isQueryBuilderCodeShown(code) {
+        await (0, test_1.expect)(this.queryBuilderShowCode).toBeVisible();
+        await this.queryBuilderShowCode.click();
+        await (0, test_1.expect)(this.queryBuilderShowCode).toContainText(code, { timeout: 10000 });
     }
     async deleteFolder() {
         await this.clickDeleteFolderButton();
         await this.clickConfirmToDeleteButton();
     }
-    async isTreeItemVisible(name) {
-        await (0, test_1.expect)(this.page.locator('umb-tree-item').locator('[label="' + name + '"] ')).toBeVisible();
+    async clickDeleteExactLabel() {
+        await this.deleteExactLabelBtn.click();
+    }
+    async clickDeleteExactButton() {
+        await this.deleteExactBtn.click();
     }
-    async goToSection(sectionName) {
-        for (let section in ConstantHelper_1.ConstantHelper.sections) {
-            await (0, test_1.expect)(this.page.getByRole('tab', { name: section })).toBeVisible();
+    async isTreeItemVisible(name, isVisible = true) {
+        await (0, test_1.expect)(this.page.locator('umb-tree-item').locator('[label="' + name + '"]')).toBeVisible({ visible: isVisible });
+    }
+    async doesTreeItemHaveTheCorrectIcon(name, icon) {
+        return await (0, test_1.expect)(this.page.locator('umb-tree-item').filter({ hasText: name }).locator('umb-icon').locator('[name="' + icon + '"]')).toBeVisible();
+    }
+    async goToSection(sectionName, checkSections = true) {
+        if (checkSections) {
+            for (let section in ConstantHelper_1.ConstantHelper.sections) {
+                await (0, test_1.expect)(this.backOfficeHeader.getByRole('tab', { name: ConstantHelper_1.ConstantHelper.sections[section] })).toBeVisible({ timeout: 30000 });
+            }
         }
-        await this.page.getByRole('tab', { name: sectionName }).click();
+        await this.backOfficeHeader.getByRole('tab', { name: sectionName }).click();
+    }
+    async goToSettingsTreeItem(settingsTreeItemName) {
+        await this.goToSection(ConstantHelper_1.ConstantHelper.sections.settings);
+        await this.page.getByLabel(settingsTreeItemName, { exact: true }).click();
+    }
+    async clickDataElement(elementName, options = null) {
+        await this.page.click(`[data-element="${elementName}"]`, options);
+    }
+    async getDataElement(elementName) {
+        return this.page.locator(`[data-element="${elementName}"]`);
+    }
+    async isButtonWithNameVisible(name) {
+        await (0, test_1.expect)(this.page.getByRole('button', { name: name })).toBeVisible();
+    }
+    async clickLabelWithName(name, isExact = true, toForce = false) {
+        await (0, test_1.expect)(this.page.getByLabel(name, { exact: isExact })).toBeVisible();
+        await this.page.getByLabel(name, { exact: isExact }).click({ force: toForce });
+    }
+    async clickButtonWithName(name, isExact = false) {
+        await this.page.getByRole('button', { name: name, exact: isExact }).click();
+    }
+    async isSuccessNotificationVisible(isVisible = true) {
+        return await (0, test_1.expect)(this.successNotification.first()).toBeVisible({ visible: isVisible });
+    }
+    async doesSuccessNotificationsHaveCount(count) {
+        return await (0, test_1.expect)(this.successNotification).toHaveCount(count);
+    }
+    async isErrorNotificationVisible(isVisible = true) {
+        return await (0, test_1.expect)(this.errorNotification.first()).toBeVisible({ visible: isVisible });
+    }
+    async isTextWithMessageVisible(message, isVisible = true) {
+        return await (0, test_1.expect)(this.page.getByText(message)).toBeVisible({ visible: isVisible });
+    }
+    async clickCreateThreeDotsButton() {
+        await this.createThreeDotsBtn.click();
+    }
+    async clickCreateButton(toForceClick = false) {
+        await (0, test_1.expect)(this.createBtn).toBeVisible();
+        await this.createBtn.click({ force: toForceClick });
+    }
+    async clickAddButton() {
+        await this.addBtn.click();
+    }
+    ;
+    async clickNewFolderThreeDotsButton() {
+        await this.newFolderThreeDotsBtn.click();
+    }
+    async clickEditorSettingsButton(index = 0) {
+        return this.editorSettingsBtn.nth(index).click();
+    }
+    async enterDescription(description) {
+        await this.enterDescriptionTxt.fill(description);
+    }
+    async doesDescriptionHaveValue(value, index = 0) {
+        return await (0, test_1.expect)(this.descriptionBtn.nth(index)).toHaveValue(value);
+    }
+    async clickStructureTab() {
+        await this.page.waitForTimeout(1000);
+        await this.structureTabBtn.waitFor({ state: 'visible' });
+        await this.structureTabBtn.click();
+    }
+    async clickAllowAtRootButton() {
+        await this.allowAtRootBtn.click();
+    }
+    async clickIAmDoneReorderingButton() {
+        await this.iAmDoneReorderingBtn.click();
+    }
+    async clickReorderButton() {
+        await this.reorderBtn.click();
+    }
+    async clickLabelAboveButton() {
+        await this.labelAboveBtn.click();
+    }
+    async clickMandatorySlider() {
+        await this.mandatorySlider.click();
+    }
+    async selectValidationOption(option) {
+        await this.validation.selectOption(option);
+    }
+    async enterRegEx(regEx) {
+        await this.regexTxt.fill(regEx);
+    }
+    async enterRegExMessage(regExMessage) {
+        await this.regexMessageTxt.fill(regExMessage);
+    }
+    async clickCompositionsButton() {
+        await this.compositionsBtn.click();
+    }
+    async clickAddTabButton() {
+        await this.addTabBtn.click();
+    }
+    async enterTabName(tabName) {
+        await (0, test_1.expect)(this.unnamedTxt).toBeVisible();
+        await this.page.waitForTimeout(400);
+        await this.unnamedTxt.clear();
+        await this.unnamedTxt.fill(tabName);
+    }
+    async searchForTypeToFilterValue(searchValue) {
+        await (0, test_1.expect)(this.typeToFilterSearchTxt).toBeVisible();
+        await this.typeToFilterSearchTxt.fill(searchValue);
+    }
+    async addPropertyEditor(propertyEditorName, index = 0) {
+        await (0, test_1.expect)(this.addPropertyBtn.nth(index)).toBeVisible();
+        await this.addPropertyBtn.nth(index).click();
+        await this.enterAPropertyName(propertyEditorName);
+        await (0, test_1.expect)(this.propertyNameTxt).toHaveValue(propertyEditorName);
+        await this.clickSelectPropertyEditorButton();
+        await this.searchForTypeToFilterValue(propertyEditorName);
+        await this.page.getByText(propertyEditorName, { exact: true }).click();
+        await this.clickSubmitButton();
+    }
+    async updatePropertyEditor(propertyEditorName) {
+        await this.clickEditorSettingsButton();
+        await this.clickChangeButton();
+        await this.searchForTypeToFilterValue(propertyEditorName);
+        await this.page.getByText(propertyEditorName, { exact: true }).click();
+        await this.enterAPropertyName(propertyEditorName);
+        await this.clickSubmitButton();
+    }
+    async enterPropertyEditorDescription(description) {
+        await this.enterPropertyEditorDescriptionTxt.fill(description);
+    }
+    async clickAddGroupButton() {
+        await this.addGroupBtn.click();
+    }
+    async clickChooseModalButton() {
+        await this.chooseModalBtn.click();
+    }
+    async enterGroupName(groupName, index = 0) {
+        await this.page.waitForTimeout(200);
+        const groupNameTxt = this.groupLabel.nth(index);
+        await (0, test_1.expect)(groupNameTxt).toBeVisible();
+        await groupNameTxt.clear();
+        await groupNameTxt.fill(groupName);
+    }
+    async isGroupVisible(groupName, isVisible = true) {
+        await (0, test_1.expect)(this.groupLabel.filter({ hasText: groupName })).toBeVisible({ visible: isVisible });
+    }
+    async doesGroupHaveValue(value) {
+        await (0, test_1.expect)(this.groupLabel).toBeVisible();
+        return await (0, test_1.expect)(this.groupLabel).toHaveValue(value);
+    }
+    async rename(newName) {
+        await this.clickRenameButton();
+        await (0, test_1.expect)(this.newNameTxt).toBeVisible();
+        await this.newNameTxt.click();
+        await this.newNameTxt.clear();
+        await this.newNameTxt.fill(newName);
+        await this.renameModalBtn.click();
+    }
+    async isSuccessButtonWithTextVisible(text) {
+        return await (0, test_1.expect)(this.successState.filter({ hasText: text })).toBeVisible();
+    }
+    async dragAndDrop(dragFromSelector, dragToSelector, verticalOffset = 0, horizontalOffset = 0, steps = 5) {
+        await (0, test_1.expect)(dragFromSelector).toBeVisible();
+        await (0, test_1.expect)(dragToSelector).toBeVisible();
+        const targetLocation = await dragToSelector.boundingBox();
+        const elementCenterX = targetLocation.x + targetLocation.width / 2;
+        const elementCenterY = targetLocation.y + targetLocation.height / 2;
+        await dragFromSelector.hover();
+        await this.page.mouse.move(10, 10);
+        await dragFromSelector.hover();
+        await this.page.mouse.down();
+        await this.page.waitForTimeout(400);
+        await this.page.mouse.move(elementCenterX + horizontalOffset, elementCenterY + verticalOffset, { steps: steps });
+        await this.page.waitForTimeout(400);
+        await this.page.mouse.up();
+    }
+    async clickCreateLink() {
+        await this.createLink.click();
+    }
+    async insertSystemFieldValue(fieldValue) {
+        await this.clickInsertButton();
+        await (0, test_1.expect)(this.insertValueBtn).toBeVisible();
+        await this.insertValueBtn.click();
+        await (0, test_1.expect)(this.chooseFieldDropDown).toBeVisible();
+        await this.chooseFieldDropDown.click();
+        await this.systemFieldsOption.click();
+        await this.chooseFieldValueDropDown.click();
+        await this.page.getByText(fieldValue).click();
+        await this.clickSubmitButton();
+    }
+    async insertPartialView(partialViewName) {
+        await this.clickInsertButton();
+        await (0, test_1.expect)(this.insertPartialViewBtn).toBeVisible();
+        await this.insertPartialViewBtn.click();
+        await (0, test_1.expect)(this.page.getByLabel(partialViewName)).toBeVisible();
+        await this.page.getByLabel(partialViewName).click();
+        await this.chooseBtn.click();
+    }
+    async deletePropertyEditorWithName(name) {
+        // We need to hover over the Property Editor to make the delete button visible
+        const propertyEditor = this.page.locator('umb-content-type-design-editor-property', { hasText: name });
+        await propertyEditor.hover();
+        await propertyEditor.getByLabel('Delete').click({ force: true });
+        await this.clickConfirmToDeleteButton();
+    }
+    async clickRenameButton() {
+        await this.renameBtn.click();
+    }
+    async clickDeleteAndConfirmButton() {
+        await this.clickDeleteExactLabel();
+        await this.clickConfirmToDeleteButton();
+    }
+    async clickQueryBuilderButton() {
+        await this.queryBuilderBtn.click();
+    }
+    async chooseRootContentInQueryBuilder(contentName) {
+        await (0, test_1.expect)(this.chooseRootContentBtn).toBeVisible();
+        await this.chooseRootContentBtn.click();
+        await (0, test_1.expect)(this.page.getByText(contentName)).toBeVisible();
+        await this.page.getByText(contentName).click();
+        await this.chooseBtn.click();
+    }
+    async reorderTwoGroups() {
+        const firstGroup = this.typeGroups.nth(0);
+        const secondGroup = this.typeGroups.nth(1);
+        const firstGroupValue = await firstGroup.getByLabel('Group', { exact: true }).inputValue();
+        const secondGroupValue = await secondGroup.getByLabel('Group', { exact: true }).inputValue();
+        const dragToLocator = firstGroup.locator('[name="icon-navigation"]').first();
+        const dragFromLocator = secondGroup.locator('[name="icon-navigation"]').first();
+        await this.dragAndDrop(dragFromLocator, dragToLocator, 0, 0, 10);
+        return { firstGroupValue, secondGroupValue };
+    }
+    async clickAllowedChildNodesButton() {
+        await this.allowedChildNodesModal.locator(this.chooseBtn).click();
+    }
+    async clickConfigureAsACollectionButton() {
+        await this.configureAsACollectionBtn.click();
+    }
+    async doesReturnedItemsHaveCount(itemCount) {
+        await (0, test_1.expect)(this.returnedItemsCount).toContainText(itemCount.toString() + ' items returned');
+    }
+    async doesQueryResultHaveContentName(contentName) {
+        await (0, test_1.expect)(this.queryBuilderShowCode).toContainText(contentName);
+    }
+    async deleteGroup(groupName, toForceClick = false) {
+        await this.page.waitForTimeout(1000);
+        const groups = this.page.locator('umb-content-type-design-editor-group').all();
+        for (const group of await groups) {
+            if (await group.getByLabel('Group', { exact: true }).inputValue() === groupName) {
+                await group.locator('[slot="header-actions"]').getByLabel('Delete').click({ force: toForceClick });
+                return;
+            }
+        }
+    }
+    async clickRemoveTabWithName(name) {
+        await this.page.locator('[label="' + name + '"] [label="Remove"]').click();
+    }
+    async clickLeftArrowButton() {
+        await this.leftArrowBtn.click();
+    }
+    async clickToUploadButton() {
+        await this.clickToUploadBtn.click();
+    }
+    async uploadFile(filePath) {
+        const fileChooserPromise = this.page.waitForEvent('filechooser');
+        await this.clickToUploadButton();
+        const fileChooser = await fileChooserPromise;
+        await fileChooser.setFiles(filePath);
+    }
+    getTabLocatorWithName(name) {
+        return this.page.getByRole('tab', { name: name });
+    }
+    getTextLocatorWithName(name) {
+        return this.page.getByText(name, { exact: true });
+    }
+    async isFailedStateButtonVisible() {
+        await (0, test_1.expect)(this.failedStateButton).toBeVisible();
+    }
+    async clickContainerSaveAndPublishButton() {
+        await this.containerSaveAndPublishBtn.click();
+    }
+    async clickConfirmTrashButton() {
+        await this.confirmTrashBtn.click();
+    }
+    async reloadRecycleBin(containsItems = true) {
+        // We need to wait to be sure that the item is visible after reload
+        await (0, test_1.expect)(this.recycleBinMenuItem).toBeVisible();
+        await this.clickActionsMenuForName('Recycle Bin');
+        await this.clickReloadButton();
+        await (0, test_1.expect)(this.recycleBinMenuItem).toBeVisible();
+        // If the Recycle Bin does not contain any items,0 the caret button should not be visible. and we should not try to click it
+        if (!containsItems) {
+            await (0, test_1.expect)(this.recycleBinMenuItemCaretBtn).not.toBeVisible();
+            return;
+        }
+        await (0, test_1.expect)(this.recycleBinMenuItemCaretBtn).toBeVisible();
+        const isCaretButtonOpen = await this.recycleBinMenuItem.getAttribute('show-children');
+        if (isCaretButtonOpen === null) {
+            // We need to wait before clicking the caret button. Because the reload might not have happened yet. 
+            await this.clickCaretButtonForName('Recycle Bin');
+        }
+    }
+    async clickRecycleBinButton() {
+        await this.recycleBinBtn.click();
+    }
+    async isItemVisibleInRecycleBin(item, isVisible = true, isReload = true) {
+        if (isReload) {
+            await this.reloadRecycleBin(isVisible);
+        }
+        return (0, test_1.expect)(this.page.locator('[label="Recycle Bin"] [label="' + item + '"]')).toBeVisible({ visible: isVisible });
+    }
+    async changeToGridView() {
+        await this.viewBundleBtn.click();
+        await this.gridBtn.click();
+    }
+    async changeToListView() {
+        await this.viewBundleBtn.click();
+        await this.listBtn.click();
+    }
+    async isViewBundleButtonVisible(isVisible = true) {
+        return (0, test_1.expect)(this.viewBundleBtn).toBeVisible({ visible: isVisible });
+    }
+    async doesSuccessNotificationHaveText(text) {
+        return await (0, test_1.expect)(this.successNotification.filter({ hasText: text })).toBeVisible();
+    }
+    async doesErrorNotificationHaveText(text) {
+        return await (0, test_1.expect)(this.errorNotification.filter({ hasText: text })).toBeVisible();
+    }
+    async isSectionWithNameVisible(sectionName, isVisible = true) {
+        return (0, test_1.expect)(this.page.getByRole('tab', { name: sectionName })).toBeVisible({ visible: isVisible });
     }
 }
 exports.UiBaseLocators = UiBaseLocators;