inteligr8/alfresco-content-app
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-content-app.git synced 2025-07-31 17:38:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

e2e refactorings (#1346)

Browse Source 
* - create a generic-dialog class to remove some duplicated code
- add return types

* - share dialog needs custom methods
- also, fix copy/paste mistake :D
This commit is contained in:
Adina Parpalita
2020-02-25 12:28:59 +02:00
committed by GitHub
parent 59b529160d
commit a825c37da4
14 changed files with 376 additions and 517 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
e2e/components/breadcrumb/breadcrumb.ts
View File

@@ -44,43 +44,32 @@ export class Breadcrumb extends Component {
return this.items.get(nth - 1); return this.items.get(nth - 1);
} }
async getNthItemName(nth: number) { async getItemsCount(): Promise<number> {
return this.getNthItem(nth).getText();
}
async getItemsCount() {
return this.items.count(); return this.items.count();
} }
async getAllItems() { async getAllItems(): Promise<string[]> {
return this.items.map(async elem => { const items: string[] = await this.items.map(async elem => {
const str = await elem.getText(); const str = await elem.getText();
return str.split('\nchevron_right')[0]; return str.split('\nchevron_right')[0];
}); });
return items;
} }
async getFirstItemName() { getCurrentItem(): ElementFinder {
return this.items.get(0).getText();
}
getCurrentItem() {
return this.currentItem; return this.currentItem;
} }
async getCurrentItemName() { async getCurrentItemName(): Promise<string> {
return this.currentItem.getText(); return this.currentItem.getText();
} }
async clickItem(name: string) { async clickItem(name: string): Promise<void> {
const elem = this.component.element(by.css(`${Breadcrumb.selectors.item}[title=${name}]`)); const elem = this.component.element(by.css(`${Breadcrumb.selectors.item}[title=${name}]`));
await elem.click(); await elem.click();
} }
async clickNthItem(nth: number) { async getNthItemTooltip(nth: number): Promise<string> {
await this.getNthItem(nth).click();
}
async getNthItemTooltip(nth: number) {
return this.getNthItem(nth).getAttribute('title'); return this.getNthItem(nth).getAttribute('title');
} }
} }

16
e2e/components/datetime-picker/datetime-picker.ts
View File

@@ -48,31 +48,33 @@ export class DateTimePicker extends Component {
headerYear: ElementFinder = this.component.element(by.css(DateTimePicker.selectors.year)); headerYear: ElementFinder = this.component.element(by.css(DateTimePicker.selectors.year));
dayPicker: ElementFinder = this.component.element(by.css(DateTimePicker.selectors.dayPicker)); dayPicker: ElementFinder = this.component.element(by.css(DateTimePicker.selectors.dayPicker));
rootElemLocator = by.css(DateTimePicker.selectors.root);
constructor(ancestor?: string) { constructor(ancestor?: string) {
super(DateTimePicker.selectors.root, ancestor); super(DateTimePicker.selectors.root, ancestor);
} }
async waitForDateTimePickerToOpen() { async waitForDateTimePickerToOpen(): Promise<void> {
await browser.wait(EC.presenceOf(this.calendar), BROWSER_WAIT_TIMEOUT); await browser.wait(EC.presenceOf(this.calendar), BROWSER_WAIT_TIMEOUT);
} }
async waitForDateTimePickerToClose() { async waitForDateTimePickerToClose(): Promise<void> {
await browser.wait(EC.stalenessOf(this.calendar), BROWSER_WAIT_TIMEOUT); await browser.wait(EC.stalenessOf(this.calendar), BROWSER_WAIT_TIMEOUT);
} }
async isCalendarOpen() { async isCalendarOpen(): Promise<boolean> {
return browser.isElementPresent(by.css(DateTimePicker.selectors.root)); return (await browser.element(this.rootElemLocator).isPresent()) && (await browser.element(this.rootElemLocator).isDisplayed());
} }
async getDate() { async getDate(): Promise<string> {
return this.headerDate.getText(); return this.headerDate.getText();
} }
async getYear() { async getYear(): Promise<string> {
return this.headerYear.getText(); return this.headerYear.getText();
} }
async setDefaultDay() { async setDefaultDay(): Promise<string> {
const today = moment(); const today = moment();
const tomorrow = today.add(1, 'day'); const tomorrow = today.add(1, 'day');
const dayOfTomorrow = tomorrow.date(); const dayOfTomorrow = tomorrow.date();

101
e2e/components/dialog/confirm-dialog.ts
View File

@@ -23,105 +23,66 @@
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/ */
import { ElementFinder, by, browser, ExpectedConditions as EC } from 'protractor'; import { by } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs'; import { GenericDialog } from '../dialog/generic-dialog';
import { Component } from '../component';
export class ConfirmDialog extends Component { export class ConfirmDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: 'adf-confirm-dialog', root: 'adf-confirm-dialog',
title: '.mat-dialog-title', okButton: by.buttonText('OK'),
content: '.mat-dialog-content', cancelButton: by.buttonText('Cancel'),
accept: 'adf-confirm-accept', keepButton: by.buttonText('Keep'),
cancel: 'adf-confirm-cancel', deleteButton: by.buttonText('Delete'),
actionButton: 'adf-confirm' removeButton: by.buttonText('Remove')
};
title: ElementFinder = this.component.element(by.css(ConfirmDialog.selectors.title));
content: ElementFinder = this.component.element(by.css(ConfirmDialog.selectors.content));
acceptButton: ElementFinder = this.component.element(by.id(ConfirmDialog.selectors.accept));
cancelButton: ElementFinder = this.component.element(by.id(ConfirmDialog.selectors.cancel));
actionButton: ElementFinder = this.component.element(by.id(ConfirmDialog.selectors.actionButton));
constructor(ancestor?: string) {
super(ConfirmDialog.selectors.root, ancestor);
} }
async waitForDialogToClose() { constructor() {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT); super(ConfirmDialog.selectors.root);
} }
async waitForDialogToOpen() { async getText(): Promise<string> {
await browser.wait(EC.presenceOf(this.title), BROWSER_WAIT_TIMEOUT);
}
async isDialogOpen() {
return browser.isElementPresent(by.css(ConfirmDialog.selectors.root));
}
async getTitle() {
return this.title.getText();
}
async getText() {
return this.content.getText(); return this.content.getText();
} }
getButtonByName(name: string) { async isOkEnabled(): Promise<boolean> {
return this.component.element(by.buttonText(name)); return this.isButtonEnabled(ConfirmDialog.selectors.okButton);
} }
async clickButton(name: string) { async isCancelEnabled(): Promise<boolean> {
const button = this.getButtonByName(name); return this.isButtonEnabled(ConfirmDialog.selectors.cancelButton);
await button.click();
} }
async isButtonEnabled(name: string) { async isKeepEnabled(): Promise<boolean> {
const button = this.getButtonByName(name); return this.isButtonEnabled(ConfirmDialog.selectors.keepButton);
return button.isEnabled();
} }
async isDeleteEnabled(): Promise<boolean> {
async isOkEnabled() { return this.isButtonEnabled(ConfirmDialog.selectors.deleteButton);
return this.isButtonEnabled('OK');
} }
async isCancelEnabled() { async isRemoveEnabled(): Promise<boolean> {
return this.isButtonEnabled('Cancel'); return this.isButtonEnabled(ConfirmDialog.selectors.removeButton);
} }
async isKeepEnabled() { async clickOk(): Promise<void> {
return this.isButtonEnabled('Keep'); await this.clickButton(ConfirmDialog.selectors.okButton);
} }
async isDeleteEnabled() { async clickCancel(): Promise<void> {
return this.isButtonEnabled('Delete'); await this.clickButton(ConfirmDialog.selectors.cancelButton);
} }
async isRemoveEnabled() { async clickKeep(): Promise<void> {
return this.isButtonEnabled('Remove'); await this.clickButton(ConfirmDialog.selectors.keepButton);
} }
async clickDelete(): Promise<void> {
async clickOk() { await this.clickButton(ConfirmDialog.selectors.deleteButton);
await this.clickButton('OK');
} }
async clickCancel() { async clickRemove(): Promise<void> {
await this.cancelButton.click(); await this.clickButton(ConfirmDialog.selectors.removeButton);
}
async clickKeep() {
await this.clickButton('Keep');
}
async clickDelete() {
await this.clickButton('Delete');
}
async clickRemove() {
await this.clickButton('Remove');
} }
} }

