[ACA-3596] Fix e2e due to process header properties changes (#5873)

* [ACA-3596] Fix e2e due to process header properties changes

* Change pages structure

* Move the build demoshell as last step and exclude for PR

* move more pages

* change testing pkg

* better JSON import

* update script

* move CLOUD in the right place

* some logs and not used methods

* retrycout

Co-authored-by: maurizio vitale <maurizio.vitale@alfresco.com>
Co-authored-by: Eugenio Romano <eugenio.romano@alfresco.com>
Co-authored-by: Eugenio Romano <eromano@users.noreply.github.com>

e2e/content-services/pages/breadcrumb/bread-crumb-dropdown.page.ts

@@ -0,0 +1,44 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { element, by } from 'protractor';
+import { BrowserActions, DropdownPage } from '@alfresco/adf-testing';
+
+export class BreadCrumbDropdownPage {
+
+    breadCrumb = element(by.css(`adf-dropdown-breadcrumb[data-automation-id='content-node-selector-content-breadcrumb']`));
+    parentFolder = this.breadCrumb.element(by.css(`button[data-automation-id='dropdown-breadcrumb-trigger']`));
+    currentFolder = this.breadCrumb.element(by.css(`div span[data-automation-id="current-folder"]`));
+
+    breadCrumbDropdown = new DropdownPage(element.all(by.css(`div[class*='mat-select-panel']`)).first());
+
+    async choosePath(pathName: string): Promise<void> {
+        await this.breadCrumbDropdown.selectOption(pathName);
+    }
+
+    async clickParentFolder(): Promise<void> {
+        await BrowserActions.click(this.parentFolder);
+    }
+
+    async checkBreadCrumbDropdownIsDisplayed(): Promise<void> {
+        await this.breadCrumbDropdown.checkDropdownIsVisible();
+    }
+
+    async getTextOfCurrentFolder(): Promise<string> {
+        return BrowserActions.getText(this.currentFolder);
+    }
+}

e2e/content-services/pages/lock-file.page.ts

@@ -0,0 +1,56 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { element, by } from 'protractor';
+import { BrowserVisibility, BrowserActions } from '@alfresco/adf-testing';
+
+export class LockFilePage {
+
+    cancelButton = element(by.css('button[data-automation-id="lock-dialog-btn-cancel"]'));
+    saveButton = element(by.cssContainingText('button span', 'Save'));
+    lockFileCheckboxText = element(by.cssContainingText('mat-checkbox label span', ' Lock file '));
+    lockFileCheckbox = element(by.css('mat-checkbox[data-automation-id="adf-lock-node-checkbox"]'));
+    allowOwnerCheckbox = element(by.cssContainingText('mat-checkbox[class*="adf-lock-file-name"] span', ' Allow the owner to modify this file '));
+
+    async checkLockFileCheckboxIsDisplayed(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.lockFileCheckboxText);
+    }
+
+    async checkCancelButtonIsDisplayed(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.cancelButton);
+    }
+
+    async checkSaveButtonIsDisplayed(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.saveButton);
+    }
+
+    async clickCancelButton(): Promise<void> {
+        await BrowserActions.click(this.cancelButton);
+    }
+
+    async clickLockFileCheckbox(): Promise<void> {
+        await BrowserActions.click(this.lockFileCheckbox);
+    }
+
+    async clickSaveButton(): Promise<void> {
+        await BrowserActions.click(this.saveButton);
+    }
+
+    async clickAllowOwnerCheckbox(): Promise<void> {
+        await BrowserActions.click(this.allowOwnerCheckbox);
+    }
+}

e2e/content-services/pages/permissions.page.ts

