inteligr8/alfresco-content-app
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-content-app.git synced 2025-05-12 17:04:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

[ACA-2160] add tests for Edit offline actions availability (#921)

Browse Source 
* add tests for Edit offline actions availability

* fix delete / undo delete tests
This commit is contained in:
Adina Parpalita 2019-02-07 21:45:24 +02:00 committed by Denys Vuika
parent 5cc4f8ec55
commit 819f6ddced
17 changed files with 2831 additions and 875 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
e2e/components/menu/menu.ts
View File

@ -37,7 +37,9 @@ export class Menu extends Component {
submenu: 'app-context-menu-item .mat-menu-item',
editFolder: `app.context.menu.editFolder`
editFolder: `app.context.menu.editFolder`,
editOffline: `.mat-menu-item[title='Edit offline']`,
cancelEditing: `.mat-menu-item[title='Cancel editing']`
};
items: ElementArrayFinder = this.component.all(by.css(Menu.selectors.item));
@ -45,27 +47,29 @@ export class Menu extends Component {
uploadFiles: ElementFinder = browser.element(by.id(Menu.selectors.uploadFiles));
submenus: ElementArrayFinder = browser.element.all(by.css(Menu.selectors.submenu));
shareAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Share'));
shareEditAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Shared link settings'));
viewAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'View'));
downloadAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Download'));
editAction: ElementFinder = this.component.element(by.id(Menu.selectors.editFolder));
copyAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Copy'));
moveAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Move'));
deleteAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Delete'));
managePermissionsAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Permissions'));
manageVersionsAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Manage Versions'));
favoriteAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Favorite'));
leaveAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Leave'));
joinAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Join'));
cancelEditingAction: ElementFinder = this.component.element(by.css(Menu.selectors.cancelEditing));
cancelJoinAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Cancel join'));
permanentDeleteAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Permanently delete'));
restoreAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Restore'));
viewDetailsAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'View details'));
copyAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Copy'));
createFolderAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Create folder'));
createLibraryAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Create Library'));
deleteAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Delete'));
downloadAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Download'));
editFolderAction: ElementFinder = this.component.element(by.id(Menu.selectors.editFolder));
editOfflineAction: ElementFinder = this.component.element(by.css(Menu.selectors.editOffline));
favoriteAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Favorite'));
joinAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Join'));
leaveAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Leave'));
managePermissionsAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Permissions'));
manageVersionsAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Manage Versions'));
moveAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Move'));
permanentDeleteAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Permanently delete'));
restoreAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Restore'));
shareAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Share'));
shareEditAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Shared link settings'));
uploadFileAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Upload file'));
uploadFolderAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'Upload folder'));
viewAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'View'));
viewDetailsAction: ElementFinder = this.component.element(by.cssContainingText(Menu.selectors.item, 'View details'));
constructor(ancestor?: ElementFinder) {
super(Menu.selectors.root, ancestor);
@ -212,8 +216,16 @@ export class Menu extends Component {
return await this.downloadAction.isPresent();
}
async isEditPresent() {
return await this.editAction.isPresent();
async isEditFolderPresent() {
return await this.editFolderAction.isPresent();
}
async isEditOfflinePresent() {
return await this.editOfflineAction.isPresent();
}
async isCancelEditingPresent() {
return await this.cancelEditingAction.isPresent();
}
async isCopyPresent() {

3
e2e/components/search/search-input.ts
View File

@ -74,14 +74,17 @@ export class SearchInput extends Component {
}
async clickFilesOption() {
await browser.wait(EC.elementToBeClickable(this.searchFilesOption), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for Files to be clickable');
return await this.searchFilesOption.click();
}
async clickFoldersOption() {
await browser.wait(EC.elementToBeClickable(this.searchFoldersOption), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for Folders to be clickable');
return await this.searchFoldersOption.click();
}
async clickLibrariesOption() {
await browser.wait(EC.elementToBeClickable(this.searchLibrariesOption), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for Libraries to be clickable');
return await this.searchLibrariesOption.click();
}

39
e2e/components/toolbar/toolbar.ts
View File

@ -37,7 +37,7 @@ export class Toolbar extends Component {
shareEdit: `.mat-icon-button[title='Shared link settings']`,
view: `.mat-icon-button[title='View']`,
download: `.mat-icon-button[title='Download']`,
edit: `.mat-icon-button[title='Edit']`,
editFolder: 'app.toolbar.editFolder',
viewDetails: `.mat-icon-button[title='View details']`,
print: `.mat-icon-button[title='Print']`,
fullScreen: `.mat-icon-button[title='Activate full-screen mode']`,
@ -53,7 +53,7 @@ export class Toolbar extends Component {
shareEditButton: ElementFinder = this.component.element(by.css(Toolbar.selectors.shareEdit));
viewButton: ElementFinder = this.component.element(by.css(Toolbar.selectors.view));
downloadButton: ElementFinder = this.component.element(by.css(Toolbar.selectors.download));
editButton: ElementFinder = this.component.element(by.css(Toolbar.selectors.edit));
editFolderButton: ElementFinder = this.component.element(by.id(Toolbar.selectors.editFolder));
viewDetailsButton: ElementFinder = this.component.element(by.css(Toolbar.selectors.viewDetails));
printButton: ElementFinder = this.component.element(by.css(Toolbar.selectors.print));
fullScreenButton: ElementFinder = this.component.element(by.css(Toolbar.selectors.fullScreen));
@ -108,15 +108,6 @@ export class Toolbar extends Component {
await btn.click();
}
async clickShare() {
const btn = this.shareButton;
await btn.click();
}
async clickSharedLinkSettings() {
const btn = this.shareEditButton;
await btn.click();
}
async isSharedLinkSettingsPresent() {
return await browser.isElementPresent(this.shareEditButton);
@ -134,8 +125,16 @@ export class Toolbar extends Component {
return await browser.isElementPresent(this.downloadButton);
}
async isEditPresent() {
return await browser.isElementPresent(this.editButton);
async isPermanentlyDeletePresent() {
return await browser.isElementPresent(this.permanentlyDeleteButton);
}
async isRestorePresent() {
return await browser.isElementPresent(this.restoreButton);
}
async isEditFolderPresent() {
return await browser.isElementPresent(this.editFolderButton);
}
async isViewDetailsPresent() {
@ -151,12 +150,22 @@ export class Toolbar extends Component {
}
async clickShare() {
const btn = this.shareButton;
await btn.click();
}
async clickSharedLinkSettings() {
const btn = this.shareEditButton;
await btn.click();
}
async clickView() {
return await this.viewButton.click();
}
async clickEdit() {
return await this.editButton.click();
async clickEditFolder() {
return await this.editFolderButton.click();
}
async clickViewDetails() {

280
e2e/suites/actions/context-menu-multiple-selection.test.ts
View File

@ -31,8 +31,12 @@ import { Utils } from '../../utilities/utils';
describe('Context menu actions - multiple selection : ', () => {
const username = `user-${Utils.random()}`;
const parent = `parent=${Utils.random()}`; let parentId;
const file1 = `my-file1-${Utils.random()}.txt`; let file1Id;
const file2 = `my-file2-${Utils.random()}.txt`; let file2Id;
const fileLocked1 = `my-fileLocked1-${Utils.random()}.txt`; let fileLocked1Id;
const fileLocked2 = `my-fileLocked2-${Utils.random()}.txt`; let fileLocked2Id;
const folder1 = `my-folder1-${Utils.random()}`; let folder1Id;
const folder2 = `my-folder2-${Utils.random()}`; let folder2Id;
@ -45,6 +49,8 @@ describe('Context menu actions - multiple selection : ', () => {
const siteName = `site-${Utils.random()}`;
const file1Site = `my-inSite-file1-${Utils.random()}.txt`;
const file2Site = `my-inSite-file2-${Utils.random()}.txt`;
const fileLocked1Site = `my-inSite-fileLocked1-${Utils.random()}.txt`; let fileLocked1SiteId;
const fileLocked2Site = `my-inSite-fileLocked2-${Utils.random()}.txt`; let fileLocked2SiteId;
const folder1Site = `my-inSite-folder1-${Utils.random()}`;
const folder2Site = `my-inSite-folder2-${Utils.random()}`;
@ -62,10 +68,17 @@ describe('Context menu actions - multiple selection : ', () => {
beforeAll(async (done) => {
await apis.admin.people.createUser({ username });
file1Id = (await apis.user.nodes.createFile(file1)).entry.id;
file2Id = (await apis.user.nodes.createFile(file2)).entry.id;
folder1Id = (await apis.user.nodes.createFolder(folder1)).entry.id;
folder2Id = (await apis.user.nodes.createFolder(folder2)).entry.id;
parentId = (await apis.user.nodes.createFolder(parent)).entry.id;
file1Id = (await apis.user.nodes.createFile(file1, parentId)).entry.id;
file2Id = (await apis.user.nodes.createFile(file2, parentId)).entry.id;
folder1Id = (await apis.user.nodes.createFolder(folder1, parentId)).entry.id;
folder2Id = (await apis.user.nodes.createFolder(folder2, parentId)).entry.id;
fileLocked1Id = (await apis.user.nodes.createFile(fileLocked1, parentId)).entry.id;
fileLocked2Id = (await apis.user.nodes.createFile(fileLocked2, parentId)).entry.id;
await apis.user.nodes.lockFile(fileLocked1Id);
await apis.user.nodes.lockFile(fileLocked2Id);
await apis.user.sites.createSite(siteName, SITE_VISIBILITY.PUBLIC);
const docLibId = await apis.user.sites.getDocLibId(siteName);
@ -73,13 +86,17 @@ describe('Context menu actions - multiple selection : ', () => {
await apis.user.nodes.createFile(file2Site, docLibId);
await apis.user.nodes.createFolder(folder1Site, docLibId);
await apis.user.nodes.createFolder(folder2Site, docLibId);
fileLocked1SiteId = (await apis.user.nodes.createFile(fileLocked1Site, docLibId)).entry.id;
fileLocked2SiteId = (await apis.user.nodes.createFile(fileLocked2Site, docLibId)).entry.id;
await apis.user.nodes.lockFile(fileLocked1SiteId);
await apis.user.nodes.lockFile(fileLocked2SiteId);
await apis.user.shared.shareFilesByIds([ file1Id, file2Id ]);
await apis.user.shared.waitForApi({ expect: 2 });
await apis.user.shared.shareFilesByIds([ file1Id, file2Id, fileLocked1Id, fileLocked2Id ]);
await apis.user.shared.waitForApi({ expect: 4 });
await apis.user.favorites.addFavoritesByIds('file', [ file1Id, file2Id ]);
await apis.user.favorites.addFavoritesByIds('file', [ file1Id, file2Id, fileLocked1Id, fileLocked2Id ]);
await apis.user.favorites.addFavoritesByIds('folder', [ folder1Id, folder2Id ]);
await apis.user.favorites.waitForApi({ expect: 4 + 1 });
await apis.user.favorites.waitForApi({ expect: 6 + 1 });
fileInTrash1Id = (await apis.user.nodes.createFile(fileInTrash1)).entry.id;
fileInTrash2Id = (await apis.user.nodes.createFile(fileInTrash2)).entry.id;
@ -92,7 +109,7 @@ describe('Context menu actions - multiple selection : ', () => {
});
afterAll(async (done) => {
await apis.user.nodes.deleteNodesById([ file1Id, file2Id, folder1Id, folder2Id ]);
await apis.user.nodes.deleteNodeById(parentId);
await apis.user.sites.deleteSite(siteName);
await apis.user.trashcan.emptyTrash();
done();
@ -102,7 +119,12 @@ describe('Context menu actions - multiple selection : ', () => {
beforeEach(async (done) => {
await Utils.pressEscape();
await page.clickPersonalFilesAndWait();
await dataTable.clearSelection();
await dataTable.doubleClickOnRowByName(parent);
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
@ -119,7 +141,7 @@ describe('Context menu actions - multiple selection : ', () => {
expect(await dataTable.hasContextMenu()).toBe(true, `Context menu is not displayed for ${file1}`);
expect(await dataTable.countSelectedRows()).toEqual(1, 'incorrect number of selected rows');
expect(await contextMenu.isEditPresent()).toBe(false, `Edit is displayed for ${file1}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${file1}`);
expect(await dataTable.hasCheckMarkIcon(file1)).toBe(true, `${file1} is not selected`);
expect(await dataTable.hasCheckMarkIcon(file2)).toBe(false, `${file2} is selected`);
expect(await dataTable.hasCheckMarkIcon(folder1)).toBe(false, `${folder1} is selected`);
@ -130,7 +152,13 @@ describe('Context menu actions - multiple selection : ', () => {
beforeEach(async (done) => {
await Utils.pressEscape();
await page.clickPersonalFilesAndWait();
await dataTable.clearSelection();
await dataTable.doubleClickOnRowByName(parent);
await dataTable.waitForBody();
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
@ -138,41 +166,62 @@ describe('Context menu actions - multiple selection : ', () => {
await dataTable.selectMultipleItems([file1, file2]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([fileLocked1, fileLocked2]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple folders are selected - [C280632]', async () => {
await dataTable.selectMultipleItems([folder1, folder2]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when both files and folders are selected - [C280631]', async () => {
await dataTable.selectMultipleItems([file1, file2, folder1, folder2]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
});
@ -185,46 +234,73 @@ describe('Context menu actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C280641]', async () => {
await dataTable.selectMultipleItems([ file1Site, file2Site ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([ fileLocked1Site, fileLocked2Site ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple folders are selected - [C280574]', async () => {
await dataTable.selectMultipleItems([ folder1Site, folder2Site ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when both files and folders are selected - [C280642]', async () => {
await dataTable.selectMultipleItems([ file1Site, file2Site, folder1Site, folder2Site ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
});
@ -236,18 +312,41 @@ describe('Context menu actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C280648]', async () => {
await dataTable.selectMultipleItems([ file1, file2 ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is not displayed`);
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([ fileLocked1, fileLocked2 ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is not displayed`);
});
});
@ -259,18 +358,41 @@ describe('Context menu actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C280652]', async () => {
await dataTable.selectMultipleItems([ file1, file2 ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([ fileLocked1, fileLocked2 ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
});
@ -282,49 +404,73 @@ describe('Context menu actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C280656]', async () => {
await dataTable.selectMultipleItems([ file1, file2 ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
// TODO: enable when ACA-1794 is fixed
// expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([ fileLocked1, fileLocked2 ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple folders are selected - [C280664]', async () => {
await dataTable.selectMultipleItems([ folder1, folder2 ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
// TODO: enable when ACA-1794 is fixed
// expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when both files and folders are selected - [C280657]', async () => {
await dataTable.selectMultipleItems([ file1, file2, folder1, folder2 ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
// TODO: enable when ACA-1794 is fixed
// expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
});
@ -336,6 +482,11 @@ describe('Context menu actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C286273]', async () => {
await dataTable.selectMultipleItems([ fileInTrash1, fileInTrash2 ]);
await dataTable.rightClickOnMultipleSelection();
@ -344,11 +495,14 @@ describe('Context menu actions - multiple selection : ', () => {
expect(await contextMenu.isRestorePresent()).toBe(true, 'Restore is not displayed');
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(false, 'Download is displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(false, `Copy is displayed`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed`);
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(false, `Favorite is displayed`);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple folders are selected - [C286274]', async () => {
@ -359,11 +513,14 @@ describe('Context menu actions - multiple selection : ', () => {
expect(await contextMenu.isRestorePresent()).toBe(true, 'Restore is not displayed');
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(false, 'Download is displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(false, `Copy is displayed`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed`);
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(false, `Favorite is displayed`);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when both files and folders are selected - [C286275]', async () => {
@ -374,11 +531,14 @@ describe('Context menu actions - multiple selection : ', () => {
expect(await contextMenu.isRestorePresent()).toBe(true, 'Restore is not displayed');
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(false, 'Download is displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(false, `Copy is displayed`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed`);
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(false, `Favorite is displayed`);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
});
@ -389,6 +549,11 @@ describe('Context menu actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C291831]', async () => {
await searchInput.clickSearchButton();
await searchInput.checkOnlyFiles();
@ -396,14 +561,35 @@ describe('Context menu actions - multiple selection : ', () => {
await dataTable.selectMultipleItems([ file1Site, file2Site ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed`);
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await searchInput.clickSearchButton();
await searchInput.checkOnlyFiles();
await searchInput.searchForTextAndCloseSearchOptions('my-inSite-file');
await dataTable.selectMultipleItems([ fileLocked1Site, fileLocked2Site ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed`);
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when multiple folders are selected - [C291832]', async () => {
@ -413,14 +599,16 @@ describe('Context menu actions - multiple selection : ', () => {
await dataTable.selectMultipleItems([ folder1Site, folder2Site ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed`);
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
it('correct actions appear when both files and folders are selected - [C291833]', async () => {
@ -430,14 +618,16 @@ describe('Context menu actions - multiple selection : ', () => {
await dataTable.selectMultipleItems([ file1Site, file2Site, folder1Site, folder2Site ]);
await dataTable.rightClickOnMultipleSelection();
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await contextMenu.isViewPresent()).toBe(false, 'View is displayed');
expect(await contextMenu.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await contextMenu.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await contextMenu.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed`);
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
});
});
});

239
e2e/suites/actions/context-menu-single-selection.test.ts
View File

@ -35,9 +35,11 @@ describe('Context menu actions - single selection : ', () => {
const folderUser = `folderUser-${Utils.random()}`; let folderUserId;
const fileInTrash = `fileForDelete-${Utils.random()}.txt`; let fileInTrashId;
const folderInTrash = `folderForDelete-${Utils.random()}`; let folderInTrashId;
const fileLocked = `fileLocked-${Utils.random()}.txt`; let fileLockedId;
const siteName = `userSite-${Utils.random()}`;
const fileSiteUser = `fileUser-${Utils.random()}.txt`;
const fileLockedInSite = `file-locked-site-${Utils.random()}.txt`; let fileLockedInSiteId;
const folderSiteUser = `folderUser-${Utils.random()}`;
const adminPublic = `admin-public-${Utils.random()}`;
@ -61,10 +63,15 @@ describe('Context menu actions - single selection : ', () => {
fileUserId = (await apis.user.nodes.createFile(fileUser)).entry.id;
folderUserId = (await apis.user.nodes.createFolder(folderUser)).entry.id;
fileLockedId = (await apis.user.nodes.createFile(fileLocked)).entry.id;
await apis.user.nodes.lockFile(fileLockedId);
await apis.user.sites.createSite(siteName, SITE_VISIBILITY.PUBLIC);
const docLibId = await apis.user.sites.getDocLibId(siteName);
await apis.user.nodes.createFile(fileSiteUser, docLibId);
fileLockedInSiteId = (await apis.user.nodes.createFile(fileLockedInSite, docLibId)).entry.id;
await apis.user.nodes.createFolder(folderSiteUser, docLibId);
await apis.user.nodes.lockFile(fileLockedInSiteId);
fileInTrashId = (await apis.user.nodes.createFiles([fileInTrash])).entry.id;
folderInTrashId = (await apis.user.nodes.createFolders([ folderInTrash ])).entry.id;
@ -72,11 +79,13 @@ describe('Context menu actions - single selection : ', () => {
await apis.user.nodes.deleteNodeById(folderInTrashId, false);
await apis.user.shared.shareFileById(fileUserId);
await apis.user.shared.waitForApi({ expect: 1 });
await apis.user.shared.shareFileById(fileLockedId);
await apis.user.shared.waitForApi({ expect: 2 });
await apis.user.favorites.addFavoriteById('file', fileUserId);
await apis.user.favorites.addFavoriteById('file', fileLockedId);
await apis.user.favorites.addFavoriteById('folder', folderUserId);
await apis.user.favorites.waitForApi({ expect: 3 });
await apis.user.favorites.waitForApi({ expect: 4 });
await apis.admin.sites.createSite(adminPublic);
await apis.admin.sites.createSite(adminModerated, SITE_VISIBILITY.MODERATED);
@ -109,6 +118,11 @@ describe('Context menu actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Row is marked with a check circle icon on direct right click - [C286252]', async () => {
await dataTable.rightClickOnItem(fileUser);
@ -133,7 +147,7 @@ describe('Context menu actions - single selection : ', () => {
await dataTable.rightClickOnItem(folderUser);
expect(await dataTable.hasContextMenu()).toBe(true, `Context menu is not displayed for ${folderUser}`);
expect(await contextMenu.isEditPresent()).toBe(true, `Edit is not displayed for ${folderUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(true, `Edit folder is not displayed for ${folderUser}`);
expect(await dataTable.hasCheckMarkIcon(folderUser)).toBe(true, `${folderUser} is not selected`);
expect(await dataTable.hasCheckMarkIcon(fileUser)).toBe(false, `${fileUser} is not selected`);
});
@ -142,7 +156,9 @@ describe('Context menu actions - single selection : ', () => {
await dataTable.rightClickOnItem(fileUser);
expect(await dataTable.hasContextMenu()).toBe(true, 'Context menu is not displayed');
await page.sidenav.getActiveLink().click();
expect(await dataTable.hasContextMenu()).toBe(false, 'Context menu is displayed');
});
});
@ -155,9 +171,16 @@ describe('Context menu actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Context menu has the correct actions for a file - [C280615]', async () => {
await dataTable.rightClickOnItem(fileUser);
expect(await contextMenu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed for ${fileUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileUser}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileUser}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileUser}`);
@ -167,15 +190,33 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions is not displayed for ${fileUser}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileUser}`);
expect(await contextMenu.isEditPresent()).toBe(false, `Edit is displayed for ${fileUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileUser}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileUser}`);
});
it('Context menu has the correct actions for a locked file - []', async () => {
await dataTable.rightClickOnItem(fileLocked);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed for ${fileLocked}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLocked}`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLocked}`);
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileLocked}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions is not displayed for ${fileLocked}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileLocked}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileLocked}`);
});
it('Context menu has the correct actions for a folder - [C280616]', async () => {
await dataTable.rightClickOnItem(folderUser);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${folderUser}`);
expect(await contextMenu.isEditPresent()).toBe(true, `Edit is not displayed for ${folderUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(true, `Edit folder is not displayed for ${folderUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${folderUser}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${folderUser}`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed for ${folderUser}`);
@ -184,6 +225,8 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isViewPresent()).toBe(false, `View is displayed for ${folderUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage Versions is displayed for ${folderUser}`);
expect(await contextMenu.isSharePresent()).toBe(false, `Share is displayed for ${folderUser}`);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${folderUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${folderUser}`);
});
});
@ -196,9 +239,16 @@ describe('Context menu actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Context menu has the correct actions for a file - [C280594]', async () => {
await dataTable.rightClickOnItem(fileSiteUser);
expect(await contextMenu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileSiteUser}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileSiteUser}`);
@ -208,15 +258,33 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions not displayed for ${fileSiteUser}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isEditPresent()).toBe(false, `Edit is displayed for ${fileSiteUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileSiteUser}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileSiteUser}`);
});
it('Context menu has the correct actions for a locked file - []', async () => {
await dataTable.rightClickOnItem(fileLockedInSite);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(true, `Cancel editing is displayed for ${fileLockedInSite}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileLockedInSite}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLockedInSite}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileLockedInSite}`);
});
it('Context menu has the correct actions for a folder - [C280595]', async () => {
await dataTable.rightClickOnItem(folderSiteUser);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isEditPresent()).toBe(true, `Edit is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(true, `Edit folder is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed for ${folderSiteUser}`);
@ -225,6 +293,8 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isViewPresent()).toBe(false, `View is displayed for ${folderSiteUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage Versions displayed for ${folderSiteUser}`);
expect(await contextMenu.isSharePresent()).toBe(false, `Share is displayed for ${folderSiteUser}`);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${folderSiteUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${folderSiteUser}`);
});
});
@ -235,6 +305,11 @@ describe('Context menu actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Available actions for a library - My Libraries - [C290080]', async () => {
await page.goToMyLibrariesAndWait();
await dataTable.rightClickOnItem(siteName);
@ -319,9 +394,17 @@ describe('Context menu actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Context menu has the correct actions for a file - [C280601]', async () => {
await dataTable.rightClickOnItem(fileUser);
// TODO: change expect to true when ACA-2173 is done
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileUser}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileUser}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileUser}`);
@ -331,9 +414,28 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isSharedLinkSettingsPresent()).toBe(true, `Shared link settings is not displayed for ${fileUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions not displayed for ${fileUser}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileUser}`);
expect(await contextMenu.isEditPresent()).toBe(false, `Edit is displayed for ${fileUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileUser}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileUser}`);
});
it('Context menu has the correct actions for a locked file - []', async () => {
await dataTable.rightClickOnItem(fileLocked);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
// TODO: change expect to true when ACA-2173 is done
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileLocked}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLocked}`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLocked}`);
expect(await contextMenu.isSharedLinkSettingsPresent()).toBe(true, `Shared link settings is not displayed for ${fileLocked}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions not displayed for ${fileLocked}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileLocked}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileLocked}`);
});
});
describe('on Recent Files', () => {
@ -343,9 +445,16 @@ describe('Context menu actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Context menu has the correct actions for a file - [C280622]', async () => {
await dataTable.rightClickOnItem(fileUser);
expect(await contextMenu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed for ${fileUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileUser}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileUser}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileUser}`);
@ -355,9 +464,27 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions not displayed for ${fileUser}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileUser}`);
expect(await contextMenu.isEditPresent()).toBe(false, `Edit is displayed for ${fileUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileUser}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileUser}`);
});
it('Context menu has the correct actions for a locked file - []', async () => {
await dataTable.rightClickOnItem(fileLocked);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed for ${fileLocked}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLocked}`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLocked}`);
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileLocked}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions not displayed for ${fileLocked}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileLocked}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileLocked}`);
});
});
describe('on Favorites', () => {
@ -367,9 +494,17 @@ describe('Context menu actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Context menu has the correct actions for a file - [C280608]', async () => {
await dataTable.rightClickOnItem(fileUser);
// TODO: change expect to true when ACA-2174 is done
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileUser}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileUser}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileUser}`);
@ -378,26 +513,42 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileUser}`);
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions is not displayed for ${fileUser}`);
// TODO: enable when ACA-1794 is fixed
// expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileUser}`);
expect(await contextMenu.isEditPresent()).toBe(false, `Edit is displayed for ${fileUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileUser}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileUser}`);
});
it('Context menu has the correct actions for a locked file - []', async () => {
await dataTable.rightClickOnItem(fileLocked);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
// TODO: change expect to true when ACA-2174 is done
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileLocked}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLocked}`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLocked}`);
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileLocked}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions is not displayed for ${fileLocked}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileLocked}`);
});
it('Context menu has the correct actions for a folder - [C280609]', async () => {
await dataTable.rightClickOnItem(folderUser);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${folderUser}`);
expect(await contextMenu.isEditPresent()).toBe(true, `Edit is not displayed for ${folderUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(true, `Edit folder is not displayed for ${folderUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${folderUser}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${folderUser}`);
expect(await contextMenu.isMovePresent()).toBe(true, `Move is not displayed for ${folderUser}`);
expect(await contextMenu.isDeletePresent()).toBe(true, `Delete is not displayed for ${folderUser}`);
// TODO: enable when ACA-1794 is fixed
// expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${folderUser}`);
expect(await contextMenu.isViewPresent()).toBe(false, `View is displayed for ${folderUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage Versions is displayed for ${folderUser}`);
expect(await contextMenu.isSharePresent()).toBe(false, `Share is displayed for ${folderUser}`);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${folderUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${folderUser}`);
});
});
@ -408,11 +559,15 @@ describe('Context menu actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Context menu has the correct actions for a file - [C286258]', async () => {
await dataTable.rightClickOnItem(fileInTrash);
expect(await contextMenu.isPermanentDeletePresent())
.toBe(true, `Permanently delete is not displayed for ${fileInTrash}`);
expect(await contextMenu.isPermanentDeletePresent()).toBe(true, `Permanently delete is not displayed for ${fileInTrash}`);
expect(await contextMenu.isRestorePresent()).toBe(true, `Restore is not displayed for ${fileInTrash}`);
expect(await contextMenu.isDownloadPresent()).toBe(false, `Download is displayed for ${fileInTrash}`);
expect(await contextMenu.isViewPresent()).toBe(false, `View is displayed for ${fileInTrash}`);
@ -421,17 +576,17 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed for ${fileInTrash}`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed for ${fileInTrash}`);
expect(await contextMenu.isSharePresent()).toBe(false, `Share is displayed for ${fileInTrash}`);
expect(await contextMenu.isManageVersionsPresent())
.toBe(false, `Manage Versions is displayed for ${fileInTrash}`);
expect(await contextMenu.isEditPresent()).toBe(false, `Edit is displayed for ${fileInTrash}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage Versions is displayed for ${fileInTrash}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileInTrash}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileInTrash}`);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileInTrash}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileInTrash}`);
});
it('Context menu has the correct actions for a folder - [C286259]', async () => {
await dataTable.rightClickOnItem(folderInTrash);
expect(await contextMenu.isPermanentDeletePresent())
.toBe(true, `Permanently delete is not displayed for ${folderInTrash}`);
expect(await contextMenu.isPermanentDeletePresent()).toBe(true, `Permanently delete is not displayed for ${folderInTrash}`);
expect(await contextMenu.isRestorePresent()).toBe(true, `Restore is not displayed for ${folderInTrash}`);
expect(await contextMenu.isDownloadPresent()).toBe(false, `Download is displayed for ${folderInTrash}`);
expect(await contextMenu.isViewPresent()).toBe(false, `View is displayed for ${folderInTrash}`);
@ -440,10 +595,10 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed for ${folderInTrash}`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed for ${folderInTrash}`);
expect(await contextMenu.isSharePresent()).toBe(false, `Share is displayed for ${folderInTrash}`);
expect(await contextMenu.isManageVersionsPresent())
.toBe(false, `Manage Versions is displayed for ${folderInTrash}`);
expect(await contextMenu.isEditPresent()).toBe(false, `Edit is displayed for ${folderInTrash}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage Versions is displayed for ${folderInTrash}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${folderInTrash}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${folderInTrash}`);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${folderInTrash}`);
});
});
@ -454,12 +609,19 @@ describe('Context menu actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Context menu has the correct actions for a file - [C291827]', async () => {
await searchInput.clickSearchButton();
await searchInput.checkOnlyFiles();
await searchInput.searchForTextAndCloseSearchOptions(fileSiteUser);
await dataTable.rightClickOnItem(fileSiteUser);
expect(await contextMenu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileSiteUser}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileSiteUser}`);
@ -469,10 +631,31 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions not displayed for ${fileSiteUser}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileSiteUser}`);
expect(await contextMenu.isEditPresent()).toBe(false, `Edit is displayed for ${fileSiteUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileSiteUser}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileSiteUser}`);
});
it('Context menu has the correct actions for a locked file - []', async () => {
await searchInput.clickSearchButton();
await searchInput.checkOnlyFiles();
await searchInput.searchForTextAndCloseSearchOptions(fileLocked);
await dataTable.rightClickOnItem(fileLocked);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed for ${fileLocked}`);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await contextMenu.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed for ${fileLocked}`);
expect(await contextMenu.isDeletePresent()).toBe(false, `Delete is displayed for ${fileLocked}`);
expect(await contextMenu.isSharePresent()).toBe(true, `Share is not displayed for ${fileLocked}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(true, `Manage Versions not displayed for ${fileLocked}`);
expect(await contextMenu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed for ${fileLocked}`);
expect(await contextMenu.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
expect(await contextMenu.isViewDetailsPresent()).toBe(false, `View details is displayed for ${fileLocked}`);
});
it('Context menu has the correct actions for a folder - [C291828]', async () => {
await searchInput.clickSearchButton();
await searchInput.checkOnlyFolders();
@ -480,7 +663,7 @@ describe('Context menu actions - single selection : ', () => {
await dataTable.rightClickOnItem(folderSiteUser);
expect(await contextMenu.isDownloadPresent()).toBe(true, `Download is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isEditPresent()).toBe(true, `Edit is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isEditFolderPresent()).toBe(true, `Edit folder is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isCopyPresent()).toBe(true, `Copy is not displayed for ${folderSiteUser}`);
expect(await contextMenu.isMovePresent()).toBe(false, `Move is displayed for ${folderSiteUser}`);
@ -489,6 +672,8 @@ describe('Context menu actions - single selection : ', () => {
expect(await contextMenu.isViewPresent()).toBe(false, `View is displayed for ${folderSiteUser}`);
expect(await contextMenu.isManageVersionsPresent()).toBe(false, `Manage Versions displayed for ${folderSiteUser}`);
expect(await contextMenu.isSharePresent()).toBe(false, `Share is displayed for ${folderSiteUser}`);
expect(await contextMenu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${folderSiteUser}`);
expect(await contextMenu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${folderSiteUser}`);
});
});
});

16
e2e/suites/actions/delete-undo-delete.test.ts
View File

@ -99,10 +99,10 @@ describe('Delete and undo delete', () => {
fileLocked4Id = (await apis.user.nodes.createFile(fileLocked4, folder5Id)).entry.id;
await apis.user.nodes.createFile(file2InFolder, folder6Id);
await apis.user.nodes.lockFile(fileLocked1Id);
await apis.user.nodes.lockFile(fileLocked2Id);
await apis.user.nodes.lockFile(fileLocked3Id);
await apis.user.nodes.lockFile(fileLocked4Id);
await apis.user.nodes.lockFile(fileLocked1Id, 'FULL');
await apis.user.nodes.lockFile(fileLocked2Id, 'FULL');
await apis.user.nodes.lockFile(fileLocked3Id, 'FULL');
await apis.user.nodes.lockFile(fileLocked4Id, 'FULL');
await loginPage.loginWith(username);
@ -364,10 +364,10 @@ describe('Delete and undo delete', () => {
fileLocked4Id = (await apis.user.nodes.createFile(fileLocked4, favFolder5Id)).entry.id;
await apis.user.nodes.createFile(file2InFolder, favFolder6Id);
await apis.user.nodes.lockFile(fileLocked1Id);
await apis.user.nodes.lockFile(fileLocked2Id);
await apis.user.nodes.lockFile(fileLocked3Id);
await apis.user.nodes.lockFile(fileLocked4Id);
await apis.user.nodes.lockFile(fileLocked1Id, 'FULL');
await apis.user.nodes.lockFile(fileLocked2Id, 'FULL');
await apis.user.nodes.lockFile(fileLocked3Id, 'FULL');
await apis.user.nodes.lockFile(fileLocked4Id, 'FULL');
await apis.user.favorites.addFavoritesByIds('file', [ favFile1Id, favFile2Id, favFile3Id, favFile4Id, favFile5Id, favFile6Id, favFile7Id ]);
await apis.user.favorites.addFavoritesByIds('folder', [ favFolder1Id, favFolder2Id, favFolder3Id, favFolder4Id, favFolder5Id, favFolder6Id ]);

24
e2e/suites/actions/edit-folder.test.ts
View File

@ -111,7 +111,7 @@ describe('Edit folder', () => {
it('dialog UI defaults - [C216331]', async () => {
await dataTable.doubleClickOnRowByName(parent);
await dataTable.selectItem(folderName);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
expect(await editDialog.getTitle()).toEqual('Edit folder');
expect(await editDialog.getName()).toBe(folderName);
@ -130,7 +130,7 @@ describe('Edit folder', () => {
it('properties are modified when pressing OK - [C216335]', async (done) => {
await dataTable.selectItem(folderNameToEdit);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.waitForDialogToOpen();
await editDialog.enterDescription(folderDescriptionEdited);
await editDialog.enterName(folderNameEdited);
@ -146,7 +146,7 @@ describe('Edit folder', () => {
it('with empty folder name - [C216332]', async () => {
await dataTable.selectItem(folderName);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.deleteNameWithBackspace();
expect(await editDialog.isUpdateButtonEnabled()).toBe(false, 'upload button is not enabled');
@ -157,7 +157,7 @@ describe('Edit folder', () => {
const namesWithSpecialChars = [ 'a*a', 'a"a', 'a<a', 'a>a', `a\\a`, 'a/a', 'a?a', 'a:a', 'a|a' ];
await dataTable.selectItem(folderName);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
for (const name of namesWithSpecialChars) {
await editDialog.enterName(name);
@ -168,7 +168,7 @@ describe('Edit folder', () => {
it('with name ending with a dot - [C216334]', async () => {
await dataTable.selectItem(folderName);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.waitForDialogToOpen();
await editDialog.nameInput.sendKeys('.');
@ -178,7 +178,7 @@ describe('Edit folder', () => {
it('Cancel button - [C216336]', async () => {
await dataTable.selectItem(folderName);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.waitForDialogToOpen();
await editDialog.clickCancel();
@ -187,7 +187,7 @@ describe('Edit folder', () => {
it('with duplicate folder name - [C216337]', async () => {
await dataTable.selectItem(folderName);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.waitForDialogToOpen();
await editDialog.enterName(duplicateFolderName);
await editDialog.clickUpdate();
@ -198,7 +198,7 @@ describe('Edit folder', () => {
it('trim ending spaces - [C216338]', async () => {
await dataTable.selectItem(folderName);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.nameInput.sendKeys(' ');
await editDialog.clickUpdate();
await editDialog.waitForDialogToClose();
@ -216,7 +216,7 @@ describe('Edit folder', () => {
it('properties are modified when pressing OK - [C280384]', async (done) => {
await dataTable.selectItem(folderFavoriteToEdit);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.waitForDialogToOpen();
await editDialog.enterDescription(folderDescriptionEdited);
await editDialog.enterName(folderNameEdited);
@ -232,7 +232,7 @@ describe('Edit folder', () => {
it('with duplicate folder name - [C280386]', async () => {
await dataTable.selectItem(folderFavorite);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.waitForDialogToOpen();
await editDialog.enterName(folderFavoriteDuplicate);
await editDialog.clickUpdate();
@ -251,7 +251,7 @@ describe('Edit folder', () => {
it('properties are modified when pressing OK - [C280509]', async (done) => {
await dataTable.selectItem(folderSiteToEdit);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.waitForDialogToOpen();
await editDialog.enterDescription(folderDescriptionEdited);
await editDialog.enterName(folderNameEdited);
@ -267,7 +267,7 @@ describe('Edit folder', () => {
it('with duplicate folder name - [C280511]', async () => {
await dataTable.selectItem(folderSite);
await toolbar.clickEdit();
await toolbar.clickEditFolder();
await editDialog.waitForDialogToOpen();
await editDialog.enterName(duplicateFolderSite);
await editDialog.clickUpdate();

2065
e2e/suites/actions/special-permissions-available-actions.test.ts
View File

File diff suppressed because it is too large Load Diff

362
e2e/suites/actions/toolbar-multiple-selection.test.ts
View File

@ -32,30 +32,29 @@ import { Utils } from '../../utilities/utils';
describe('Toolbar actions - multiple selection : ', () => {
const username = `user-${Utils.random()}`;
const file1 = `my-file1-${Utils.random()}.txt`;
let file1Id;
const file2 = `my-file2-${Utils.random()}.txt`;
let file2Id;
const parent = `parent-${Utils.random()}`; let parentId;
const folder1 = `my-folder1-${Utils.random()}`;
let folder1Id;
const folder2 = `my-folder2-${Utils.random()}`;
let folder2Id;
const file1 = `my-file1-${Utils.random()}.txt`; let file1Id;
const file2 = `my-file2-${Utils.random()}.txt`; let file2Id;
const fileForDelete1 = `file-${Utils.random()}.txt`;
let fileForDelete1Id;
const fileForDelete2 = `file-${Utils.random()}.txt`;
let fileForDelete2Id;
const folderForDelete1 = `folder-${Utils.random()}`;
let folderForDelete1Id;
const folderForDelete2 = `folder-${Utils.random()}`;
let folderForDelete2Id;
const folder1 = `my-folder1-${Utils.random()}`; let folder1Id;
const folder2 = `my-folder2-${Utils.random()}`; let folder2Id;
const fileForDelete1 = `file-${Utils.random()}.txt`; let fileForDelete1Id;
const fileForDelete2 = `file-${Utils.random()}.txt`; let fileForDelete2Id;
const folderForDelete1 = `folder-${Utils.random()}`; let folderForDelete1Id;
const folderForDelete2 = `folder-${Utils.random()}`; let folderForDelete2Id;
const siteName = `site-${Utils.random()}`;
const file1InSite = `my-fileInSite1-${Utils.random()}.txt`;
const file2InSite = `my-fileInSite2-${Utils.random()}.txt`;
const folder1InSite = `my-folderInSite1-${Utils.random()}`;
const folder2InSite = `my-folderInSite2-${Utils.random()}`;
const fileLocked1InSite = `my-fileLockedInSite1-${Utils.random()}.txt`; let fileLocked1InSiteId;
const fileLocked2InSite = `my-fileLockedInSite2-${Utils.random()}.txt`; let fileLocked2InSiteId;
const fileLocked1 = `my-fileLocked1-${Utils.random()}.txt`; let fileLocked1Id;
const fileLocked2 = `my-fileLocked2-${Utils.random()}.txt`; let fileLocked2Id;
const apis = {
admin: new RepoClient(),
@ -71,21 +70,27 @@ describe('Toolbar actions - multiple selection : ', () => {
beforeAll(async (done) => {
await apis.admin.people.createUser({ username });
file1Id = (await apis.user.nodes.createFiles([file1])).entry.id;
file2Id = (await apis.user.nodes.createFiles([file2])).entry.id;
folder1Id = (await apis.user.nodes.createFolders([folder1])).entry.id;
folder2Id = (await apis.user.nodes.createFolders([folder2])).entry.id;
fileForDelete1Id = (await apis.user.nodes.createFiles([fileForDelete1])).entry.id;
fileForDelete2Id = (await apis.user.nodes.createFiles([fileForDelete2])).entry.id;
folderForDelete1Id = (await apis.user.nodes.createFolders([folderForDelete1])).entry.id;
folderForDelete2Id = (await apis.user.nodes.createFolders([folderForDelete2])).entry.id;
parentId = (await apis.user.nodes.createFolder(parent)).entry.id;
await apis.user.shared.shareFilesByIds([file1Id, file2Id]);
await apis.user.shared.waitForApi({ expect: 2 });
file1Id = (await apis.user.nodes.createFile(file1, parentId)).entry.id;
file2Id = (await apis.user.nodes.createFile(file2, parentId)).entry.id;
folder1Id = (await apis.user.nodes.createFolder(folder1, parentId)).entry.id;
folder2Id = (await apis.user.nodes.createFolder(folder2, parentId)).entry.id;
fileForDelete1Id = (await apis.user.nodes.createFile(fileForDelete1, parentId)).entry.id;
fileForDelete2Id = (await apis.user.nodes.createFile(fileForDelete2, parentId)).entry.id;
folderForDelete1Id = (await apis.user.nodes.createFolder(folderForDelete1, parentId)).entry.id;
folderForDelete2Id = (await apis.user.nodes.createFolder(folderForDelete2, parentId)).entry.id;
fileLocked1Id = (await apis.user.nodes.createFile(fileLocked1, parentId)).entry.id;
fileLocked2Id = (await apis.user.nodes.createFile(fileLocked2, parentId)).entry.id;
await apis.user.nodes.lockFile(fileLocked1Id);
await apis.user.nodes.lockFile(fileLocked2Id);
await apis.user.favorites.addFavoritesByIds('file', [file1Id, file2Id]);
await apis.user.shared.shareFilesByIds([file1Id, file2Id, fileLocked1Id, fileLocked2Id]);
await apis.user.shared.waitForApi({ expect: 4 });
await apis.user.favorites.addFavoritesByIds('file', [file1Id, file2Id, fileLocked1Id, fileLocked2Id]);
await apis.user.favorites.addFavoritesByIds('folder', [folder1Id, folder2Id]);
await apis.user.favorites.waitForApi({ expect: 4 });
await apis.user.favorites.waitForApi({ expect: 6 });
await apis.user.nodes.deleteNodesById([fileForDelete1Id, fileForDelete2Id, folderForDelete1Id, folderForDelete2Id], false);
await apis.user.trashcan.waitForApi({ expect: 4 });
@ -96,7 +101,13 @@ describe('Toolbar actions - multiple selection : ', () => {
await apis.user.nodes.createFile(file2InSite, docLibId);
await apis.user.nodes.createFolder(folder1InSite, docLibId);
await apis.user.nodes.createFolder(folder2InSite, docLibId);
await apis.user.search.waitForApi(username, { expect: 4 });
fileLocked1InSiteId = (await apis.user.nodes.createFile(fileLocked1InSite, docLibId)).entry.id;
fileLocked2InSiteId = (await apis.user.nodes.createFile(fileLocked2InSite, docLibId)).entry.id;
await apis.user.nodes.lockFile(fileLocked1InSiteId);
await apis.user.nodes.lockFile(fileLocked2InSiteId);
await apis.user.search.waitForApi(username, { expect: 6 });
await loginPage.loginWith(username);
done();
@ -104,7 +115,7 @@ describe('Toolbar actions - multiple selection : ', () => {
afterAll(async (done) => {
await Promise.all([
apis.user.nodes.deleteNodesById([file1Id, file2Id, folder1Id, folder2Id]),
apis.user.nodes.deleteNodeById(parentId),
apis.user.trashcan.emptyTrash(),
apis.user.sites.deleteSite(siteName)
]);
@ -116,13 +127,23 @@ describe('Toolbar actions - multiple selection : ', () => {
await Utils.pressEscape();
await dataTable.clearSelection();
await page.clickPersonalFilesAndWait();
await dataTable.doubleClickOnRowByName(parent);
await dataTable.waitForBody();
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('Unselect items with single click - [C280458]', async () => {
await dataTable.selectMultipleItems([file1, file2, folder1, folder2]);
expect(await dataTable.countSelectedRows()).toEqual(4, 'incorrect selected rows number');
await dataTable.selectItem(file1);
expect(await dataTable.countSelectedRows()).toEqual(1, 'incorrect selected rows number');
});
@ -133,7 +154,9 @@ describe('Toolbar actions - multiple selection : ', () => {
await dataTable.selectItem(folder1);
await dataTable.selectItem(folder2);
await browser.actions().sendKeys(protractor.Key.NULL).perform();
expect(await dataTable.countSelectedRows()).toEqual(4, 'incorrect selected rows number');
await browser.actions().sendKeys(protractor.Key.COMMAND).perform();
await dataTable.selectItem(file1);
await dataTable.selectItem(file2);
@ -144,40 +167,81 @@ describe('Toolbar actions - multiple selection : ', () => {
it('correct actions appear when multiple files are selected - [C217112]', async () => {
await dataTable.selectMultipleItems([file1, file2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([fileLocked1, fileLocked2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when multiple folders are selected - [C280459]', async () => {
await dataTable.selectMultipleItems([folder1, folder2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when both files and folders are selected - [C280460]', async () => {
await dataTable.selectMultipleItems([file1, file2, folder1, folder2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
});
@ -191,42 +255,88 @@ describe('Toolbar actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C280461]', async () => {
await dataTable.selectMultipleItems([file1InSite, file2InSite]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed for selected files');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed for selected files');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed for selected files');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed for selected files');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([fileLocked1InSite, fileLocked2InSite]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed for selected files');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed for selected files');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed for selected files');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when multiple folders are selected - [C280462]', async () => {
await dataTable.selectMultipleItems([folder1InSite, folder2InSite]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when both files and folders are selected - [C280463]', async () => {
await dataTable.selectMultipleItems([file1InSite, file2InSite, folder1InSite, folder2InSite]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
});
@ -239,16 +349,48 @@ describe('Toolbar actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C280467]', async () => {
await dataTable.selectMultipleItems([file1, file2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed for selected files');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed for selected files');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed for selected files');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([fileLocked1, fileLocked2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed for selected files');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed for selected files');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
});
@ -261,16 +403,48 @@ describe('Toolbar actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C280468]', async () => {
await dataTable.selectMultipleItems([file1, file2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([fileLocked1, fileLocked2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
});
@ -283,42 +457,88 @@ describe('Toolbar actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C280469]', async () => {
await dataTable.selectMultipleItems([file1, file2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await dataTable.selectMultipleItems([fileLocked1, fileLocked2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when multiple folders are selected - [C280470]', async () => {
await dataTable.selectMultipleItems([folder1, folder2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when both files and folders are selected - [C280471]', async () => {
await dataTable.selectMultipleItems([file1, file2, folder1, folder2]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed for selected files');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
});
@ -329,20 +549,28 @@ describe('Toolbar actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C280472]', async () => {
await dataTable.selectMultipleItems([fileForDelete1, fileForDelete2]);
expect(await toolbar.isButtonPresent('Permanently delete')).toBe(true, 'Permanently delete is displayed');
expect(await toolbar.isButtonPresent('Restore')).toBe(true, 'Restore is not displayed');
});
it('correct actions appear when multiple folders are selected - [C280473]', async () => {
await dataTable.selectMultipleItems([folderForDelete1, folderForDelete2]);
expect(await toolbar.isButtonPresent('Permanently delete')).toBe(true, 'Permanently delete is displayed');
expect(await toolbar.isButtonPresent('Restore')).toBe(true, 'Restore is not displayed');
});
it('correct actions appear when both files and folders are selected - [C280474]', async () => {
await dataTable.selectMultipleItems([fileForDelete1, fileForDelete2, folderForDelete1, folderForDelete2]);
expect(await toolbar.isButtonPresent('Permanently delete')).toBe(true, 'Permanently delete is displayed');
expect(await toolbar.isButtonPresent('Restore')).toBe(true, 'Restore is not displayed');
});
@ -355,6 +583,11 @@ describe('Toolbar actions - multiple selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('correct actions appear when multiple files are selected - [C291820]', async () => {
await searchInput.clickSearchButton();
await searchInput.checkOnlyFiles();
@ -363,12 +596,41 @@ describe('Toolbar actions - multiple selection : ', () => {
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed for selected files');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed for selected files');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed for selected files');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed for selected files');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(false, `Delete is displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(false, `Move is displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when multiple locked files are selected - []', async () => {
await searchInput.clickSearchButton();
await searchInput.checkOnlyFiles();
await searchInput.searchForTextAndCloseSearchOptions('my-fileLockedInSite');
await dataTable.selectMultipleItems([fileLocked1InSite, fileLocked2InSite]);
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed for selected files');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed for selected files');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed for selected files');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(false, `Delete is displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(false, `Move is displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
@ -380,12 +642,18 @@ describe('Toolbar actions - multiple selection : ', () => {
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(false, `Delete is displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(false, `Move is displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
@ -397,12 +665,18 @@ describe('Toolbar actions - multiple selection : ', () => {
expect(await toolbar.isViewPresent()).toBe(false, 'View is displayed');
expect(await toolbar.isDownloadPresent()).toBe(true, 'Download is not displayed');
expect(await toolbar.isEditPresent()).toBe(false, 'Edit is displayed');
expect(await toolbar.isEditFolderPresent()).toBe(false, 'Edit folder is displayed');
await toolbar.openMoreMenu();
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for selected files`);
expect(await toolbar.menu.isDeletePresent()).toBe(false, `Delete is displayed for selected files`);
expect(await toolbar.menu.isMovePresent()).toBe(false, `Move is displayed for selected files`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for selected files`);
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed`);
await toolbar.closeMoreMenu();
});
});

308
e2e/suites/actions/toolbar-single-selection.test.ts
View File

@ -35,9 +35,11 @@ describe('Toolbar actions - single selection : ', () => {
const folderUser = `folderUser-${Utils.random()}`; let folderUserId;
const fileForDelete = `fileForDelete-${Utils.random()}.txt`; let fileForDeleteId;
const folderForDelete = `folderForDelete-${Utils.random()}`; let folderForDeleteId;
const fileLocked = `fileLocked-${Utils.random()}.txt`; let fileLockedId;
const siteName = `site-${Utils.random()}`;
const fileInSite = `file-site-${Utils.random()}.txt`;
const fileLockedInSite = `file-locked-site-${Utils.random()}.txt`; let fileLockedInSiteId;
const folderInSite = `folder-site-${Utils.random()}`;
const adminPublic = `admin-public-${Utils.random()}`;
@ -61,19 +63,27 @@ describe('Toolbar actions - single selection : ', () => {
fileForDeleteId = (await apis.user.nodes.createFile(fileForDelete)).entry.id;
folderForDeleteId = (await apis.user.nodes.createFolder(folderForDelete)).entry.id;
folderUserId = (await apis.user.nodes.createFolder(folderUser)).entry.id;
fileLockedId = (await apis.user.nodes.createFile(fileLocked)).entry.id;
await apis.user.shared.shareFileById(fileUserId);
await apis.user.shared.waitForApi({ expect: 1 });
await apis.user.shared.shareFileById(fileLockedId);
await apis.user.shared.waitForApi({ expect: 2 });
await apis.user.favorites.addFavoriteById('file', fileUserId);
await apis.user.favorites.addFavoriteById('folder', folderUserId);
await apis.user.favorites.waitForApi({ expect: 2 });
await apis.user.favorites.addFavoriteById('file', fileLockedId);
await apis.user.favorites.waitForApi({ expect: 3 });
await apis.user.nodes.lockFile(fileLockedId);
await apis.user.sites.createSite(siteName, SITE_VISIBILITY.PRIVATE);
const docLibId = await apis.user.sites.getDocLibId(siteName);
await apis.user.nodes.createFile(fileInSite, docLibId);
fileLockedInSiteId = (await apis.user.nodes.createFile(fileLockedInSite, docLibId)).entry.id;
await apis.user.nodes.createFolder(folderInSite, docLibId);
await apis.user.nodes.lockFile(fileLockedInSiteId);
await apis.user.nodes.deleteNodeById(fileForDeleteId, false);
await apis.user.nodes.deleteNodeById(folderForDeleteId, false);
@ -109,8 +119,14 @@ describe('Toolbar actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('selected row is marked with a check circle icon - [C213134]', async () => {
await dataTable.selectItem(fileUser);
expect(await dataTable.hasCheckMarkIcon(fileUser)).toBe(true, 'check mark missing');
});
@ -120,29 +136,64 @@ describe('Toolbar actions - single selection : ', () => {
it('correct actions appear when a file is selected - [C213122]', async () => {
await dataTable.selectItem(fileUser);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileUser}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileUser}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileUser}`);
expect(await toolbar.isEditPresent()).toBe(false, `Edit is displayed for ${fileUser}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileUser}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed for ${fileUser}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileUser}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileUser}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileUser}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileUser}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileUser}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileUser}`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when a locked file is selected - []', async () => {
await dataTable.selectItem(fileLocked);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileLocked}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileLocked}`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when a folder is selected - [C213123]', async () => {
await dataTable.selectItem(folderUser);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${folderUser}`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed for ${folderUser}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not enabled for ${folderUser}`);
expect(await toolbar.isEditPresent()).toBe(true, `Edit is not displayed for ${folderUser}`);
expect(await toolbar.isEditFolderPresent()).toBe(true, `Edit folder is not displayed for ${folderUser}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${folderUser}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${folderUser}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${folderUser}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${folderUser}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${folderUser}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${folderUser}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed for ${folderUser}`);
await toolbar.closeMoreMenu();
});
});
@ -156,35 +207,75 @@ describe('Toolbar actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('actions are not displayed when no item is selected - [C280439]', async () => {
expect(await toolbar.isEmpty()).toBe(true, `actions displayed though nothing selected`);
});
it('correct actions appear when a file is selected - [C280440]', async () => {
await dataTable.selectItem(fileInSite);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileInSite}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileInSite}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileInSite}`);
expect(await toolbar.isEditPresent()).toBe(false, `Edit is displayed for ${fileInSite}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileInSite}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed for ${fileInSite}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileInSite}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileInSite}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileInSite}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileInSite}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileInSite}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileInSite}`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when a locked file is selected - []', async () => {
await dataTable.selectItem(fileLockedInSite);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileLockedInSite}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileLockedInSite}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLockedInSite}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLockedInSite}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLockedInSite}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed for ${fileLockedInSite}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLockedInSite}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLockedInSite}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLockedInSite}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLockedInSite}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileLockedInSite}`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when a folder is selected - [C280441]', async () => {
await dataTable.selectItem(folderInSite);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${folderInSite}`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed for ${folderInSite}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not enabled for ${folderInSite}`);
expect(await toolbar.isEditPresent()).toBe(true, `Edit is not displayed for ${folderInSite}`);
expect(await toolbar.isEditFolderPresent()).toBe(true, `Edit folder is not displayed for ${folderInSite}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${folderInSite}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${folderInSite}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${folderInSite}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${folderInSite}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${folderInSite}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${folderInSite}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed for ${folderInSite}`);
await toolbar.closeMoreMenu();
});
});
@ -196,6 +287,7 @@ describe('Toolbar actions - single selection : ', () => {
});
afterAll(async (done) => {
await Utils.pressEscape();
await page.clickPersonalFiles();
done();
});
@ -203,48 +295,64 @@ describe('Toolbar actions - single selection : ', () => {
it('Available actions for a library - My Libraries - [C213135]', async () => {
await page.goToMyLibrariesAndWait();
await dataTable.selectItem(siteName);
expect(await toolbar.isEmpty()).toBe(false, 'toolbar not displayed');
expect(await toolbar.isViewDetailsPresent()).toBe(true, `View details is not displayed for ${siteName}`);
expect(await toolbar.isButtonPresent('Leave library')).toBe(true, `Leave is not displayed for ${siteName}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${siteName}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${siteName}`);
await toolbar.closeMoreMenu();
});
it('Available actions for a library - Favorite Libraries - user is a member - [C289892]', async () => {
await page.goToFavoriteLibrariesAndWait();
await dataTable.selectItem(siteName);
expect(await toolbar.isEmpty()).toBe(false, 'toolbar not displayed');
expect(await toolbar.isViewDetailsPresent()).toBe(true, `View details is not displayed for ${siteName}`);
expect(await toolbar.isButtonPresent('Leave library')).toBe(true, `Leave is not displayed for ${siteName}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${siteName}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${siteName}`);
await toolbar.closeMoreMenu();
});
it('Available actions for a library - Favorite Libraries - user is not a member - [C290090]', async () => {
await page.goToFavoriteLibrariesAndWait();
await dataTable.selectItem(adminPublic);
expect(await toolbar.isEmpty()).toBe(false, 'toolbar not displayed');
expect(await toolbar.isViewDetailsPresent()).toBe(true, `View details is not displayed for ${adminPublic}`);
expect(await toolbar.isButtonPresent('Join')).toBe(true, `Join is not displayed for ${adminPublic}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${adminPublic}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${adminPublic}`);
await toolbar.closeMoreMenu();
});
it('Available actions for a moderated library - Favorite Libraries - user requested to join - [C290091]', async () => {
await page.goToFavoriteLibrariesAndWait();
await dataTable.selectItem(adminModerated);
expect(await toolbar.isEmpty()).toBe(false, 'toolbar not displayed');
expect(await toolbar.isViewDetailsPresent()).toBe(true, `View details is not displayed for ${adminModerated}`);
expect(await toolbar.isButtonPresent('Cancel join request')).toBe(true, `Cancel join is not displayed for ${adminModerated}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${adminModerated}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${adminModerated}`);
await toolbar.closeMoreMenu();
});
@ -257,9 +365,12 @@ describe('Toolbar actions - single selection : ', () => {
expect(await toolbar.isEmpty()).toBe(false, 'toolbar not displayed');
expect(await toolbar.isViewDetailsPresent()).toBe(true, `View details is not displayed for ${siteName}`);
expect(await toolbar.isButtonPresent('Leave library')).toBe(true, `Leave is not displayed for ${siteName}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${siteName}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${siteName}`);
await toolbar.closeMoreMenu();
});
@ -272,9 +383,12 @@ describe('Toolbar actions - single selection : ', () => {
expect(await toolbar.isEmpty()).toBe(false, 'toolbar not displayed');
expect(await toolbar.isViewDetailsPresent()).toBe(true, `View details is not displayed for ${adminPublic}`);
expect(await toolbar.isButtonPresent('Join')).toBe(true, `Join is not displayed for ${adminPublic}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${adminPublic}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${adminPublic}`);
await toolbar.closeMoreMenu();
});
@ -287,9 +401,12 @@ describe('Toolbar actions - single selection : ', () => {
expect(await toolbar.isEmpty()).toBe(false, 'toolbar not displayed');
expect(await toolbar.isViewDetailsPresent()).toBe(true, `View details is not displayed for ${adminModerated}`);
expect(await toolbar.isButtonPresent('Cancel join request')).toBe(true, `Cancel join is not displayed for ${adminModerated}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${adminModerated}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${adminModerated}`);
await toolbar.closeMoreMenu();
});
});
@ -301,22 +418,58 @@ describe('Toolbar actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('actions are not displayed when no item is selected - [C280445]', async () => {
expect(await toolbar.isEmpty()).toBe(true, `actions displayed though nothing selected`);
});
it('correct actions appear when a file is selected - [C286265]', async () => {
await page.dataTable.selectItem(fileUser);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileUser}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileUser}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileUser}`);
expect(await toolbar.isEditPresent()).toBe(false, `Edit is displayed for ${fileUser}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileUser}`);
expect(await toolbar.isSharedLinkSettingsPresent()).toBe(true, `Shared link settings is not displayed for ${fileUser}`);
await toolbar.openMoreMenu();
// TODO: change expect to true when ACA-2173 is done
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileUser}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileUser}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileUser}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileUser}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileUser}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileUser}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileUser}`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when a locked file is selected - []', async () => {
await page.dataTable.selectItem(fileLocked);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileLocked}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
expect(await toolbar.isSharedLinkSettingsPresent()).toBe(true, `Shared link settings is not displayed for ${fileLocked}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
// TODO: change expect to true when ACA-2173 is done
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileLocked}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileLocked}`);
await toolbar.closeMoreMenu();
});
});
@ -328,21 +481,54 @@ describe('Toolbar actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('actions are not displayed when no item is selected - [C280447]', async () => {
expect(await toolbar.isEmpty()).toBe(true, `actions displayed though nothing selected`);
});
it('correct actions appear when a file is selected - [C280448]', async () => {
await dataTable.selectItem(fileUser);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileUser}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileUser}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileUser}`);
expect(await toolbar.isEditPresent()).toBe(false, `Edit is displayed for ${fileUser}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileUser}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed for ${fileUser}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileUser}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileUser}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileUser}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileUser}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileUser}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileUser}`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when a locked file is selected - []', async () => {
await dataTable.selectItem(fileLocked);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileLocked}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileLocked}`);
await toolbar.closeMoreMenu();
});
});
@ -354,35 +540,77 @@ describe('Toolbar actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('actions are not displayed when no item is selected - [C280449]', async () => {
expect(await toolbar.isEmpty()).toBe(true, `actions displayed though nothing selected`);
});
it('correct actions appear when a file is selected - [C280450]', async () => {
await dataTable.selectItem(fileUser);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileUser}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileUser}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileUser}`);
expect(await toolbar.isEditPresent()).toBe(false, `Edit is displayed for ${fileUser}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileUser}`);
await toolbar.openMoreMenu();
// TODO: change expect to true when ACA-2174 is done
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileUser}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileUser}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileUser}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileUser}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileUser}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileUser}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileUser}`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when a locked file is selected - []', async () => {
await dataTable.selectItem(fileLocked);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileLocked}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
// TODO: change expect to true when ACA-2174 is done
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileLocked}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileLocked}`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when a folder is selected - [C280451]', async () => {
await dataTable.selectItem(folderUser);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${folderUser}`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed for ${folderUser}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not enabled for ${folderUser}`);
expect(await toolbar.isEditPresent()).toBe(true, `Edit is not displayed for ${folderUser}`);
expect(await toolbar.isEditFolderPresent()).toBe(true, `Edit folder is not displayed for ${folderUser}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${folderUser}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${folderUser}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${folderUser}`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed for ${folderUser}`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed for ${folderUser}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${folderUser}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed for ${folderUser}`);
await toolbar.closeMoreMenu();
});
});
@ -394,22 +622,29 @@ describe('Toolbar actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('actions are not displayed when no item is selected - [C280452]', async () => {
expect(await toolbar.isEmpty()).toBe(true, `actions displayed though nothing selected`);
});
it('correct actions appear when a file is selected - [C280453]', async () => {
await dataTable.selectItem(fileForDelete);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileForDelete}`);
expect(await toolbar.isButtonPresent('Permanently delete')).toBe(true, `Permanently delete is not displayed for file`);
expect(await toolbar.isButtonPresent('Restore')).toBe(true, `Restore is not displayed for file`);
expect(await toolbar.isPermanentlyDeletePresent()).toBe(true, `Permanently delete is not displayed for file`);
expect(await toolbar.isRestorePresent()).toBe(true, `Restore is not displayed for file`);
});
it('correct actions appear when a folder is selected - [C280454]', async () => {
await dataTable.selectItem(folderForDelete);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${folderForDelete}`);
expect(await toolbar.isButtonPresent('Permanently delete')).toBe(true, `Permanently delete is displayed for folder`);
expect(await toolbar.isButtonPresent('Restore')).toBe(true, `Restore is not enabled for folder`);
expect(await toolbar.isPermanentlyDeletePresent()).toBe(true, `Permanently delete is displayed for folder`);
expect(await toolbar.isRestorePresent()).toBe(true, `Restore is not displayed for folder`);
});
});
@ -420,6 +655,11 @@ describe('Toolbar actions - single selection : ', () => {
done();
});
afterAll(async (done) => {
await Utils.pressEscape();
done();
});
it('actions are not displayed when no item is selected - [C291815]', async () => {
await searchInput.clickSearchButton();
await searchInput.checkFilesAndFolders();
@ -437,12 +677,42 @@ describe('Toolbar actions - single selection : ', () => {
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileUser}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileUser}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileUser}`);
expect(await toolbar.isEditPresent()).toBe(false, `Edit is displayed for ${fileUser}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileUser}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed for ${fileUser}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${fileUser}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileUser}`);
expect(await toolbar.menu.isDeletePresent()).toBe(false, `Delete is displayed for ${fileUser}`);
expect(await toolbar.menu.isMovePresent()).toBe(false, `Move is displayed for ${fileUser}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileUser}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileUser}`);
await toolbar.closeMoreMenu();
});
it('correct actions appear when a locked file is selected - []', async () => {
await searchInput.clickSearchButton();
await searchInput.checkOnlyFiles();
await searchInput.searchForTextAndCloseSearchOptions(fileLocked);
await dataTable.selectItem(fileLocked);
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${fileLocked}`);
expect(await toolbar.isViewPresent()).toBe(true, `View is not displayed for ${fileLocked}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed for ${fileLocked}`);
expect(await toolbar.isEditFolderPresent()).toBe(false, `Edit folder is displayed for ${fileLocked}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${fileLocked}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isDeletePresent()).toBe(false, `Delete is displayed for ${fileLocked}`);
expect(await toolbar.menu.isMovePresent()).toBe(false, `Move is displayed for ${fileLocked}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${fileLocked}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed for ${fileLocked}`);
await toolbar.closeMoreMenu();
});
@ -455,12 +725,18 @@ describe('Toolbar actions - single selection : ', () => {
expect(await toolbar.isEmpty()).toBe(false, `actions not displayed for ${folderUser}`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed for ${folderUser}`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not enabled for ${folderUser}`);
expect(await toolbar.isEditPresent()).toBe(true, `Edit is not displayed for ${folderUser}`);
expect(await toolbar.isEditFolderPresent()).toBe(true, `Edit folder is not displayed for ${folderUser}`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed for ${folderUser}`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed for ${folderUser}`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed for ${folderUser}`);
expect(await toolbar.menu.isDeletePresent()).toBe(false, `Delete is displayed for ${folderUser}`);
expect(await toolbar.menu.isMovePresent()).toBe(false, `Move is displayed for ${folderUser}`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed for ${folderUser}`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(false, `Manage versions is displayed for ${folderUser}`);
await toolbar.closeMoreMenu();
});
});

2
e2e/suites/list-views/tooltips.test.ts
View File

@ -166,7 +166,7 @@ describe('File / folder tooltips', () => {
});
// disabled until ACA-518 is done
xdescribe('on Shared Files', () => {
describe('on Shared Files', () => {
beforeAll(async (done) => {
await apis.user.shared.waitForApi({ expect: 8 });
await page.clickSharedFilesAndWait();

271
e2e/suites/viewer/viewer-actions.test.ts
View File

@ -58,11 +58,12 @@ describe('Viewer actions', () => {
done();
});
describe('on Personal Files', () => {
describe('file opened from Personal Files', () => {
const parent = `parentPF-${Utils.random()}`; let parentId;
const destination = `destPF-${Utils.random()}`; let destinationId;
const docxPersonalFiles = `docxPF-${Utils.random()}.docx`; let docxFileId;
const docxLockedPersonalFiles = `docxLockedPF-${Utils.random()}.docx`; let docxLockedId;
const xlsxPersonalFiles = `xlsxPF-${Utils.random()}.xlsx`;
const pdfPersonalFiles = `pdfPF-${Utils.random()}.pdf`;
@ -70,9 +71,12 @@ describe('Viewer actions', () => {
parentId = (await apis.user.nodes.createFolder(parent)).entry.id;
destinationId = (await apis.user.nodes.createFolder(destination)).entry.id;
docxFileId = (await apis.user.upload.uploadFileWithRename(docxFile, parentId, docxPersonalFiles)).entry.id;
docxLockedId = (await apis.user.upload.uploadFileWithRename(docxFile, parentId, docxLockedPersonalFiles)).entry.id;
await apis.user.upload.uploadFileWithRename(xlsxFileForMove, parentId, xlsxPersonalFiles);
await apis.user.upload.uploadFileWithRename(pdfFileForDelete, parentId, pdfPersonalFiles);
await apis.user.nodes.lockFile(docxLockedId);
await loginPage.loginWith(username);
done();
});
@ -98,7 +102,7 @@ describe('Viewer actions', () => {
it('Correct actions appear in the viewer toolbar - [C282025]', async () => {
await dataTable.doubleClickOnRowByName(docxPersonalFiles);
expect(await viewer.isViewerOpened()).toBe(true, 'Viewer is not opened');
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
@ -107,13 +111,42 @@ describe('Viewer actions', () => {
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharePresent()).toBe(true, `Share is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
expect(await toolbar.menu.isManagePermissionsPresent()).toBe(true, `Permissions is not displayed`);
await toolbar.closeMoreMenu();
});
it('Correct actions appear in the viewer toolbar for a locked file - []', async () => {
await dataTable.doubleClickOnRowByName(docxLockedPersonalFiles);
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed`);
expect(await toolbar.isPrintPresent()).toBe(true, `Print is not displayed`);
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharePresent()).toBe(true, `Share is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
await toolbar.closeMoreMenu();
});
@ -215,7 +248,7 @@ describe('Viewer actions', () => {
await manageVersionsDialog.clickClose();
});
// TODO: enable this once bug is fixed
// TODO: disabled until ACA-2176 is done
xit('Pressing ESC in the viewer closes only the action dialog - [C286314]', async () => {
await dataTable.doubleClickOnRowByName(docxPersonalFiles);
expect(await viewer.isViewerOpened()).toBe(true, 'Viewer is not opened');
@ -228,11 +261,12 @@ describe('Viewer actions', () => {
});
});
describe('on File Libraries', () => {
describe('file opened from File Libraries', () => {
const siteName = `site-${Utils.random()}`;
const destination = `destFL-${Utils.random()}`; let destinationId;
const docxLibraries = `docxFL-${Utils.random()}.docx`; let docxFileId;
const docxLockedLibraries = `docxLockedFL-${Utils.random()}.docx`; let docxLockedId;
const xlsxLibraries = `xlsxFL-${Utils.random()}.xlsx`;
const pdfLibraries = `pdfFL-${Utils.random()}.pdf`;
@ -241,6 +275,8 @@ describe('Viewer actions', () => {
const docLibId = await apis.user.sites.getDocLibId(siteName);
destinationId = (await apis.user.nodes.createFolder(destination)).entry.id;
docxFileId = (await apis.user.upload.uploadFileWithRename(docxFile, docLibId, docxLibraries)).entry.id;
docxLockedId = (await apis.user.upload.uploadFileWithRename(docxFile, docLibId, docxLockedLibraries)).entry.id;
await apis.user.nodes.lockFile(docxLockedId);
await apis.user.upload.uploadFileWithRename(xlsxFileForMove, docLibId, xlsxLibraries);
await apis.user.upload.uploadFileWithRename(pdfFileForDelete, docLibId, pdfLibraries);
@ -267,6 +303,56 @@ describe('Viewer actions', () => {
done();
});
it('Correct actions appear in the viewer toolbar - []', async () => {
await dataTable.doubleClickOnRowByName(docxLibraries);
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed`);
expect(await toolbar.isPrintPresent()).toBe(true, `Print is not displayed`);
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharePresent()).toBe(true, `Share is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
await toolbar.closeMoreMenu();
});
it('Correct actions appear in the viewer toolbar for a locked file - []', async () => {
await dataTable.doubleClickOnRowByName(docxLockedLibraries);
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed`);
expect(await toolbar.isPrintPresent()).toBe(true, `Print is not displayed`);
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharePresent()).toBe(true, `Share is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
await toolbar.closeMoreMenu();
});
it('Download action - [C286369]', async () => {
await dataTable.doubleClickOnRowByName(docxLibraries);
expect(await viewer.isViewerOpened()).toBe(true, 'Viewer is not opened');
@ -354,11 +440,12 @@ describe('Viewer actions', () => {
});
});
describe('on Recent Files', () => {
describe('file opened from Recent Files', () => {
const parent = `parentRF-${Utils.random()}`; let parentId;
const destination = `destRF-${Utils.random()}`; let destinationId;
const docxRecentFiles = `docxRF-${Utils.random()}.docx`; let docxFileId;
const docxLockedRecentFiles = `docxLockedRF-${Utils.random()}.docx`; let docxLockedId;
const xlsxRecentFiles = `xlsxRF-${Utils.random()}.xlsx`;
const pdfRecentFiles = `pdfRF-${Utils.random()}.pdf`;
@ -367,10 +454,12 @@ describe('Viewer actions', () => {
parentId = (await apis.user.nodes.createFolder(parent)).entry.id;
destinationId = (await apis.user.nodes.createFolder(destination)).entry.id;
docxFileId = (await apis.user.upload.uploadFileWithRename(docxFile, parentId, docxRecentFiles)).entry.id;
docxLockedId = (await apis.user.upload.uploadFileWithRename(docxFile, parentId, docxLockedRecentFiles)).entry.id;
await apis.user.nodes.lockFile(docxLockedId);
await apis.user.upload.uploadFileWithRename(xlsxFileForMove, parentId, xlsxRecentFiles);
await apis.user.upload.uploadFileWithRename(pdfFileForDelete, parentId, pdfRecentFiles);
await apis.user.search.waitForApi(username, {expect: 3});
await apis.user.search.waitForApi(username, {expect: 4});
await loginPage.loginWith(username);
done();
@ -393,6 +482,56 @@ describe('Viewer actions', () => {
done();
});
it('Correct actions appear in the viewer toolbar - []', async () => {
await dataTable.doubleClickOnRowByName(docxRecentFiles);
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed`);
expect(await toolbar.isPrintPresent()).toBe(true, `Print is not displayed`);
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharePresent()).toBe(true, `Share is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
await toolbar.closeMoreMenu();
});
it('Correct actions appear in the viewer toolbar for a locked file - []', async () => {
await dataTable.doubleClickOnRowByName(docxLockedRecentFiles);
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed`);
expect(await toolbar.isPrintPresent()).toBe(true, `Print is not displayed`);
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharePresent()).toBe(true, `Share is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
await toolbar.closeMoreMenu();
});
it('Download action - [C286383]', async () => {
await dataTable.doubleClickOnRowByName(docxRecentFiles);
expect(await viewer.isViewerOpened()).toBe(true, 'Viewer is not opened');
@ -481,11 +620,12 @@ describe('Viewer actions', () => {
});
});
describe('on Shared Files', () => {
describe('file opened from Shared Files', () => {
const parent = `parentSF-${Utils.random()}`; let parentId;
const destination = `destSF-${Utils.random()}`; let destinationId;
const docxSharedFiles = `docxSF-${Utils.random()}.docx`; let docxFileId;
const docxLockedSharedFiles = `docxLockedSF-${Utils.random()}.docx`; let docxLockedId;
const xlsxSharedFiles = `xlsxSF-${Utils.random()}.xlsx`; let xlsxFileId;
const pdfSharedFiles = `pdfSF-${Utils.random()}.pdf`; let pdfFileId;
@ -493,11 +633,13 @@ describe('Viewer actions', () => {
parentId = (await apis.user.nodes.createFolder(parent)).entry.id;
destinationId = (await apis.user.nodes.createFolder(destination)).entry.id;
docxFileId = (await apis.user.upload.uploadFileWithRename(docxFile, parentId, docxSharedFiles)).entry.id;
docxLockedId = (await apis.user.upload.uploadFileWithRename(docxFile, parentId, docxLockedSharedFiles)).entry.id;
xlsxFileId = (await apis.user.upload.uploadFileWithRename(xlsxFileForMove, parentId, xlsxSharedFiles)).entry.id;
pdfFileId = (await apis.user.upload.uploadFileWithRename(pdfFileForDelete, parentId, pdfSharedFiles)).entry.id;
await apis.user.nodes.lockFile(docxLockedId);
await apis.user.shared.shareFilesByIds([docxFileId, xlsxFileId, pdfFileId])
await apis.user.shared.waitForApi({expect: 3});
await apis.user.shared.shareFilesByIds([docxFileId, docxLockedId, xlsxFileId, pdfFileId])
await apis.user.shared.waitForApi({expect: 4});
await loginPage.loginWith(username);
done();
@ -520,6 +662,56 @@ describe('Viewer actions', () => {
done();
});
it('Correct actions appear in the viewer toolbar - []', async () => {
await dataTable.doubleClickOnRowByName(docxSharedFiles);
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed`);
expect(await toolbar.isPrintPresent()).toBe(true, `Print is not displayed`);
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharedLinkSettingsPresent()).toBe(true, `Shared link settings is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
await toolbar.closeMoreMenu();
});
it('Correct actions appear in the viewer toolbar for a locked file - []', async () => {
await dataTable.doubleClickOnRowByName(docxLockedSharedFiles);
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed`);
expect(await toolbar.isPrintPresent()).toBe(true, `Print is not displayed`);
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharedLinkSettingsPresent()).toBe(true, `Shared link settings is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
await toolbar.closeMoreMenu();
});
it('Download action - [C286376]', async () => {
await dataTable.doubleClickOnRowByName(docxSharedFiles);
expect(await viewer.isViewerOpened()).toBe(true, 'Viewer is not opened');
@ -608,13 +800,14 @@ describe('Viewer actions', () => {
});
});
describe('on Favorites', () => {
describe('file opened from Favorites', () => {
const parent = `parentFav-${Utils.random()}`;
let parentId;
const destination = `destFav-${Utils.random()}`;
let destinationId;
const docxFavorites = `docxFav-${Utils.random()}.docx`; let docxFileId;
const docxLockedFavorites = `docxLockedFav-${Utils.random()}.docx`; let docxLockedId;
const xlsxFavorites = `xlsxFav-${Utils.random()}.xlsx`; let xlsxFileId;
const pdfFavorites = `pdfFav-${Utils.random()}.pdf`; let pdfFileId;
@ -622,11 +815,13 @@ describe('Viewer actions', () => {
parentId = (await apis.user.nodes.createFolder(parent)).entry.id;
destinationId = (await apis.user.nodes.createFolder(destination)).entry.id;
docxFileId = (await apis.user.upload.uploadFileWithRename(docxFile, parentId, docxFavorites)).entry.id;
docxLockedId = (await apis.user.upload.uploadFileWithRename(docxFile, parentId, docxLockedFavorites)).entry.id;
xlsxFileId = (await apis.user.upload.uploadFileWithRename(xlsxFileForMove, parentId, xlsxFavorites)).entry.id;
pdfFileId = (await apis.user.upload.uploadFileWithRename(pdfFileForDelete, parentId, pdfFavorites)).entry.id;
await apis.user.nodes.lockFile(docxLockedId);
await apis.user.favorites.addFavoritesByIds('file', [docxFileId, xlsxFileId, pdfFileId])
await apis.user.favorites.waitForApi({expect: 3});
await apis.user.favorites.addFavoritesByIds('file', [docxFileId, docxLockedId, xlsxFileId, pdfFileId])
await apis.user.favorites.waitForApi({expect: 4});
await loginPage.loginWith(username);
done();
@ -649,6 +844,56 @@ describe('Viewer actions', () => {
done();
});
it('Correct actions appear in the viewer toolbar - []', async () => {
await dataTable.doubleClickOnRowByName(docxFavorites);
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed`);
expect(await toolbar.isPrintPresent()).toBe(true, `Print is not displayed`);
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharePresent()).toBe(true, `Share is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(true, `Edit offline is not displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(false, `Cancel editing is displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
await toolbar.closeMoreMenu();
});
it('Correct actions appear in the viewer toolbar for a locked file - []', async () => {
await dataTable.doubleClickOnRowByName(docxLockedFavorites);
await viewer.waitForViewerToOpen();
expect(await toolbar.isEmpty()).toBe(false, `viewer toolbar is empty`);
expect(await toolbar.isViewPresent()).toBe(false, `View is displayed`);
expect(await toolbar.isDownloadPresent()).toBe(true, `Download is not displayed`);
expect(await toolbar.isPrintPresent()).toBe(true, `Print is not displayed`);
expect(await toolbar.isFullScreenPresent()).toBe(true, `Full screen is not displayed`);
expect(await toolbar.isSharePresent()).toBe(true, `Share is not displayed`);
expect(await toolbar.isViewDetailsPresent()).toBe(true, `view details is not displayed`);
await toolbar.openMoreMenu();
expect(await toolbar.menu.isEditOfflinePresent()).toBe(false, `Edit offline is displayed`);
expect(await toolbar.menu.isCancelEditingPresent()).toBe(true, `Cancel editing is not displayed`);
expect(await toolbar.menu.isFavoritePresent()).toBe(true, `Favorite is not displayed`);
expect(await toolbar.menu.isCopyPresent()).toBe(true, `Copy is not displayed`);
expect(await toolbar.menu.isMovePresent()).toBe(true, `Move is not displayed`);
expect(await toolbar.menu.isDeletePresent()).toBe(true, `Delete is not displayed`);
expect(await toolbar.menu.isManageVersionsPresent()).toBe(true, `Manage versions is not displayed`);
await toolbar.closeMoreMenu();
});
it('Download action - [C286390]', async () => {
await dataTable.doubleClickOnRowByName(docxFavorites);
expect(await viewer.isViewerOpened()).toBe(true, 'Viewer is not opened');

3
e2e/utilities/repo-client/apis/nodes/nodes-api.ts
View File

@ -207,10 +207,11 @@ export class NodesApi extends RepoApi {
}
// lock node
async lockFile(nodeId: string, lockType: string = 'FULL') {
async lockFile(nodeId: string, lockType: string = 'ALLOW_OWNER_CHANGES') {
const data = <NodeBodyLock>{
type: lockType
};
await this.apiAuth();
return await this.nodesApi.lockNode(nodeId, data );
}

2
src/app/extensions/core.extensions.module.ts
View File

@ -147,6 +147,8 @@ export class CoreExtensionsModule {
'app.navigation.isSearchResults': nav.isSearchResults,
'app.navigation.isNotSearchResults': nav.isNotSearchResults,
'app.navigation.isPreview': nav.isPreview,
'app.navigation.isSharedPreview': nav.isSharedPreview,
'app.navigation.isFavoritesPreview': nav.isFavoritesPreview,
'repository.isQuickShareEnabled': repository.hasQuickShareEnabled
});

6
src/app/extensions/evaluators/app.evaluators.ts
View File

@ -335,8 +335,8 @@ export function canUnlockFile(
): boolean {
const { file } = context.selection;
return (
(isWriteLocked(context, ...args) &&
context.permissions.check(file.entry, ['delete'])) ||
isUserWriteLockOwner(context, ...args)
isWriteLocked(context, ...args) &&
(context.permissions.check(file.entry, ['delete']) ||
isUserWriteLockOwner(context, ...args))
);
}

20
src/app/extensions/evaluators/navigation.evaluators.ts
View File

@ -140,3 +140,23 @@ export function isPreview(
const { url } = context.navigation;
return url && url.includes('/preview/');
}
export function isSharedPreview(
context: RuleContext,
...args: RuleParameter[]
): boolean {
const { url } = context.navigation;
console.log(
'===== isSharedPreview: ',
url && url.startsWith('/shared/preview/')
);
return url && url.startsWith('/shared/preview/');
}
export function isFavoritesPreview(
context: RuleContext,
...args: RuleParameter[]
): boolean {
const { url } = context.navigation;
return url && url.startsWith('/favorites/preview/');
}

16
src/assets/app.extensions.json
View File

@ -231,6 +231,22 @@
"parameters": [
{ "type": "rule", "value": "app.selection.file" },
{ "type": "rule", "value": "app.navigation.isNotTrashcan" },
{
"type": "rule",
"value": "core.some",
"parameters": [
{ "type": "rule", "value": "app.navigation.isNotFavorites" },
{ "type": "rule", "value": "app.navigation.isFavoritesPreview" }
]
},
{
"type": "rule",
"value": "core.some",
"parameters": [
{ "type": "rule", "value": "app.navigation.isNotSharedFiles" },
{ "type": "rule", "value": "app.navigation.isSharedPreview" }
]
},
{
"type": "rule",
"value": "core.some",