58
e2e/components/dialog/content-node-selector-dialog.ts
View File

@@ -25,55 +25,41 @@
import { ElementFinder, by, browser, ExpectedConditions as EC, protractor } from 'protractor'; import { ElementFinder, by, browser, ExpectedConditions as EC, protractor } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs'; import { BROWSER_WAIT_TIMEOUT } from '../../configs';
import { Component } from '../component'; import { GenericDialog } from '../dialog/generic-dialog';
import { Utils } from '../../utilities/utils'; import { Utils } from '../../utilities/utils';
import { DropDownBreadcrumb } from '../breadcrumb/dropdown-breadcrumb'; import { DropDownBreadcrumb } from '../breadcrumb/dropdown-breadcrumb';
import { DataTable } from '../data-table/data-table'; import { DataTable } from '../data-table/data-table';
export class ContentNodeSelectorDialog extends Component { export class ContentNodeSelectorDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: '.adf-content-node-selector-dialog', root: '.adf-content-node-selector-dialog',
title: '.mat-dialog-title',
locationDropDown: 'site-dropdown-container', locationDropDown: 'site-dropdown-container',
locationOption: '.mat-option .mat-option-text', locationOption: '.mat-option .mat-option-text',
dataTable: '.adf-datatable-body', dataTable: '.adf-datatable-body',
selectedRow: '.adf-is-selected', selectedRow: '.adf-is-selected',
button: '.mat-dialog-actions button',
chooseAction: '.adf-choose-action',
searchInput: '#searchInput', searchInput: '#searchInput',
toolbarTitle: '.adf-toolbar-title' toolbarTitle: '.adf-toolbar-title',
cancelButton: by.css('[data-automation-id="content-node-selector-actions-cancel"]'),
copyButton: by.cssContainingText('[data-automation-id="content-node-selector-actions-choose"]', 'Copy'),
moveButton: by.cssContainingText('[data-automation-id="content-node-selector-actions-choose"]', 'Move')
}; };
title: ElementFinder = this.component.element(by.css(ContentNodeSelectorDialog.selectors.title)); locationDropDown: ElementFinder = this.rootElem.element(by.id(ContentNodeSelectorDialog.selectors.locationDropDown));
locationDropDown: ElementFinder = this.component.element(by.id(ContentNodeSelectorDialog.selectors.locationDropDown));
locationPersonalFiles: ElementFinder = browser.element(by.cssContainingText(ContentNodeSelectorDialog.selectors.locationOption, 'Personal Files')); locationPersonalFiles: ElementFinder = browser.element(by.cssContainingText(ContentNodeSelectorDialog.selectors.locationOption, 'Personal Files'));
locationFileLibraries: ElementFinder = browser.element(by.cssContainingText(ContentNodeSelectorDialog.selectors.locationOption, 'File Libraries')); locationFileLibraries: ElementFinder = browser.element(by.cssContainingText(ContentNodeSelectorDialog.selectors.locationOption, 'File Libraries'));
cancelButton: ElementFinder = this.component.element(by.cssContainingText(ContentNodeSelectorDialog.selectors.button, 'Cancel')); searchInput: ElementFinder = this.rootElem.element(by.css(ContentNodeSelectorDialog.selectors.searchInput));
copyButton: ElementFinder = this.component.element(by.css(ContentNodeSelectorDialog.selectors.chooseAction)); toolbarTitle: ElementFinder = this.rootElem.element(by.css(ContentNodeSelectorDialog.selectors.toolbarTitle));
moveButton: ElementFinder = this.component.element(by.cssContainingText(ContentNodeSelectorDialog.selectors.button, 'Move'));
searchInput: ElementFinder = this.component.element(by.css(ContentNodeSelectorDialog.selectors.searchInput));
toolbarTitle: ElementFinder = this.component.element(by.css(ContentNodeSelectorDialog.selectors.toolbarTitle));
breadcrumb: DropDownBreadcrumb = new DropDownBreadcrumb(); breadcrumb: DropDownBreadcrumb = new DropDownBreadcrumb();
dataTable: DataTable = new DataTable(ContentNodeSelectorDialog.selectors.root); dataTable: DataTable = new DataTable(ContentNodeSelectorDialog.selectors.root);
constructor(ancestor?: string) { constructor() {
super(ContentNodeSelectorDialog.selectors.root, ancestor); super(ContentNodeSelectorDialog.selectors.root);
}
async waitForDialogToOpen(): Promise<void> {
await browser.wait(EC.presenceOf(this.title), BROWSER_WAIT_TIMEOUT, 'timeout waiting for dialog title');
await browser.wait(EC.presenceOf(browser.element(by.css('.cdk-overlay-backdrop'))), BROWSER_WAIT_TIMEOUT, 'timeout waiting for overlay backdrop');
}
async waitForDialogToClose(): Promise<void> {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT);
} }
async waitForDropDownToOpen(): Promise<void> { async waitForDropDownToOpen(): Promise<void> {
@@ -85,28 +71,20 @@ export class ContentNodeSelectorDialog extends Component {
} }
async waitForRowToBeSelected(): Promise<void> { async waitForRowToBeSelected(): Promise<void> {
await browser.wait(EC.presenceOf(this.component.element(by.css(ContentNodeSelectorDialog.selectors.selectedRow))), BROWSER_WAIT_TIMEOUT); await browser.wait(EC.presenceOf(browser.element(by.css(ContentNodeSelectorDialog.selectors.selectedRow))), BROWSER_WAIT_TIMEOUT);
}
async isDialogOpen(): Promise<boolean> {
return browser.$(ContentNodeSelectorDialog.selectors.root).isDisplayed();
}
async getTitle(): Promise<string> {
return this.title.getText();
} }
async clickCancel(): Promise<void> { async clickCancel(): Promise<void> {
await this.cancelButton.click(); await this.clickButton(ContentNodeSelectorDialog.selectors.cancelButton);
await this.waitForDialogToClose(); await this.waitForDialogToClose();
} }
async clickCopy(): Promise<void> { async clickCopy(): Promise<void> {
await this.copyButton.click(); await this.clickButton(ContentNodeSelectorDialog.selectors.copyButton);
} }
async clickMove(): Promise<void> { async clickMove(): Promise<void> {
await this.moveButton.click(); await this.clickButton(ContentNodeSelectorDialog.selectors.moveButton);
} }
async selectLocation(location: 'Personal Files' | 'File Libraries'): Promise<void> { async selectLocation(location: 'Personal Files' | 'File Libraries'): Promise<void> {
@@ -138,11 +116,11 @@ export class ContentNodeSelectorDialog extends Component {
} }
async isCopyButtonEnabled(): Promise<boolean> { async isCopyButtonEnabled(): Promise<boolean> {
return (await this.copyButton.isPresent()) && (await this.copyButton.isEnabled()); return this.isButtonEnabled(ContentNodeSelectorDialog.selectors.copyButton);
} }
async isCancelButtonEnabled(): Promise<boolean> { async isCancelButtonEnabled(): Promise<boolean> {
return (await this.cancelButton.isPresent()) && (await this.cancelButton.isEnabled()); return this.isButtonEnabled(ContentNodeSelectorDialog.selectors.cancelButton);
} }
async searchFor(text: string): Promise<void> { async searchFor(text: string): Promise<void> {

88
e2e/components/dialog/create-edit-folder-dialog.ts
View File

@@ -23,72 +23,58 @@
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/ */
import { ElementFinder, by, browser, protractor, ExpectedConditions as EC } from 'protractor'; import { ElementFinder, by, protractor, browser, ExpectedConditions as EC } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs'; import { BROWSER_WAIT_TIMEOUT } from '../../configs';
import { Component } from '../component'; import { GenericDialog } from '../dialog/generic-dialog';
import { Utils } from '../../utilities/utils';
export class CreateOrEditFolderDialog extends Component { export class CreateOrEditFolderDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: 'adf-folder-dialog', root: 'adf-folder-dialog',
title: '.mat-dialog-title',
nameInput: 'input[placeholder="Name" i]', nameInput: 'input[placeholder="Name" i]',
descriptionTextArea: 'textarea[placeholder="Description" i]', descriptionTextArea: 'textarea[placeholder="Description" i]',
button: '.mat-dialog-actions button',
validationMessage: '.mat-hint span' validationMessage: '.mat-hint span',
createButton: by.cssContainingText('.mat-dialog-actions button', 'Create'),
cancelButton: by.id('adf-folder-cancel-button'),
updateButton: by.cssContainingText('.mat-dialog-actions button', 'Update')
}; };
title: ElementFinder = this.component.element(by.css(CreateOrEditFolderDialog.selectors.title)); nameInput: ElementFinder = this.rootElem.element(by.css(CreateOrEditFolderDialog.selectors.nameInput));
nameInput: ElementFinder = this.component.element(by.css(CreateOrEditFolderDialog.selectors.nameInput)); descriptionTextArea: ElementFinder = this.rootElem.element(by.css(CreateOrEditFolderDialog.selectors.descriptionTextArea));
descriptionTextArea: ElementFinder = this.component.element(by.css(CreateOrEditFolderDialog.selectors.descriptionTextArea)); validationMessage: ElementFinder = this.rootElem.element(by.css(CreateOrEditFolderDialog.selectors.validationMessage));
createButton: ElementFinder = this.component.element(by.cssContainingText(CreateOrEditFolderDialog.selectors.button, 'Create'));
cancelButton: ElementFinder = this.component.element(by.cssContainingText(CreateOrEditFolderDialog.selectors.button, 'Cancel'));
updateButton: ElementFinder = this.component.element(by.cssContainingText(CreateOrEditFolderDialog.selectors.button, 'Update'));
validationMessage: ElementFinder = this.component.element(by.css(CreateOrEditFolderDialog.selectors.validationMessage));
constructor(ancestor?: string) { constructor() {
super(CreateOrEditFolderDialog.selectors.root, ancestor); super(CreateOrEditFolderDialog.selectors.root);
} }
async waitForDialogToOpen() { async waitForDialogToOpen() {
await browser.wait(EC.presenceOf(this.title), BROWSER_WAIT_TIMEOUT); await super.waitForDialogToOpen();
await browser.wait(EC.presenceOf(browser.element(by.css('.cdk-overlay-backdrop'))), BROWSER_WAIT_TIMEOUT); await browser.wait(EC.elementToBeClickable(this.nameInput), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for input to be clickable ---');
}
async waitForDialogToClose() {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT, '---- timeout waiting for dialog to close ----');
}
async isDialogOpen() {
return browser.isElementPresent(by.css(CreateOrEditFolderDialog.selectors.root));
}
async getTitle() {
return this.title.getText();
} }
async isValidationMessageDisplayed(): Promise<boolean> { async isValidationMessageDisplayed(): Promise<boolean> {
return (await this.validationMessage.isPresent()) && (await this.validationMessage.isDisplayed()); return (await this.validationMessage.isPresent()) && (await this.validationMessage.isDisplayed());
} }
async isUpdateButtonEnabled() { async isUpdateButtonEnabled(): Promise<boolean> {
return this.updateButton.isEnabled(); return this.isButtonEnabled(CreateOrEditFolderDialog.selectors.updateButton);
} }
async isCreateButtonEnabled() { async isCreateButtonEnabled(): Promise<boolean> {
return this.createButton.isEnabled(); return this.isButtonEnabled(CreateOrEditFolderDialog.selectors.createButton);
} }
async isCancelButtonEnabled() { async isCancelButtonEnabled(): Promise<boolean> {
return this.cancelButton.isEnabled(); return this.isButtonEnabled(CreateOrEditFolderDialog.selectors.cancelButton);
} }
async isNameDisplayed() { async isNameDisplayed(): Promise<boolean> {
return this.nameInput.isDisplayed(); return this.nameInput.isDisplayed();
} }
async isDescriptionDisplayed() { async isDescriptionDisplayed(): Promise<boolean> {
return this.descriptionTextArea.isDisplayed(); return this.descriptionTextArea.isDisplayed();
} }
@@ -100,40 +86,40 @@ export class CreateOrEditFolderDialog extends Component {
} }
} }
async getName() { async getName(): Promise<string> {
return this.nameInput.getAttribute('value'); return this.nameInput.getAttribute('value');
} }
async getDescription() { async getDescription(): Promise<string> {
return this.descriptionTextArea.getAttribute('value'); return this.descriptionTextArea.getAttribute('value');
} }
async enterName(name: string) { async enterName(name: string): Promise<void> {
await this.nameInput.clear(); await this.nameInput.clear();
await Utils.typeInField(this.nameInput, name); await this.nameInput.sendKeys(name);
} }
async enterDescription(description: string) { async enterDescription(description: string): Promise<void> {
await this.descriptionTextArea.clear(); await this.descriptionTextArea.clear();
await Utils.typeInField(this.descriptionTextArea, description); await this.descriptionTextArea.sendKeys(description);
} }
async deleteNameWithBackspace() { async deleteNameWithBackspace(): Promise<void> {
await this.nameInput.clear(); await this.nameInput.clear();
await this.nameInput.sendKeys(' ', protractor.Key.CONTROL, 'a', protractor.Key.NULL, protractor.Key.BACK_SPACE); await this.nameInput.sendKeys(' ', protractor.Key.CONTROL, 'a', protractor.Key.NULL, protractor.Key.BACK_SPACE);
} }
async clickCreate() { async clickCreate(): Promise<void> {
await this.createButton.click(); await this.clickButton(CreateOrEditFolderDialog.selectors.createButton);
} }
async clickCancel() { async clickCancel(): Promise<void> {
await this.cancelButton.click(); await this.clickButton(CreateOrEditFolderDialog.selectors.cancelButton);
await this.waitForDialogToClose(); await this.waitForDialogToClose();
} }
async clickUpdate() { async clickUpdate(): Promise<void> {
await this.updateButton.click(); await this.clickButton(CreateOrEditFolderDialog.selectors.updateButton);
} }
} }