@@ -0,0 +1,49 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    DataTableComponentPage,
+    AddPermissionsDialogPage,
+    BrowserVisibility,
+    BrowserActions
+} from '@alfresco/adf-testing';
+import { by, element } from 'protractor';
+
+export class PermissionsPage {
+
+    dataTableComponentPage = new DataTableComponentPage();
+    addPermissionsDialog = new AddPermissionsDialogPage();
+
+    addPermissionButton = element(by.css("button[data-automation-id='adf-add-permission-button']"));
+    addPermissionDialog = element(by.css('adf-add-permission-dialog'));
+    searchUserInput = element(by.id('searchInput'));
+    searchResults = element(by.css('#adf-add-permission-authority-results #adf-search-results-content'));
+    addButton = element(by.id('add-permission-dialog-confirm-button'));
+    permissionInheritedButton = element.all(by.css('.app-inherit_permission_button button')).first();
+    noPermissions = element(by.id('adf-no-permissions-template'));
+    deletePermissionButton = element(by.css(`button[data-automation-id='adf-delete-permission-button']`));
+    permissionDisplayContainer = element(by.id('adf-permission-display-container'));
+    closeButton = element(by.id('add-permission-dialog-close-button'));
+
+    async clickCloseButton(): Promise<void> {
+        await BrowserActions.click(this.closeButton);
+    }
+
+    async checkAddPermissionButtonIsDisplayed(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.addPermissionButton);
+    }
+}

e2e/content-services/pages/social.page.ts

@@ -0,0 +1,34 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { by, element } from 'protractor';
+import { BrowserActions, BrowserVisibility } from '@alfresco/adf-testing';
+
+export class SocialPage {
+
+    nodeIdField = element(by.css(`input[id="nodeId"]`));
+
+    async getNodeIdFieldValue(): Promise<string> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.nodeIdField);
+        return this.nodeIdField.getAttribute('value');
+    }
+
+    async writeCustomNodeId(nodeId: string): Promise<void> {
+        await BrowserActions.clearSendKeys(this.nodeIdField, nodeId);
+    }
+
+}

e2e/content-services/pages/tag.page.ts