54
e2e/components/dialog/create-from-template-dialog.ts
View File

@@ -23,49 +23,29 @@
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/ */
import { ElementFinder, by, browser, protractor, ExpectedConditions as EC } from 'protractor'; import { ElementFinder, by, protractor } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs'; import { GenericDialog } from '../dialog/generic-dialog';
import { Component } from '../component';
export class CreateFromTemplateDialog extends Component { export class CreateFromTemplateDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: '.aca-create-from-template-dialog', root: '.aca-create-from-template-dialog',
title: '.mat-dialog-title',
nameInput: 'input[placeholder="Name" i]', nameInput: 'input[placeholder="Name" i]',
titleInput: 'input[placeholder="Title" i]', titleInput: 'input[placeholder="Title" i]',
descriptionTextArea: 'textarea[placeholder="Description" i]', descriptionTextArea: 'textarea[placeholder="Description" i]',
button: '.mat-dialog-actions button', validationMessage: '.mat-error',
validationMessage: '.mat-error'
createButton: by.cssContainingText('.mat-dialog-actions button', 'Create'),
cancelButton: by.cssContainingText('.mat-dialog-actions button', 'CANCEL')
}; };
title: ElementFinder = this.component.element(by.css(CreateFromTemplateDialog.selectors.title)); nameInput: ElementFinder = this.rootElem.element(by.css(CreateFromTemplateDialog.selectors.nameInput));
nameInput: ElementFinder = this.component.element(by.css(CreateFromTemplateDialog.selectors.nameInput)); titleInput: ElementFinder = this.rootElem.element(by.css(CreateFromTemplateDialog.selectors.titleInput));
titleInput: ElementFinder = this.component.element(by.css(CreateFromTemplateDialog.selectors.titleInput)); descriptionTextArea: ElementFinder = this.rootElem.element(by.css(CreateFromTemplateDialog.selectors.descriptionTextArea));
descriptionTextArea: ElementFinder = this.component.element(by.css(CreateFromTemplateDialog.selectors.descriptionTextArea)); validationMessage: ElementFinder = this.rootElem.element(by.css(CreateFromTemplateDialog.selectors.validationMessage));
createButton: ElementFinder = this.component.element(by.cssContainingText(CreateFromTemplateDialog.selectors.button, 'Create'));
cancelButton: ElementFinder = this.component.element(by.cssContainingText(CreateFromTemplateDialog.selectors.button, 'CANCEL'));
validationMessage: ElementFinder = this.component.element(by.css(CreateFromTemplateDialog.selectors.validationMessage));
constructor(ancestor?: string) { constructor() {
super(CreateFromTemplateDialog.selectors.root, ancestor); super(CreateFromTemplateDialog.selectors.root);
}
async waitForDialogToOpen(): Promise<void> {
await browser.wait(EC.presenceOf(this.title), BROWSER_WAIT_TIMEOUT, 'timeout waiting for dialog title');
await browser.wait(EC.presenceOf(browser.element(by.css('.cdk-overlay-backdrop'))), BROWSER_WAIT_TIMEOUT, 'timeout waiting for overlay backdrop');
}
async waitForDialogToClose(): Promise<void> {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT, '---- timeout waiting for dialog to close ----');
}
async isDialogOpen(): Promise<boolean> {
return browser.isElementPresent(by.css(CreateFromTemplateDialog.selectors.root));
}
async getTitle(): Promise<string> {
return this.title.getText();
} }
async isValidationMessageDisplayed(): Promise<boolean> { async isValidationMessageDisplayed(): Promise<boolean> {
@@ -73,11 +53,11 @@ export class CreateFromTemplateDialog extends Component {
} }
async isCreateButtonEnabled(): Promise<boolean> { async isCreateButtonEnabled(): Promise<boolean> {
return this.createButton.isEnabled(); return this.isButtonEnabled(CreateFromTemplateDialog.selectors.createButton);
} }
async isCancelButtonEnabled(): Promise<boolean> { async isCancelButtonEnabled(): Promise<boolean> {
return this.cancelButton.isEnabled(); return this.isButtonEnabled(CreateFromTemplateDialog.selectors.cancelButton);
} }
async isNameFieldDisplayed(): Promise<boolean> { async isNameFieldDisplayed(): Promise<boolean> {
@@ -129,11 +109,11 @@ export class CreateFromTemplateDialog extends Component {
} }
async clickCreate(): Promise<void> { async clickCreate(): Promise<void> {
await this.createButton.click(); await this.clickButton(CreateFromTemplateDialog.selectors.createButton);
} }
async clickCancel(): Promise<void> { async clickCancel(): Promise<void> {
await this.cancelButton.click(); await this.clickButton(CreateFromTemplateDialog.selectors.cancelButton);
await this.waitForDialogToClose(); await this.waitForDialogToClose();
} }

119
e2e/components/dialog/create-library-dialog.ts
View File

@@ -23,151 +23,140 @@
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/ */
import { ElementFinder, by, browser, protractor, ExpectedConditions as EC } from 'protractor'; import { ElementFinder, by, protractor, browser, ExpectedConditions as EC } from 'protractor';
import { GenericDialog } from '../dialog/generic-dialog';
import { BROWSER_WAIT_TIMEOUT } from '../../configs'; import { BROWSER_WAIT_TIMEOUT } from '../../configs';
import { Component } from '../component';
import { Utils } from '../../utilities/utils';
export class CreateLibraryDialog extends Component { export class CreateLibraryDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: 'adf-library-dialog', root: 'adf-library-dialog',
title: '.mat-dialog-title',
nameInput: 'input[placeholder="Name" i]', nameInput: 'input[placeholder="Name" i]',
libraryIdInput: 'input[placeholder="Library ID" i]', libraryIdInput: 'input[placeholder="Library ID" i]',
descriptionTextArea: 'textarea[placeholder="Description" i]', descriptionTextArea: 'textarea[placeholder="Description" i]',
button: '.mat-dialog-actions button',
radioButton: '.mat-radio-label', radioButton: '.mat-radio-label',
radioChecked: 'mat-radio-checked', radioChecked: 'mat-radio-checked',
errorMessage: '.mat-error' errorMessage: '.mat-error',
createButton: by.cssContainingText('.mat-dialog-actions button', 'Create'),
cancelButton: by.cssContainingText('.mat-dialog-actions button', 'Cancel')
}; };
title: ElementFinder = this.component.element(by.css(CreateLibraryDialog.selectors.title)); nameInput: ElementFinder = this.rootElem.element(by.css(CreateLibraryDialog.selectors.nameInput));
nameInput: ElementFinder = this.component.element(by.css(CreateLibraryDialog.selectors.nameInput)); libraryIdInput: ElementFinder = this.rootElem.element(by.css(CreateLibraryDialog.selectors.libraryIdInput));
libraryIdInput: ElementFinder = this.component.element(by.css(CreateLibraryDialog.selectors.libraryIdInput)); descriptionTextArea: ElementFinder = this.rootElem.element(by.css(CreateLibraryDialog.selectors.descriptionTextArea));
descriptionTextArea: ElementFinder = this.component.element(by.css(CreateLibraryDialog.selectors.descriptionTextArea)); visibilityPublic: ElementFinder = this.rootElem.element(by.cssContainingText(CreateLibraryDialog.selectors.radioButton, 'Public'));
visibilityPublic: ElementFinder = this.component.element(by.cssContainingText(CreateLibraryDialog.selectors.radioButton, 'Public')); visibilityModerated: ElementFinder = this.rootElem.element(by.cssContainingText(CreateLibraryDialog.selectors.radioButton, 'Moderated'));
visibilityModerated: ElementFinder = this.component.element(by.cssContainingText(CreateLibraryDialog.selectors.radioButton, 'Moderated')); visibilityPrivate: ElementFinder = this.rootElem.element(by.cssContainingText(CreateLibraryDialog.selectors.radioButton, 'Private'));
visibilityPrivate: ElementFinder = this.component.element(by.cssContainingText(CreateLibraryDialog.selectors.radioButton, 'Private'));
createButton: ElementFinder = this.component.element(by.cssContainingText(CreateLibraryDialog.selectors.button, 'Create'));
cancelButton: ElementFinder = this.component.element(by.cssContainingText(CreateLibraryDialog.selectors.button, 'Cancel'));
errorMessage: ElementFinder = this.component.element(by.css(CreateLibraryDialog.selectors.errorMessage));
constructor(ancestor?: string) { errorMessage: ElementFinder = this.rootElem.element(by.css(CreateLibraryDialog.selectors.errorMessage));
super(CreateLibraryDialog.selectors.root, ancestor);
constructor() {
super(CreateLibraryDialog.selectors.root);
} }
async waitForDialogToOpen() { async waitForDialogToOpen(): Promise<void> {
await browser.wait(EC.presenceOf(this.title), BROWSER_WAIT_TIMEOUT); await super.waitForDialogToOpen();
await browser.wait(EC.presenceOf(browser.element(by.css('.cdk-overlay-backdrop'))), BROWSER_WAIT_TIMEOUT); await browser.wait(EC.elementToBeClickable(this.nameInput), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for input to be clickable ---');
} }
async waitForDialogToClose() { async isErrorMessageDisplayed(): Promise<boolean> {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT);
}
async isDialogOpen() {
return browser.isElementPresent(by.css(CreateLibraryDialog.selectors.root));
}
async getTitle() {
return this.title.getText();
}
async isErrorMessageDisplayed() {
return this.errorMessage.isDisplayed(); return this.errorMessage.isDisplayed();
} }
async getErrorMessage() { async getErrorMessage(): Promise<string> {
await this.isErrorMessageDisplayed(); if (await this.isErrorMessageDisplayed()) {
return this.errorMessage.getText(); return this.errorMessage.getText();
}
return '';
} }
async isNameDisplayed() { async isNameDisplayed(): Promise<boolean> {
return this.nameInput.isDisplayed(); return this.nameInput.isDisplayed();
} }
async isLibraryIdDisplayed() { async isLibraryIdDisplayed(): Promise<boolean> {
return this.libraryIdInput.isDisplayed(); return this.libraryIdInput.isDisplayed();
} }
async isDescriptionDisplayed() { async isDescriptionDisplayed(): Promise<boolean> {
return this.descriptionTextArea.isDisplayed(); return this.descriptionTextArea.isDisplayed();
} }
async isPublicDisplayed() { async isPublicDisplayed(): Promise<boolean> {
return this.visibilityPublic.isDisplayed(); return this.visibilityPublic.isDisplayed();
} }
async isModeratedDisplayed() { async isModeratedDisplayed(): Promise<boolean> {
return this.visibilityModerated.isDisplayed(); return this.visibilityModerated.isDisplayed();
} }
async isPrivateDisplayed() { async isPrivateDisplayed(): Promise<boolean> {
return this.visibilityPrivate.isDisplayed(); return this.visibilityPrivate.isDisplayed();
} }
async enterName(name: string) { async enterName(name: string): Promise<void> {
await this.nameInput.clear(); await this.nameInput.clear();
await Utils.typeInField(this.nameInput, name); await this.nameInput.sendKeys(name);
} }
async enterLibraryId(id: string) { async enterLibraryId(id: string): Promise<void> {
await this.libraryIdInput.clear(); await this.libraryIdInput.clear();
await Utils.typeInField(this.libraryIdInput, id); await this.libraryIdInput.sendKeys(id);
} }
async enterDescription(description: string) { async enterDescription(description: string): Promise<void> {
await this.descriptionTextArea.clear(); await this.descriptionTextArea.clear();
await Utils.typeInField(this.descriptionTextArea, description); await this.descriptionTextArea.sendKeys(description);
} }
async deleteNameWithBackspace() { async deleteNameWithBackspace(): Promise<void> {
await this.nameInput.clear(); await this.nameInput.clear();
await this.nameInput.sendKeys(' ', protractor.Key.CONTROL, 'a', protractor.Key.NULL, protractor.Key.BACK_SPACE); await this.nameInput.sendKeys(' ', protractor.Key.CONTROL, 'a', protractor.Key.NULL, protractor.Key.BACK_SPACE);
} }
async isCreateEnabled() { async isCreateEnabled(): Promise<boolean> {
return this.createButton.isEnabled(); return this.isButtonEnabled(CreateLibraryDialog.selectors.createButton);
} }
async isCancelEnabled() { async isCancelEnabled(): Promise<boolean> {
return this.cancelButton.isEnabled(); return this.isButtonEnabled(CreateLibraryDialog.selectors.cancelButton);
} }
async clickCreate() { async clickCreate(): Promise<void> {
await this.createButton.click(); await this.clickButton(CreateLibraryDialog.selectors.createButton);
} }
async clickCancel() { async clickCancel(): Promise<void> {
await this.cancelButton.click(); await this.clickButton(CreateLibraryDialog.selectors.cancelButton);
await this.waitForDialogToClose(); await this.waitForDialogToClose();
} }
async isPublicChecked() { async isPublicChecked(): Promise<boolean> {
const elemClass = await this.visibilityPublic.element(by.xpath('..')).getAttribute('class'); const elemClass = await this.visibilityPublic.element(by.xpath('..')).getAttribute('class');
return elemClass.includes(CreateLibraryDialog.selectors.radioChecked); return elemClass.includes(CreateLibraryDialog.selectors.radioChecked);
} }
async isModeratedChecked() { async isModeratedChecked(): Promise<boolean> {
const elemClass = await this.visibilityModerated.element(by.xpath('..')).getAttribute('class'); const elemClass = await this.visibilityModerated.element(by.xpath('..')).getAttribute('class');
return elemClass.includes(CreateLibraryDialog.selectors.radioChecked); return elemClass.includes(CreateLibraryDialog.selectors.radioChecked);
} }
async isPrivateChecked() { async isPrivateChecked(): Promise<boolean> {
const elemClass = await this.visibilityPrivate.element(by.xpath('..')).getAttribute('class'); const elemClass = await this.visibilityPrivate.element(by.xpath('..')).getAttribute('class');
return elemClass.includes(CreateLibraryDialog.selectors.radioChecked); return elemClass.includes(CreateLibraryDialog.selectors.radioChecked);
} }
async selectPublic() { async selectPublic(): Promise<void> {
await this.visibilityPublic.click(); await this.visibilityPublic.click();
} }
async selectModerated() { async selectModerated(): Promise<void> {
await this.visibilityModerated.click(); await this.visibilityModerated.click();
} }
async selectPrivate() { async selectPrivate(): Promise<void> {
await this.visibilityPrivate.click(); await this.visibilityPrivate.click();
} }
} }

86
e2e/components/dialog/generic-dialog.ts Normal file
View File

@@ -0,0 +1,86 @@
/*!
* @license
* Alfresco Example Content Application
*
* Copyright (C) 2005 - 2020 Alfresco Software Limited
*
* This file is part of the Alfresco Example Content Application.
* If the software was purchased under a paid Alfresco license, the terms of
* the paid license agreement will prevail. Otherwise, the software is
* provided under the following open source license terms:
*
* The Alfresco Example Content Application is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* The Alfresco Example Content Application is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/
import { ElementFinder, by, browser, ExpectedConditions as EC, Locator } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs';
export abstract class GenericDialog {
private static locators = {
title: '.mat-dialog-title',
content: '.mat-dialog-content'
};
private rootCssSelector: string;
constructor(selector?: string) {
this.rootCssSelector = selector;
}
get rootElem(): ElementFinder {
return browser.element(by.css(this.rootCssSelector));
}
get title(): ElementFinder {
return this.rootElem.element(by.css(GenericDialog.locators.title));
}
get content(): ElementFinder {
return this.rootElem.element(by.css(GenericDialog.locators.content));
}
async getText(): Promise<string> {
return this.content.getText();
}
async waitForDialogToOpen(): Promise<void> {
await browser.wait(EC.presenceOf(this.rootElem), BROWSER_WAIT_TIMEOUT);
await browser.wait(EC.visibilityOf(this.content), BROWSER_WAIT_TIMEOUT);
await browser.wait(EC.presenceOf(browser.element(by.css('.cdk-overlay-backdrop'))), BROWSER_WAIT_TIMEOUT);
}
async waitForDialogToClose(): Promise<void> {
await browser.wait(EC.stalenessOf(this.content), BROWSER_WAIT_TIMEOUT, '---- timeout waiting for dialog to close ----');
}
async isDialogOpen(): Promise<boolean> {
return (await this.rootElem.isPresent()) && (await this.rootElem.isDisplayed());
}
async getTitle(): Promise<string> {
return this.title.getText();
}
getActionButton(selector: Locator): ElementFinder {
return this.rootElem.element(selector);
}
async isButtonEnabled(selector: Locator): Promise<boolean> {
return (await this.getActionButton(selector).isPresent()) && (await this.getActionButton(selector).isEnabled());
}
async clickButton(selector: Locator): Promise<void> {
await this.getActionButton(selector).click();
}
}

39
e2e/components/dialog/manage-versions-dialog.ts
View File

@@ -23,45 +23,22 @@
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/ */
import { ElementFinder, by, browser, ExpectedConditions as EC } from 'protractor'; import { by } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs'; import { GenericDialog } from '../dialog/generic-dialog';
import { Component } from '../component';
export class ManageVersionsDialog extends Component { export class ManageVersionsDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: '.aca-node-versions-dialog', root: '.aca-node-versions-dialog',
title: '.mat-dialog-title', closeButton: by.cssContainingText('.mat-button', 'Close')
content: '.mat-dialog-content',
button: '.mat-button'
}; };
title: ElementFinder = this.component.element(by.css(ManageVersionsDialog.selectors.title)); constructor() {
content: ElementFinder = this.component.element(by.css(ManageVersionsDialog.selectors.content)); super(ManageVersionsDialog.selectors.root);
closeButton: ElementFinder = this.component.element(by.cssContainingText(ManageVersionsDialog.selectors.button, 'Close'));
constructor(ancestor?: string) {
super(ManageVersionsDialog.selectors.root, ancestor);
} }
async waitForDialogToClose() { async clickClose(): Promise<void> {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT); await this.clickButton(ManageVersionsDialog.selectors.closeButton);
}
async isDialogOpen() {
return browser.$(ManageVersionsDialog.selectors.root).isDisplayed();
}
async getTitle() {
return this.title.getText();
}
async getText() {
return this.content.getText();
}
async clickClose() {
await this.closeButton.click();
await this.waitForDialogToClose(); await this.waitForDialogToClose();
} }
} }