@@ -0,0 +1,209 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { element, by, protractor, browser } from 'protractor';
+import { BrowserVisibility, BrowserActions } from '@alfresco/adf-testing';
+
+export class TagPage {
+
+    addTagButton = element(by.id('add-tag'));
+    insertNodeIdElement = element(by.css('input[id="nodeId"]'));
+    newTagInput = element(by.css('input[id="new-tag-text"]'));
+    tagListRow = element(by.css('adf-tag-node-actions-list mat-list-item'));
+    tagListByNodeIdRow = element(by.css('adf-tag-node-list mat-chip'));
+    errorMessage = element(by.css('mat-hint[data-automation-id="errorMessage"]'));
+    tagListRowLocator = by.css('adf-tag-node-actions-list mat-list-item div');
+    tagListByNodeIdRowLocator = by.css('adf-tag-node-list mat-chip span');
+    tagListContentServicesRowLocator = by.css('div[class*="adf-list-tag"]');
+    showDeleteButton = element(by.id('adf-remove-button-tag'));
+    showMoreButton = element(by.css('button[data-automation-id="show-more-tags"]'));
+    showLessButton = element(by.css('button[data-automation-id="show-fewer-tags"]'));
+    tagsOnPage = element.all(by.css('div[class*="adf-list-tag"]'));
+    confirmTag = element(by.id('adf-tag-node-send'));
+
+    async getNodeId(): Promise<string> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.insertNodeIdElement);
+        return this.insertNodeIdElement.getAttribute('value');
+    }
+
+    async insertNodeId(nodeId) {
+        await BrowserActions.clearSendKeys(this.insertNodeIdElement, nodeId);
+
+        await browser.sleep(200);
+        await this.insertNodeIdElement.sendKeys(' ');
+        await browser.sleep(200);
+        await this.insertNodeIdElement.sendKeys(protractor.Key.BACK_SPACE);
+        await this.clickConfirmTag();
+    }
+
+    async addNewTagInput(tag: string) {
+        await BrowserActions.clearSendKeys(this.newTagInput, tag);
+    }
+
+    async addTag(tag: string): Promise<void> {
+        await this.addNewTagInput(tag);
+        await BrowserActions.click(this.addTagButton);
+    }
+
+    async deleteTagFromTagListByNodeId(name: string): Promise<void> {
+        const deleteChip = element(by.id('tag_chips_delete_' + name));
+        await BrowserActions.click(deleteChip);
+    }
+
+    async deleteTagFromTagList(name: string): Promise<void> {
+        const deleteChip = element(by.id('tag_chips_delete_' + name));
+        await BrowserActions.click(deleteChip);
+    }
+
+    async getNewTagInput(): Promise<string> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.newTagInput);
+        return this.newTagInput.getAttribute('value');
+    }
+
+    async getNewTagPlaceholder(): Promise<string> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.newTagInput);
+        return this.newTagInput.getAttribute('placeholder');
+    }
+
+    async addTagButtonIsEnabled(): Promise<boolean> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.addTagButton);
+        return this.addTagButton.isEnabled();
+    }
+
+    async checkTagIsDisplayedInTagList(tagName: string): Promise<void> {
+        const tag = element(by.cssContainingText('div[id*="tag_name"]', tagName));
+        await BrowserVisibility.waitUntilElementIsVisible(tag);
+    }
+
+    async checkTagIsNotDisplayedInTagList(tagName: string): Promise<void> {
+        const tag = element(by.cssContainingText('div[id*="tag_name"]', tagName));
+        await BrowserVisibility.waitUntilElementIsNotVisible(tag);
+    }
+
+    async checkTagIsNotDisplayedInTagListByNodeId(tagName: string): Promise<void> {
+        const tag = element(by.cssContainingText('span[id*="tag_name"]', tagName));
+        await BrowserVisibility.waitUntilElementIsNotVisible(tag);
+    }
+
+    async checkTagIsDisplayedInTagListByNodeId(tagName: string): Promise<void> {
+        const tag = element(by.cssContainingText('span[id*="tag_name"]', tagName));
+        await BrowserVisibility.waitUntilElementIsVisible(tag);
+    }
+
+    async checkTagListIsEmpty(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsNotVisible(this.tagListRow);
+    }
+
+    async checkTagListByNodeIdIsEmpty(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsNotVisible(this.tagListByNodeIdRow);
+    }
+
+    async checkTagIsDisplayedInTagListContentServices(tagName: string): Promise<void> {
+        const tag = element(by.cssContainingText('.adf-list-tag[id*="tag_name"]', tagName));
+        await BrowserVisibility.waitUntilElementIsVisible(tag);
+    }
+
+    async getErrorMessage(): Promise<string> {
+        return BrowserActions.getText(this.errorMessage);
+    }
+
+    async checkTagListIsOrderedAscending(): Promise<any> {
+        await this.checkListIsSorted(false, this.tagListRowLocator);
+    }
+
+    async checkTagListByNodeIdIsOrderedAscending(): Promise<any> {
+        await this.checkListIsSorted(false, this.tagListByNodeIdRowLocator);
+    }
+
+    async checkTagListContentServicesIsOrderedAscending(): Promise<any> {
+        await this.checkListIsSorted(false, this.tagListContentServicesRowLocator);
+    }
+
+    async checkListIsSorted(sortOrder, locator): Promise<boolean> {
+        const tagList = element.all(locator);
+        await BrowserVisibility.waitUntilElementIsVisible(tagList.first());
+        const initialList = [];
+        await tagList.each(async (currentElement) => {
+            const text = await BrowserActions.getText(currentElement);
+            initialList.push(text);
+        });
+        let sortedList = initialList;
+        sortedList = sortedList.sort();
+        if (sortOrder === false) {
+            sortedList = sortedList.reverse();
+        }
+        return initialList.toString() === sortedList.toString();
+    }
+
+    async checkDeleteTagFromTagListByNodeIdIsDisplayed(name: string): Promise<void> {
+        const deleteChip = element(by.id('tag_chips_delete_' + name));
+        await BrowserVisibility.waitUntilElementIsVisible(deleteChip);
+    }
+
+    async checkDeleteTagFromTagListByNodeIdIsNotDisplayed(name: string): Promise<void> {
+        const deleteChip = element(by.id('tag_chips_delete_' + name));
+        await BrowserVisibility.waitUntilElementIsNotVisible(deleteChip);
+    }
+
+    async clickShowDeleteButtonSwitch(): Promise<void> {
+        await BrowserActions.click(this.showDeleteButton);
+    }
+
+    async checkShowMoreButtonIsDisplayed(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.showMoreButton);
+    }
+
+    async clickShowMoreButton(): Promise<void> {
+        await BrowserActions.click(this.showMoreButton);
+    }
+
+    async clickShowLessButton(): Promise<void> {
+        await BrowserActions.click(this.showLessButton);
+    }
+
+    async clickConfirmTag(): Promise<void> {
+        await BrowserActions.click(this.confirmTag);
+    }
+
+    async checkTagsOnList(): Promise<number> {
+        return this.tagsOnPage.count();
+    }
+
+    async checkShowLessButtonIsDisplayed(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.showLessButton);
+    }
+
+    async checkShowLessButtonIsNotDisplayed(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsNotVisible(this.showLessButton);
+    }
+
+    async clickShowMoreButtonUntilNotDisplayed(): Promise<void> {
+        const visible = await this.showMoreButton.isDisplayed();
+        if (visible) {
+            await BrowserActions.click(this.showMoreButton);
+            await this.clickShowMoreButtonUntilNotDisplayed();
+        }
+    }
+
+    async clickShowLessButtonUntilNotDisplayed(): Promise<void> {
+        const visible = await this.showLessButton.isDisplayed();
+        if (visible) {
+            await BrowserActions.click(this.showLessButton);
+            await this.clickShowLessButtonUntilNotDisplayed();
+        }
+    }
+}