74
e2e/components/dialog/password-dialog.ts
View File

@@ -23,71 +23,45 @@
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/ */
import { ElementFinder, by, browser, ExpectedConditions as EC, until } from 'protractor'; import { ElementFinder, by, browser, until } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs'; import { BROWSER_WAIT_TIMEOUT } from '../../configs';
import { Component } from '../component'; import { GenericDialog } from '../dialog/generic-dialog';
export class PasswordDialog extends Component { export class PasswordDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: 'adf-pdf-viewer-password-dialog', root: 'adf-pdf-viewer-password-dialog',
title: '.mat-dialog-title',
content: '.mat-dialog-content',
passwordInput: 'input[type="Password"]', passwordInput: 'input[type="Password"]',
actionButtons: '.mat-dialog-actions', errorMessage: '.mat-error',
errorMessage: '.mat-error'
closeButton: by.css('[data-automation-id="adf-password-dialog-close"]'),
submitButton: by.css('[data-automation-id="adf-password-dialog-submit"]')
}; };
title: ElementFinder = this.component.element(by.css(PasswordDialog.selectors.title)); passwordInput: ElementFinder = this.rootElem.element(by.css(PasswordDialog.selectors.passwordInput));
content: ElementFinder = this.component.element(by.css(PasswordDialog.selectors.content)); errorMessage: ElementFinder = this.rootElem.element(by.css(PasswordDialog.selectors.errorMessage));
passwordInput: ElementFinder = this.component.element(by.css(PasswordDialog.selectors.passwordInput));
errorMessage: ElementFinder = this.component.element(by.css(PasswordDialog.selectors.errorMessage));
closeButton: ElementFinder = this.component.element(by.buttonText('Close'));
submitButton: ElementFinder = this.component.element(by.buttonText('Submit'));
constructor(ancestor?: string) { constructor() {
super(PasswordDialog.selectors.root, ancestor); super(PasswordDialog.selectors.root);
} }
async waitForDialogToClose() { async isCloseEnabled(): Promise<boolean> {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT); return this.isButtonEnabled(PasswordDialog.selectors.closeButton);
} }
async waitForDialogToOpen() { async isSubmitEnabled(): Promise<boolean> {
await browser.wait(EC.presenceOf(this.title), BROWSER_WAIT_TIMEOUT); return this.isButtonEnabled(PasswordDialog.selectors.submitButton);
} }
async isDialogOpen() { async clickClose(): Promise<void> {
try { await this.clickButton(PasswordDialog.selectors.closeButton);
const dialog = await browser.wait(until.elementLocated(by.css(PasswordDialog.selectors.root)), BROWSER_WAIT_TIMEOUT, '------- timeout waiting for dialog')
return dialog.isDisplayed();
} catch (error) {
return false;
}
} }
async getTitle() { async clickSubmit(): Promise<void> {
return this.title.getText(); await this.clickButton(PasswordDialog.selectors.submitButton);
} }
async isCloseEnabled() { async isPasswordInputDisplayed(): Promise<boolean> {
return this.closeButton.isEnabled();
}
async isSubmitEnabled() {
return this.submitButton.isEnabled();
}
async clickClose() {
await this.closeButton.click();
}
async clickSubmit() {
await this.submitButton.click();
}
async isPasswordInputDisplayed() {
const present = await browser.isElementPresent(this.passwordInput); const present = await browser.isElementPresent(this.passwordInput);
if (present) { if (present) {
return this.passwordInput.isDisplayed(); return this.passwordInput.isDisplayed();
@@ -96,19 +70,19 @@ export class PasswordDialog extends Component {
} }
} }
async isErrorDisplayed() { async isErrorDisplayed(): Promise<boolean> {
const elem = await browser.wait(until.elementLocated(by.css(PasswordDialog.selectors.errorMessage)), BROWSER_WAIT_TIMEOUT, '------- timeout waiting for error message to appear') const elem = await browser.wait(until.elementLocated(by.css(PasswordDialog.selectors.errorMessage)), BROWSER_WAIT_TIMEOUT, '------- timeout waiting for error message to appear')
return browser.isElementPresent(elem); return (await browser.isElementPresent(elem)) && (await elem.isDisplayed());
} }
async getErrorMessage() { async getErrorMessage(): Promise<string> {
if (await this.isErrorDisplayed()) { if (await this.isErrorDisplayed()) {
return this.errorMessage.getText(); return this.errorMessage.getText();
} }
return ''; return '';
} }
async enterPassword(password: string) { async enterPassword(password: string): Promise<void> {
await this.passwordInput.clear(); await this.passwordInput.clear();
await this.passwordInput.sendKeys(password); await this.passwordInput.sendKeys(password);
} }

47
e2e/components/dialog/select-template-dialog.ts
View File

@@ -23,64 +23,41 @@
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/ */
import { ElementFinder, by, browser, ExpectedConditions as EC } from 'protractor'; import { by } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs'; import { GenericDialog } from '../dialog/generic-dialog';
import { Component } from '../component';
import { DropDownBreadcrumb } from '../breadcrumb/dropdown-breadcrumb'; import { DropDownBreadcrumb } from '../breadcrumb/dropdown-breadcrumb';
import { DataTable } from '../data-table/data-table'; import { DataTable } from '../data-table/data-table';
export class SelectTemplateDialog extends Component { export class SelectTemplateDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: '.aca-template-node-selector-dialog', root: '.aca-template-node-selector-dialog',
title: '.mat-dialog-title',
button: '.mat-dialog-actions button'
};
title: ElementFinder = this.component.element(by.css(SelectTemplateDialog.selectors.title)); nextButton: by.css('[data-automation-id="content-node-selector-actions-choose"]'),
nextButton: ElementFinder = this.component.element(by.cssContainingText(SelectTemplateDialog.selectors.button, 'Next')); cancelButton: by.css('[data-automation-id="content-node-selector-actions-cancel"]')
cancelButton: ElementFinder = this.component.element(by.cssContainingText(SelectTemplateDialog.selectors.button, 'Cancel')); };
breadcrumb: DropDownBreadcrumb = new DropDownBreadcrumb(); breadcrumb: DropDownBreadcrumb = new DropDownBreadcrumb();
dataTable: DataTable = new DataTable(SelectTemplateDialog.selectors.root); dataTable: DataTable = new DataTable(SelectTemplateDialog.selectors.root);
constructor(ancestor?: string) { constructor() {
super(SelectTemplateDialog.selectors.root, ancestor); super(SelectTemplateDialog.selectors.root);
} }
async waitForDialogToOpen(): Promise<void> {
await browser.wait(EC.presenceOf(this.title), BROWSER_WAIT_TIMEOUT, 'timeout waiting for dialog title');
await browser.wait(EC.presenceOf(browser.element(by.css('.cdk-overlay-backdrop'))), BROWSER_WAIT_TIMEOUT, 'timeout waiting for overlay backdrop');
}
async waitForDialogToClose(): Promise<void> {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT, '---- timeout waiting for dialog to close ----');
}
async isDialogOpen(): Promise<boolean> {
return browser.isElementPresent(by.css(SelectTemplateDialog.selectors.root));
}
async getTitle(): Promise<string> {
return this.title.getText();
}
// action buttons
async isCancelButtonEnabled(): Promise<boolean> { async isCancelButtonEnabled(): Promise<boolean> {
return this.cancelButton.isEnabled(); return this.isButtonEnabled(SelectTemplateDialog.selectors.cancelButton);
} }
async isNextButtonEnabled(): Promise<boolean> { async isNextButtonEnabled(): Promise<boolean> {
return this.nextButton.isEnabled(); return this.isButtonEnabled(SelectTemplateDialog.selectors.nextButton);
} }
async clickCancel(): Promise<void> { async clickCancel(): Promise<void> {
await this.cancelButton.click(); await this.clickButton(SelectTemplateDialog.selectors.cancelButton);
await this.waitForDialogToClose(); await this.waitForDialogToClose();
} }
async clickNext(): Promise<void> { async clickNext(): Promise<void> {
await this.nextButton.click(); await this.clickButton(SelectTemplateDialog.selectors.nextButton);
await this.waitForDialogToClose(); await this.waitForDialogToClose();
} }
} }

95
e2e/components/dialog/share-dialog.ts
View File

@@ -23,16 +23,15 @@
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/ */
import { ElementFinder, ElementArrayFinder, by, browser, ExpectedConditions as EC } from 'protractor'; import { ElementFinder, ElementArrayFinder, by } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs';
import { DateTimePicker } from '../../components/datetime-picker/datetime-picker'; import { DateTimePicker } from '../../components/datetime-picker/datetime-picker';
import { Component } from '../component'; import { GenericDialog } from '../dialog/generic-dialog';
export class ShareDialog extends Component { export class ShareDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: '.adf-share-dialog', root: '.adf-share-dialog',
title: `[data-automation-id='adf-share-dialog-title']`, dialogTitle: `[data-automation-id='adf-share-dialog-title']`,
info: '.adf-share-link__info', info: '.adf-share-link__info',
label: '.adf-share-link__label', label: '.adf-share-link__label',
shareToggle: `[data-automation-id='adf-share-toggle']`, shareToggle: `[data-automation-id='adf-share-toggle']`,
@@ -41,118 +40,106 @@ export class ShareDialog extends Component {
expireToggle: `[data-automation-id='adf-expire-toggle']`, expireToggle: `[data-automation-id='adf-expire-toggle']`,
datetimePickerButton: '.mat-datetimepicker-toggle', datetimePickerButton: '.mat-datetimepicker-toggle',
expirationInput: 'input[formcontrolname="time"]', expirationInput: 'input[formcontrolname="time"]',
button: `[data-automation-id='adf-share-dialog-close']`
closeButton: by.css(`[data-automation-id='adf-share-dialog-close']`)
}; };
dateTimePicker = new DateTimePicker(); dateTimePicker = new DateTimePicker();
title: ElementFinder = this.component.element(by.css(ShareDialog.selectors.title)); dialogTitle: ElementFinder = this.rootElem.element(by.css(ShareDialog.selectors.dialogTitle));
infoText: ElementFinder = this.component.element(by.css(ShareDialog.selectors.info)); infoText: ElementFinder = this.rootElem.element(by.css(ShareDialog.selectors.info));
labels: ElementArrayFinder = this.component.all(by.css(ShareDialog.selectors.label)); labels: ElementArrayFinder = this.rootElem.all(by.css(ShareDialog.selectors.label));
shareToggle: ElementFinder = this.component.element(by.css(ShareDialog.selectors.shareToggle)); shareToggle: ElementFinder = this.rootElem.element(by.css(ShareDialog.selectors.shareToggle));
url: ElementFinder = this.component.element(by.css(ShareDialog.selectors.linkUrl)); url: ElementFinder = this.rootElem.element(by.css(ShareDialog.selectors.linkUrl));
urlAction: ElementFinder = this.component.element(by.css(ShareDialog.selectors.inputAction)); urlAction: ElementFinder = this.rootElem.element(by.css(ShareDialog.selectors.inputAction));
expireToggle: ElementFinder = this.component.element(by.css(ShareDialog.selectors.expireToggle)); expireToggle: ElementFinder = this.rootElem.element(by.css(ShareDialog.selectors.expireToggle));
expireInput: ElementFinder = this.component.element(by.css(ShareDialog.selectors.expirationInput)); expireInput: ElementFinder = this.rootElem.element(by.css(ShareDialog.selectors.expirationInput));
datetimePickerButton: ElementFinder = this.component.element(by.css(ShareDialog.selectors.datetimePickerButton)); datetimePickerButton: ElementFinder = this.rootElem.element(by.css(ShareDialog.selectors.datetimePickerButton));
closeButton: ElementFinder = this.component.element(by.css(ShareDialog.selectors.button));
constructor() {
constructor(ancestor?: string) { super(ShareDialog.selectors.root);
super(ShareDialog.selectors.root, ancestor);
} }
async waitForDialogToClose() { async getTitle(): Promise<string> {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT, 'share dialog did not close'); return this.dialogTitle.getText();
} }
async waitForDialogToOpen() { async getInfoText(): Promise<string> {
await browser.wait(EC.presenceOf(this.title), BROWSER_WAIT_TIMEOUT);
}
async isDialogOpen() {
return browser.isElementPresent(by.css(ShareDialog.selectors.root));
}
async getTitle() {
return this.title.getText();
}
async getInfoText() {
return this.infoText.getText(); return this.infoText.getText();
} }
getLabels() { getLabels(): ElementArrayFinder {
return this.labels; return this.labels;
} }
async getLinkUrl() { async getLinkUrl(): Promise<string> {
return this.url.getAttribute('value'); return this.url.getAttribute('value');
} }
async isUrlReadOnly() { async isUrlReadOnly(): Promise<boolean> {
return this.url.getAttribute('readonly'); const urlAttr = await this.url.getAttribute('readonly');
return urlAttr === 'true';
} }
async isCloseEnabled() { async isCloseEnabled(): Promise<boolean> {
return this.closeButton.isEnabled(); return this.isButtonEnabled(ShareDialog.selectors.closeButton);
} }
async clickClose() { async clickClose(): Promise<void> {
await this.closeButton.click(); await this.clickButton(ShareDialog.selectors.closeButton);
await this.waitForDialogToClose(); await this.waitForDialogToClose();
} }
getShareToggle() { getShareToggle(): ElementFinder {
return this.shareToggle; return this.shareToggle;
} }
getExpireToggle() { getExpireToggle(): ElementFinder {
return this.expireToggle; return this.expireToggle;
} }
getExpireInput() { getExpireInput(): ElementFinder {
return this.expireInput; return this.expireInput;
} }
async isShareToggleChecked() { async isShareToggleChecked(): Promise<boolean> {
const toggleClass = await this.getShareToggle().getAttribute('class'); const toggleClass = await this.getShareToggle().getAttribute('class');
return toggleClass.includes('checked'); return toggleClass.includes('checked');
} }
async isShareToggleDisabled() { async isShareToggleDisabled(): Promise<boolean> {
const toggleClass = await this.getShareToggle().getAttribute('class'); const toggleClass = await this.getShareToggle().getAttribute('class');
return toggleClass.includes('mat-disabled'); return toggleClass.includes('mat-disabled');
} }
async isExpireToggleEnabled() { async isExpireToggleEnabled(): Promise<boolean> {
const toggleClass = await this.getExpireToggle().getAttribute('class'); const toggleClass = await this.getExpireToggle().getAttribute('class');
return toggleClass.includes('checked'); return toggleClass.includes('checked');
} }
async copyUrl() { async copyUrl(): Promise<void> {
await this.urlAction.click(); await this.urlAction.click();
} }
async openDatetimePicker() { async openDatetimePicker(): Promise<void> {
await this.datetimePickerButton.click(); await this.datetimePickerButton.click();
} }
async closeDatetimePicker() { async closeDatetimePicker(): Promise<void> {
if (await this.dateTimePicker.isCalendarOpen()) { if (await this.dateTimePicker.isCalendarOpen()) {
await this.datetimePickerButton.click(); await this.datetimePickerButton.click();
} }
} }
async getExpireDate() { async getExpireDate(): Promise<string> {
return this.getExpireInput().getAttribute('value'); return this.getExpireInput().getAttribute('value');
} }
async clickExpirationToggle() { async clickExpirationToggle(): Promise<void> {
await this.expireToggle.click(); await this.expireToggle.click();
} }
async clickShareToggle() { async clickShareToggle(): Promise<void> {
await this.shareToggle.click(); await this.shareToggle.click();
} }
} }