e2e/content-services/pages/tree-view.page.ts

@@ -0,0 +1,86 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { element, by, protractor } from 'protractor';
+import { BrowserVisibility, BrowserActions } from '@alfresco/adf-testing';
+
+export class TreeViewPage {
+
+    treeViewTitle = element(by.cssContainingText('app-tree-view div', 'TREE VIEW TEST'));
+    nodeIdInput = element(by.css('input[placeholder="Node Id"]'));
+    noNodeMessage = element(by.id('adf-tree-view-missing-node'));
+    nodesOnPage = element.all(by.css('mat-tree-node'));
+
+    async checkTreeViewTitleIsDisplayed(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.treeViewTitle);
+    }
+
+    async getNodeId(): Promise<string> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.nodeIdInput);
+        return this.nodeIdInput.getAttribute('value');
+    }
+
+    async clickNode(nodeName: string): Promise<void> {
+        const node = element(by.css('mat-tree-node[id="' + nodeName + '-tree-child-node"] button'));
+        await BrowserActions.click(node);
+    }
+
+    async checkNodeIsDisplayedAsClosed(nodeName: string): Promise<void> {
+        const node = element(by.css('mat-tree-node[id="' + nodeName + '-tree-child-node"][aria-expanded="false"]'));
+        await BrowserVisibility.waitUntilElementIsVisible(node);
+    }
+
+    async checkNodeIsDisplayedAsOpen(nodeName: string): Promise<void> {
+        const node = element(by.css('mat-tree-node[id="' + nodeName + '-tree-child-node"][aria-expanded="true"]'));
+        await BrowserVisibility.waitUntilElementIsVisible(node);
+    }
+
+    async checkClickedNodeName(nodeName: string): Promise<void> {
+        const clickedNode = element(by.cssContainingText('span', ' CLICKED NODE: ' + nodeName + ''));
+        await BrowserVisibility.waitUntilElementIsVisible(clickedNode);
+    }
+
+    async checkNodeIsNotDisplayed(nodeName: string): Promise<void> {
+        const node = element(by.id('' + nodeName + '-tree-child-node'));
+        await BrowserVisibility.waitUntilElementIsNotVisible(node);
+    }
+
+    async clearNodeIdInput(): Promise<void> {
+        await BrowserActions.click(this.nodeIdInput);
+        await BrowserActions.clearWithBackSpace(this.nodeIdInput);
+    }
+
+    async checkNoNodeIdMessageIsDisplayed(): Promise<void> {
+        await BrowserVisibility.waitUntilElementIsVisible(this.noNodeMessage);
+    }
+
+    async addNodeId(nodeId: string): Promise<void> {
+        await BrowserActions.click(this.nodeIdInput);
+        await BrowserActions.clearSendKeys(this.nodeIdInput, nodeId);
+        await this.nodeIdInput.sendKeys('a');
+        await this.nodeIdInput.sendKeys(protractor.Key.BACK_SPACE);
+    }
+
+    async checkErrorMessageIsDisplayed(): Promise<void> {
+        const clickedNode = element(by.cssContainingText('span', 'An Error Occurred '));
+        await BrowserVisibility.waitUntilElementIsVisible(clickedNode);
+    }
+
+    async getTotalNodes(): Promise<number> {
+        return this.nodesOnPage.count();
+    }
+}