77
e2e/components/dialog/upload-new-version-dialog.ts
View File

@@ -23,98 +23,71 @@
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>. * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
*/ */
import { ElementFinder, by, browser, ExpectedConditions as EC } from 'protractor'; import { ElementFinder, by } from 'protractor';
import { BROWSER_WAIT_TIMEOUT } from '../../configs'; import { GenericDialog } from '../dialog/generic-dialog';
import { Component } from '../component';
import { Utils } from '../../utilities/utils';
export class UploadNewVersionDialog extends Component { export class UploadNewVersionDialog extends GenericDialog {
private static selectors = { private static selectors = {
root: '.aca-node-version-upload-dialog', root: '.aca-node-version-upload-dialog',
title: '.mat-dialog-title', cancelButton: by.cssContainingText('.mat-button', 'Cancel'),
content: '.mat-dialog-content', uploadButton: by.cssContainingText('.mat-button', 'Upload'),
button: '.mat-button',
radioButton: `.mat-radio-label`, radioButton: `.mat-radio-label`,
descriptionTextArea: 'textarea' descriptionTextArea: 'textarea'
}; };
title: ElementFinder = this.component.element(by.css(UploadNewVersionDialog.selectors.title));
content: ElementFinder = this.component.element(by.css(UploadNewVersionDialog.selectors.content));
cancelButton: ElementFinder = this.component.element(by.cssContainingText(UploadNewVersionDialog.selectors.button, 'Cancel'));
uploadButton: ElementFinder = this.component.element(by.cssContainingText(UploadNewVersionDialog.selectors.button, 'Upload'));
majorOption: ElementFinder = this.component.element(by.cssContainingText(UploadNewVersionDialog.selectors.radioButton, 'Major')); majorOption: ElementFinder = this.rootElem.element(by.cssContainingText(UploadNewVersionDialog.selectors.radioButton, 'Major'));
minorOption: ElementFinder = this.component.element(by.cssContainingText(UploadNewVersionDialog.selectors.radioButton, 'Minor')); minorOption: ElementFinder = this.rootElem.element(by.cssContainingText(UploadNewVersionDialog.selectors.radioButton, 'Minor'));
description: ElementFinder = this.component.element(by.css(UploadNewVersionDialog.selectors.descriptionTextArea)); description: ElementFinder = this.rootElem.element(by.css(UploadNewVersionDialog.selectors.descriptionTextArea));
constructor(ancestor?: string) { constructor() {
super(UploadNewVersionDialog.selectors.root, ancestor); super(UploadNewVersionDialog.selectors.root);
} }
async waitForDialogToClose() { async isDescriptionDisplayed(): Promise<boolean> {
await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT);
}
async isDialogOpen() {
return browser.$(UploadNewVersionDialog.selectors.root).isDisplayed();
}
async getTitle() {
return this.title.getText();
}
async getText() {
return this.content.getText();
}
async isDescriptionDisplayed() {
return this.description.isDisplayed(); return this.description.isDisplayed();
} }
async isMinorOptionDisplayed() { async isMinorOptionDisplayed(): Promise<boolean> {
return this.minorOption.isDisplayed(); return this.minorOption.isDisplayed();
} }
async isMajorOptionDisplayed() { async isMajorOptionDisplayed(): Promise<boolean> {
return this.majorOption.isDisplayed(); return this.majorOption.isDisplayed();
} }
async isCancelButtonEnabled() { async isCancelButtonEnabled(): Promise<boolean> {
return this.cancelButton.isEnabled(); return this.isButtonEnabled(UploadNewVersionDialog.selectors.cancelButton);
} }
async isUploadButtonEnabled() { async isUploadButtonEnabled(): Promise<boolean> {
return this.uploadButton.isEnabled(); return this.isButtonEnabled(UploadNewVersionDialog.selectors.uploadButton);
} }
async clickCancel(): Promise<void> {
async clickCancel() { await this.clickButton(UploadNewVersionDialog.selectors.cancelButton);
await this.cancelButton.click();
await this.waitForDialogToClose(); await this.waitForDialogToClose();
} }
async clickUpload() { async clickUpload(): Promise<void> {
await this.uploadButton.click(); await this.clickButton(UploadNewVersionDialog.selectors.uploadButton);
} }
async clickMajor(): Promise<void> {
async clickMajor() {
await this.majorOption.click(); await this.majorOption.click();
} }
async clickMinor() { async clickMinor(): Promise<void> {
await this.minorOption.click(); await this.minorOption.click();
} }
async enterDescription(description: string): Promise<void> {
async enterDescription(description: string) {
await this.description.clear(); await this.description.clear();
await Utils.typeInField(this.description, description); await this.description.sendKeys(description);
} }
} }

12
e2e/suites/actions/share-file.test.ts
View File

@@ -159,7 +159,7 @@ describe('Share a file', () => {
expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.'); expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.');
expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share'); expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share');
expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl); expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl);
expect(await shareDialog.isUrlReadOnly()).toBe('true', 'url is not readonly'); expect(await shareDialog.isUrlReadOnly()).toBe(true, 'url is not readonly');
expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked'); expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked');
expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on'); expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on');
expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked'); expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked');
@@ -339,7 +339,7 @@ describe('Share a file', () => {
expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.'); expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.');
expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share'); expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share');
expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl); expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl);
expect(await shareDialog.isUrlReadOnly()).toBe('true', 'url is not readonly'); expect(await shareDialog.isUrlReadOnly()).toBe(true, 'url is not readonly');
expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked'); expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked');
expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on'); expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on');
expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked'); expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked');
@@ -516,7 +516,7 @@ describe('Share a file', () => {
expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.'); expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.');
expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share'); expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share');
expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl); expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl);
expect(await shareDialog.isUrlReadOnly()).toBe('true', 'url is not readonly'); expect(await shareDialog.isUrlReadOnly()).toBe(true, 'url is not readonly');
expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked'); expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked');
expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on'); expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on');
expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked'); expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked');
@@ -695,7 +695,7 @@ describe('Share a file', () => {
expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.'); expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.');
expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share'); expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share');
expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl); expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl);
expect(await shareDialog.isUrlReadOnly()).toBe('true', 'url is not readonly'); expect(await shareDialog.isUrlReadOnly()).toBe(true, 'url is not readonly');
expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked'); expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked');
expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on'); expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on');
expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked'); expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked');
@@ -783,7 +783,7 @@ describe('Share a file', () => {
expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.'); expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.');
expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share'); expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share');
expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl); expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl);
expect(await shareDialog.isUrlReadOnly()).toBe('true', 'url is not readonly'); expect(await shareDialog.isUrlReadOnly()).toBe(true, 'url is not readonly');
expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked'); expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked');
expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on'); expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on');
expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked'); expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked');
@@ -855,7 +855,7 @@ describe('Share a file', () => {
expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.'); expect(await shareDialog.getInfoText()).toEqual('Click the link below to copy it to the clipboard.');
expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share'); expect(await shareDialog.getLabels().get(0).getText()).toEqual('Link to share');
expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl); expect(await shareDialog.getLinkUrl()).toContain(shareLinkPreUrl);
expect(await shareDialog.isUrlReadOnly()).toBe('true', 'url is not readonly'); expect(await shareDialog.isUrlReadOnly()).toBe(true, 'url is not readonly');
expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked'); expect(await shareDialog.isShareToggleChecked()).toBe(true, 'Share toggle not checked');
expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on'); expect(await shareDialog.getLabels().get(1).getText()).toEqual('Expires on');
expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked'); expect(await shareDialog.isExpireToggleEnabled()).toBe(false, 'Expire toggle is checked');