[ACS-12752] refactor special permissions e2es (#5378)

e2e/playwright/special-permissions-actions-available/exclude.tests.json

@@ -1,17 +1 @@
-{
+{}
-  "all": {
-    "XAT-4845": "https://hyland.atlassian.net/browse/ACS-12214",
-    "XAT-4835": "https://hyland.atlassian.net/browse/ACS-12214",
-    "XAT-4843": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4859": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4860": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4846": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4861": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4862": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4863": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4864": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4865": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4866": "https://hyland.atlassian.net/browse/ACS-12752",
-    "XAT-4867": "https://hyland.atlassian.net/browse/ACS-12752"
-  }
-}

e2e/playwright/special-permissions-actions-available/src/tests/folders-actions.e2e.ts

@@ -22,7 +22,17 @@
  * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
  */
 
-import { ApiClientFactory, FavoritesPageApi, PersonalFilesPage, NodesApi, TrashcanApi, Utils, test, timeouts } from '@alfresco/aca-playwright-shared';
+import {
+  ApiClientFactory,
+  FavoritesPageApi,
+  FolderActionsData,
+  PersonalFilesPage,
+  NodesApi,
+  TrashcanApi,
+  Utils,
+  test,
+  timeouts
+} from '@alfresco/aca-playwright-shared';
 import * as testData from '@alfresco/aca-playwright-shared';
 
 test.describe('Folders - available actions : ', () => {
@@ -41,6 +51,12 @@ test.describe('Folders - available actions : ', () => {
     await myPersonalFiles.matMenu.verifyActualMoreActions(expectedToolbarMore);
   }
 
+  async function checkFolderRowActions(personalFiles: PersonalFilesPage, folder: FolderActionsData): Promise<void> {
+    await personalFiles.dataTable.getRowByName(folder.name).click({ button: 'right' });
+    await personalFiles.matMenu.verifyActualMoreActions(folder.contextMenu);
+    await checkActionsAvailable(personalFiles, folder.toolbarPrimary, folder.toolbarMore);
+  }
+
   test.beforeAll(async () => {
     test.setTimeout(timeouts.extendedTest);
     const apiClientFactory = new ApiClientFactory();
@@ -70,15 +86,11 @@ test.describe('Folders - available actions : ', () => {
     });
 
     test('[XAT-4637] Actions for a folder, not favorite', async ({ personalFiles }) => {
-      await personalFiles.dataTable.getRowByName(testData.folderFile.name).click({ button: 'right' });
+      await checkFolderRowActions(personalFiles, testData.folderFile);
-      await personalFiles.matMenu.verifyActualMoreActions(testData.folderFile.contextMenu);
-      await checkActionsAvailable(personalFiles, testData.folderFile.toolbarPrimary, testData.folderFile.toolbarMore);
     });
 
     test('[XAT-4638] Actions for a folder, favorite', async ({ personalFiles }) => {
-      await personalFiles.dataTable.getRowByName(testData.folderFavFile.name).click({ button: 'right' });
+      await checkFolderRowActions(personalFiles, testData.folderFavFile);
-      await personalFiles.matMenu.verifyActualMoreActions(testData.folderFavFile.contextMenu);
-      await checkActionsAvailable(personalFiles, testData.folderFavFile.toolbarPrimary, testData.folderFavFile.toolbarMore);
     });
 
     test('[XAT-4642] Actions on multiple folders', async ({ personalFiles }) => {

e2e/playwright/special-permissions-actions-available/src/tests/other-permissions.ts

@@ -89,7 +89,7 @@ export function collaboratorTests(userCollaborator: string, siteName: string) {
     });
 
     test('[XAT-4847] Toolbar - Actions appear correctly for a file - Collaborator - Search Results', async ({ searchPage, myLibrariesPage }) => {
-      await searchPage.searchWithin(testData.fileSharedFav.name, 'filesAndFolders');
+      await searchPage.searchWithin(testData.fileSharedFav.random, 'filesAndFolders', 'formula');
       await checkActionsAvailable(
         myLibrariesPage,
         testData.fileSharedFav.name,
@@ -131,7 +131,7 @@ export function collaboratorTests(userCollaborator: string, siteName: string) {
       });
 
       test('[XAT-4851] Correct actions appear for file in viewer - Collaborator - Search', async ({ searchPage, myLibrariesPage }) => {
-        await searchPage.searchWithin(testData.fileDocxSharedFav.name, 'filesAndFolders');
+        await searchPage.searchWithin(testData.fileDocxSharedFav.random, 'filesAndFolders', 'formula');
         await checkActionsViewerAvailable(
           myLibrariesPage,
           testData.fileDocxSharedFav.name,
@@ -143,7 +143,7 @@ export function collaboratorTests(userCollaborator: string, siteName: string) {
   });
 }
 
-export function filesLockedByCurrentUser(userDemoted: string, siteName?: string) {
+export function filesLockedByCurrentUser(userDemoted: string, siteName: string) {
   test.describe('available actions : ', () => {
     test.beforeEach(async ({ loginPage }) => {
       await loginPage.navigate();
@@ -156,9 +156,9 @@ export function filesLockedByCurrentUser(userDemoted: string, siteName?: string)
         await myLibrariesPage.dataTable.performClickFolderOrFileToOpen(siteName);
         await checkActionsAvailable(
           myLibrariesPage,
-          testData.fileLockedByUserWorkingCopyName,
+          testData.fileLockedByUser.name,
-          testData.collaboratorWorkingCopyToolbarPrimary,
+          testData.collaboratorToolbarPrimary,
-          testData.collaboratorLockWorkingCopyToolbarMore
+          testData.collaboratorLockCurrentUserToolbarMore
         );
       });
 
@@ -166,9 +166,9 @@ export function filesLockedByCurrentUser(userDemoted: string, siteName?: string)
         await sharedPage.navigate();
         await checkActionsAvailable(
           myLibrariesPage,
-          testData.fileLockedByUser,
+          testData.fileLockedByUser.name,
-          testData.collaboratorLockedToolbarPrimary,
+          testData.collaboratorToolbarPrimary,
-          testData.collaboratorLockedSharedViewerToolbarMore
+          testData.collaboratorLockCurrentUserToolbarMore
         );
       });
 
@@ -176,19 +176,19 @@ export function filesLockedByCurrentUser(userDemoted: string, siteName?: string)
         await favoritePage.navigate();
         await checkActionsAvailable(
           myLibrariesPage,
-          testData.fileLockedByUser,
+          testData.fileLockedByUser.name,
-          testData.collaboratorLockedToolbarPrimary,
+          testData.collaboratorToolbarPrimary,
-          testData.favoritesCheckedOutCollaboratorToolbarMore
+          testData.collaboratorLockCurrentUserToolbarMore
         );
       });
 
       test('[XAT-4855] Toolbar - Correct actions appear for file - on Search Results - Locked File', async ({ searchPage, myLibrariesPage }) => {
-        await searchPage.searchWithin(testData.fileLockedByUserWorkingCopyName, 'filesAndFolders');
+        await searchPage.searchWithin(testData.fileLockedByUser.random, 'filesAndFolders', 'formula');
         await checkActionsAvailable(
           myLibrariesPage,
-          testData.fileLockedByUserWorkingCopyName,
+          testData.fileLockedByUser.name,
-          testData.collaboratorWorkingCopyToolbarPrimary,
+          testData.collaboratorToolbarPrimary,
-          testData.lockedWorkingCopyToolbarMore
+          testData.collaboratorLockCurrentUserToolbarMore
         );
       });
     });
@@ -199,9 +199,9 @@ export function filesLockedByCurrentUser(userDemoted: string, siteName?: string)
         await myLibrariesPage.dataTable.performClickFolderOrFileToOpen(siteName);
         await checkActionsViewerAvailable(
           myLibrariesPage,
-          testData.fileLockedByUserWorkingCopyName,
+          testData.fileLockedByUser.name,
-          testData.collaboratorSharedWorkingCopyToolbarPrimary,
+          testData.collaboratorViewerLockedToolbarPrimary,
-          testData.collaboratorLockWorkingCopyToolbarMore
+          testData.collaboratorLockCurrentUserToolbarMore
         );
       });
 
@@ -209,9 +209,9 @@ export function filesLockedByCurrentUser(userDemoted: string, siteName?: string)
         await sharedPage.navigate();
         await checkActionsViewerAvailable(
           myLibrariesPage,
-          testData.fileLockedByUser,
+          testData.fileLockedByUser.name,
-          testData.collaboratorLockedOriginalSharedViewerToolbarPrimary,
+          testData.collaboratorViewerLockedToolbarPrimary,
-          testData.collaboratorLockedSharedViewerToolbarMore
+          testData.collaboratorLockCurrentUserToolbarMore
         );
       });
 
@@ -219,18 +219,18 @@ export function filesLockedByCurrentUser(userDemoted: string, siteName?: string)
         await favoritePage.navigate();
         await checkActionsViewerAvailable(
           myLibrariesPage,
-          testData.fileLockedByUser,
+          testData.fileLockedByUser.name,
-          testData.collaboratorLockedOriginalSharedViewerToolbarPrimary,
+          testData.collaboratorViewerLockedToolbarPrimary,
-          testData.collaboratorLockedSharedViewerToolbarMore
+          testData.collaboratorLockCurrentUserToolbarMore
         );
       });
 
       test('[XAT-4859] Correct actions appear for file opened from Search Results - Locked File', async ({ searchPage, myLibrariesPage }) => {
-        await searchPage.searchWithin(testData.fileLockedByUserWorkingCopyName, 'filesAndFolders');
+        await searchPage.searchWithin(testData.fileLockedByUser.random, 'filesAndFolders', 'formula');
         await checkActionsViewerAvailable(
           myLibrariesPage,
-          testData.fileLockedByUserWorkingCopyName,
+          testData.fileLockedByUser.name,
-          testData.collaboratorSharedToolbarPrimary,
+          testData.collaboratorViewerLockedToolbarPrimary,
           testData.collaboratorLockCurrentUserToolbarMore
         );
       });
@@ -238,7 +238,7 @@ export function filesLockedByCurrentUser(userDemoted: string, siteName?: string)
   });
 }
 
-export function filesLockedByOtherUser(userManager: string, siteName?: string) {
+export function filesLockedByOtherUser(userManager: string, siteName: string) {
   test.describe('available actions : ', () => {
     test.beforeEach(async ({ loginPage }) => {
       await Utils.tryLoginUser(loginPage, userManager, userManager, 'beforeEach failed');
@@ -249,7 +249,7 @@ export function filesLockedByOtherUser(userManager: string, siteName?: string) {
       await myLibrariesPage.dataTable.performClickFolderOrFileToOpen(siteName);
       await checkActionsAvailable(
         myLibrariesPage,
-        testData.fileLockedByUser,
+        testData.fileLockedByUser.name,
         testData.collaboratorToolbarPrimary,
         testData.collaboratorLockOtherUserToolbarMore
       );
@@ -259,18 +259,13 @@ export function filesLockedByOtherUser(userManager: string, siteName?: string) {
       sharedPage,
       myLibrariesPage
     }) => {
-      const expectedToolbarMore = [
-        'Cancel Editing',
-        'Upload New Version',
-        'Remove Favorite',
-        'Move',
-        'Copy',
-        'Delete',
-        'Manage Versions',
-        'Permissions'
-      ];
       await sharedPage.navigate();
-      await checkActionsAvailable(myLibrariesPage, testData.fileLockedByUser, testData.collaboratorToolbarPrimary, expectedToolbarMore);
+      await checkActionsAvailable(
+        myLibrariesPage,
+        testData.fileLockedByUser.name,
+        testData.collaboratorToolbarPrimary,
+        testData.collaboratorLockOtherUserToolbarMore
+      );
     });
 
     test('[XAT-4862] Toolbar - Correct actions appear for file - on Favorites - Locked File - Other User', async ({
@@ -280,9 +275,9 @@ export function filesLockedByOtherUser(userManager: string, siteName?: string) {
       await favoritePage.navigate();
       await checkActionsAvailable(
         myLibrariesPage,
-        testData.fileLockedByUser,
+        testData.fileLockedByUser.name,
         testData.collaboratorToolbarPrimary,
-        testData.favoritesCollaboratorToolbarMore
+        testData.collaboratorLockOtherUserToolbarMore
       );
     });
 
@@ -290,10 +285,10 @@ export function filesLockedByOtherUser(userManager: string, siteName?: string) {
       searchPage,
       myLibrariesPage
     }) => {
-      await searchPage.searchWithin(testData.fileLockedByUser, 'filesAndFolders');
+      await searchPage.searchWithin(testData.fileLockedByUser.random, 'filesAndFolders', 'formula');
       await checkActionsAvailable(
         myLibrariesPage,
-        testData.fileLockedByUser,
+        testData.fileLockedByUser.name,
         testData.collaboratorToolbarPrimary,
         testData.collaboratorLockOtherUserSearchToolbarMore
       );
@@ -305,8 +300,8 @@ export function filesLockedByOtherUser(userManager: string, siteName?: string) {
         await myLibrariesPage.dataTable.performClickFolderOrFileToOpen(siteName);
         await checkActionsViewerAvailable(
           myLibrariesPage,
-          testData.fileLockedByUser,
+          testData.fileLockedByUser.name,
-          testData.collaboratorSharedToolbarPrimary,
+          testData.collaboratorViewerLockedToolbarPrimary,
           testData.collaboratorLockOtherUserToolbarMore
         );
       });
@@ -315,8 +310,8 @@ export function filesLockedByOtherUser(userManager: string, siteName?: string) {
         await sharedPage.navigate();
         await checkActionsViewerAvailable(
           myLibrariesPage,
-          testData.fileLockedByUser,
+          testData.fileLockedByUser.name,
-          testData.collaboratorSharedToolbarPrimary,
+          testData.collaboratorViewerLockedToolbarPrimary,
           testData.collaboratorLockOtherUserToolbarMore
         );
       });
@@ -325,18 +320,18 @@ export function filesLockedByOtherUser(userManager: string, siteName?: string) {
         await favoritePage.navigate();
         await checkActionsViewerAvailable(
           myLibrariesPage,
-          testData.fileLockedByUser,
+          testData.fileLockedByUser.name,
-          testData.collaboratorSharedToolbarPrimary,
+          testData.collaboratorViewerLockedToolbarPrimary,
           testData.collaboratorLockOtherUserToolbarMore
         );
       });
 
       test('[XAT-4867] Correct actions appear for file opened from Search Results - viewer - locked', async ({ searchPage, myLibrariesPage }) => {
-        await searchPage.searchWithin(testData.fileLockedByUser, 'filesAndFolders');
+        await searchPage.searchWithin(testData.fileLockedByUser.random, 'filesAndFolders', 'formula');
         await checkActionsViewerAvailable(
           myLibrariesPage,
-          testData.fileLockedByUser,
+          testData.fileLockedByUser.name,
-          testData.collaboratorSharedToolbarPrimary,
+          testData.collaboratorViewerLockedToolbarPrimary,
           testData.collaboratorLockOtherUserSearchToolbarMore
         );
       });

e2e/playwright/special-permissions-actions-available/src/tests/repository-permissions.e2e.ts

@@ -47,6 +47,14 @@ test.describe('Repository — Permissions routing', () => {
     await page.pagination.clickMenuItem('Permissions');
   };
 
+  const expectPermissionsRoute = async (page: PersonalFilesPage, detailsPath: string, forbiddenBase: string): Promise<void> => {
+    await page.page.waitForURL(`**/${detailsPath}/permissions`);
+    const url = page.page.url();
+    expect(url).toContain(`/${detailsPath}/permissions`);
+    expect(url, `URL must not leak into /${forbiddenBase}`).not.toContain(`/${forbiddenBase}/details/`);
+    await expect(page.infoDrawer.expandedDetailsPermissionsTab).toBeVisible();
+  };
+
   test.describe('signed in as admin', () => {
     let userNodesApi: NodesApi;
     let trashcanApi: TrashcanApi;
@@ -81,10 +89,7 @@ test.describe('Repository — Permissions routing', () => {
 
       await openPermissionsFromContextMenu(personalFiles, testData.repoFile.name);
 
-      await personalFiles.page.waitForURL(`**/repository/details/${testData.repoFile.id}/permissions`);
+      await expectPermissionsRoute(personalFiles, `repository/details/${testData.repoFile.id}`, 'personal-files');
-      expect(personalFiles.page.url()).toContain(`/repository/details/${testData.repoFile.id}/permissions`);
-      expect(personalFiles.page.url(), 'URL must not redirect to /personal-files').not.toContain('/personal-files/details/');
-      await expect(personalFiles.infoDrawer.expandedDetailsPermissionsTab).toBeVisible();
     });
 
     test('[XAT-19609] Permissions from toolbar on Repository preserves the /repository route', async ({ personalFiles }) => {
@@ -95,10 +100,7 @@ test.describe('Repository — Permissions routing', () => {
       await personalFiles.dataTable.selectItems(testData.repoFile.name);
       await personalFiles.clickMoreActionsButton('Permissions');
 
-      await personalFiles.page.waitForURL(`**/repository/details/${testData.repoFile.id}/permissions`);
+      await expectPermissionsRoute(personalFiles, `repository/details/${testData.repoFile.id}`, 'personal-files');
-      expect(personalFiles.page.url()).toContain(`/repository/details/${testData.repoFile.id}/permissions`);
-      expect(personalFiles.page.url(), 'URL must not redirect to /personal-files').not.toContain('/personal-files/details/');
-      await expect(personalFiles.infoDrawer.expandedDetailsPermissionsTab).toBeVisible();
     });
 
     test('[XAT-19610] Permissions from Shared keeps a Repository file on /repository', async ({ sharedPage }) => {
@@ -161,10 +163,7 @@ test.describe('Repository — Permissions routing', () => {
 
       await openPermissionsFromContextMenu(personalFiles, personalFile.name);
 
-      await personalFiles.page.waitForURL(`**/personal-files/details/${personalFile.id}/permissions`);
+      await expectPermissionsRoute(personalFiles, `personal-files/details/${personalFile.id}`, 'repository');
-      expect(personalFiles.page.url()).toContain(`/personal-files/details/${personalFile.id}/permissions`);
-      expect(personalFiles.page.url(), 'Personal file must not leak into /repository').not.toContain('/repository/details/');
-      await expect(personalFiles.infoDrawer.expandedDetailsPermissionsTab).toBeVisible();
     });
   });
 });

e2e/playwright/special-permissions-actions-available/src/tests/special-permissions-actions.e2e.ts

@@ -41,179 +41,282 @@ import {
 import { Site } from '@alfresco/js-api';
 
 test.describe('Special permissions : ', () => {
-  const apiClientFactory = new ApiClientFactory();
+  const random = Utils.random();
-  const random = testData.random;
-  let docLibId: string;
 
-  const sitePrivate = `site-private2-${random}`;
+  test.describe('Consumer', () => {
+    const apiClientFactory = new ApiClientFactory();
+    const sitePrivate = `site-private-consumer-${random}`;
+    const userManager = `manager-consumer-${random}`;
+    const userConsumer = `consumer-${random}`;
 
-  const userManager = `manager-${random}`;
+    let docLibId: string;
-  const userConsumer = `consumer-${random}`;
+    let fileDocxFavId: string;
-  const userCollaborator = `collaborator-${random}`;
+    let fileFavId: string;
-  const userDemoted = `demoted-${random}`;
+    let fileDocxSharedId: string;
+    let fileDocxSharedFavId: string;
+    let fileSharedId: string;
+    let fileSharedFavId: string;
+    let fileLockedId: string;
+    let fileFavLockedId: string;
+    let fileSharedLockedId: string;
+    let fileSharedFavLockedId: string;
 
-  let fileDocxFavId: string;
+    let managerNodeActions: NodesApi;
-  let fileFavId: string;
+    let managerSiteActions: SitesApi;
-  let fileDocxSharedId: string;
+    let managerFileActions: FileActionsApi;
-  let fileDocxSharedFavId: string;
+    let managerSearchActions: SearchApi;
-  let fileSharedId: string;
+    let consumerFavoritesActions: FavoritesPageApi;
-  let fileSharedFavId: string;
+    let consumerShareActions: SharedLinksApi;
-  let fileLockedId: string;
-  let fileFavLockedId: string;
-  let fileSharedLockedId: string;
-  let fileSharedFavLockedId: string;
-  let fileGranularPermissionId: string;
-  let fileLockedByUserId: string;
-  let folderFavId: string;
-  let folderFav2Id: string;
 
-  let managerNodeActions: NodesApi;
+    test.beforeAll(async () => {
-  let consumerFavoritesActions: FavoritesPageApi;
+      test.setTimeout(timeouts.extendedLongTest);
-  let managerFavoritesActions: FavoritesPageApi;
+      await apiClientFactory.setUpAcaBackend('admin');
-  let collaboratorFavoritesActions: FavoritesPageApi;
+      await apiClientFactory.createUser({ username: userManager });
-  let demotedUserFavoritesActions: FavoritesPageApi;
+      await apiClientFactory.createUser({ username: userConsumer });
-  let managerUserShareActions: SharedLinksApi;
-  let demotedUserShareActions: SharedLinksApi;
-  let consumerShareActions: SharedLinksApi;
-  let managerSiteActions: SitesApi;
-  let managerFileActions: FileActionsApi;
-  let demotedUserFileActions: FileActionsApi;
-  let managerSearchActions: SearchApi;
 
-  test.beforeAll(async () => {
+      managerNodeActions = await NodesApi.initialize(userManager, userManager);
-    test.setTimeout(timeouts.extendedLongTest);
+      managerSiteActions = await SitesApi.initialize(userManager, userManager);
-    await apiClientFactory.setUpAcaBackend('admin');
+      managerFileActions = await FileActionsApi.initialize(userManager, userManager);
-    await apiClientFactory.createUser({ username: userManager });
+      managerSearchActions = await SearchApi.initialize(userManager, userManager);
-    await apiClientFactory.createUser({ username: userConsumer });
+      consumerFavoritesActions = await FavoritesPageApi.initialize(userConsumer, userConsumer);
-    await apiClientFactory.createUser({ username: userCollaborator });
+      consumerShareActions = await SharedLinksApi.initialize(userConsumer, userConsumer);
-    await apiClientFactory.createUser({ username: userDemoted });
 
-    managerNodeActions = await NodesApi.initialize(userManager, userManager);
+      const consumerFavoritesTotalItems = await consumerFavoritesActions.getFavoritesTotalItems(userConsumer);
-    consumerFavoritesActions = await FavoritesPageApi.initialize(userConsumer, userConsumer);
+      const managerSearchTotalItems = await managerSearchActions.getTotalItems(userManager);
-    collaboratorFavoritesActions = await FavoritesPageApi.initialize(userCollaborator, userCollaborator);
-    demotedUserFavoritesActions = await FavoritesPageApi.initialize(userDemoted, userDemoted);
-    managerFavoritesActions = await FavoritesPageApi.initialize(userManager, userManager);
-    managerSearchActions = await SearchApi.initialize(userManager, userManager);
-    managerSiteActions = await SitesApi.initialize(userManager, userManager);
-    managerFileActions = await FileActionsApi.initialize(userManager, userManager);
-    demotedUserFileActions = await FileActionsApi.initialize(userDemoted, userDemoted);
-    managerUserShareActions = await SharedLinksApi.initialize(userManager, userManager);
-    demotedUserShareActions = await SharedLinksApi.initialize(userDemoted, userDemoted);
-    consumerShareActions = await SharedLinksApi.initialize(userConsumer, userConsumer);
 
-    const consumerFavoritesTotalItems = await consumerFavoritesActions.getFavoritesTotalItems(userConsumer);
+      await managerSiteActions.createSite(sitePrivate, Site.VisibilityEnum.PRIVATE);
-    const managerSearchTotalItems = await managerSearchActions.getTotalItems(userManager);
+      docLibId = await managerSiteActions.getDocLibId(sitePrivate);
-    const collaboratorFavoritesTotalItems = await collaboratorFavoritesActions.getFavoritesTotalItems(userCollaborator);
+      await managerSiteActions.addSiteMember(sitePrivate, userConsumer, Site.RoleEnum.SiteConsumer);
-    const demotedUserFavoritesTotalItems = await demotedUserFavoritesActions.getFavoritesTotalItems(userDemoted);
 
-    await managerSiteActions.createSite(sitePrivate, Site.VisibilityEnum.PRIVATE);
+      await managerFileActions.uploadFileWithRename(TEST_FILES.DOCX.path, testData.fileDocx.name, docLibId);
-    docLibId = await managerSiteActions.getDocLibId(sitePrivate);
+      fileDocxFavId = (await managerFileActions.uploadFileWithRename(TEST_FILES.DOCX.path, testData.fileDocxFav.name, docLibId)).entry.id;
-    await managerSiteActions.addSiteMember(sitePrivate, userConsumer, Site.RoleEnum.SiteConsumer);
+      await managerNodeActions.createFile(testData.file.name, docLibId, '', '', '', true, ['cm:versionable']);
-    await managerSiteActions.addSiteMember(sitePrivate, userCollaborator, Site.RoleEnum.SiteCollaborator);
+      fileFavId = (await managerNodeActions.createFile(testData.fileFav.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
-    await managerSiteActions.addSiteMember(sitePrivate, userDemoted, Site.RoleEnum.SiteManager);
+      await managerNodeActions.createFile(testData.fileNotVersionable.name, docLibId, '', '', '', true, []);
-    const managerFavoritesTotalItems = await managerFavoritesActions.getFavoritesTotalItems(userManager);
+      fileDocxSharedId = (await managerFileActions.uploadFileWithRename(TEST_FILES.DOCX.path, testData.fileDocxShared.name, docLibId)).entry.id;
+      fileDocxSharedFavId = (await managerFileActions.uploadFileWithRename(TEST_FILES.DOCX.path, testData.fileDocxSharedFav.name, docLibId)).entry.id;
+      fileSharedId = (await managerNodeActions.createFile(testData.fileShared.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
+      fileSharedFavId = (await managerNodeActions.createFile(testData.fileSharedFav.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
+      fileLockedId = (await managerNodeActions.createFile(testData.fileLocked.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
+      fileFavLockedId = (await managerNodeActions.createFile(testData.fileFavLocked.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
+      fileSharedLockedId = (await managerNodeActions.createFile(testData.fileSharedLocked.name, docLibId, '', '', '', true, ['cm:versionable'])).entry
+        .id;
+      fileSharedFavLockedId = (await managerNodeActions.createFile(testData.fileSharedFavLocked.name, docLibId, '', '', '', true, ['cm:versionable']))
+        .entry.id;
 
-    await managerFileActions.uploadFileWithRename(TEST_FILES.DOCX.path, testData.fileDocx.name, docLibId);
+      await consumerFavoritesActions.addFavoritesByIds('file', [
-    fileDocxFavId = (await managerFileActions.uploadFileWithRename(TEST_FILES.DOCX.path, testData.fileDocxFav.name, docLibId)).entry.id;
+        fileDocxFavId,
-    await managerNodeActions.createFile(testData.file.name, docLibId, '', '', '', true, ['cm:versionable']);
+        fileFavId,
-    fileFavId = (await managerNodeActions.createFile(testData.fileFav.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
+        fileDocxSharedFavId,
-    await managerNodeActions.createFile(testData.fileNotVersionable.name, docLibId, '', '', '', true, []);
+        fileSharedFavId,
-    fileDocxSharedId = (await managerFileActions.uploadFileWithRename(TEST_FILES.DOCX.path, testData.fileDocxShared.name, docLibId)).entry.id;
+        fileFavLockedId,
-    fileDocxSharedFavId = (await managerFileActions.uploadFileWithRename(TEST_FILES.DOCX.path, testData.fileDocxSharedFav.name, docLibId)).entry.id;
+        fileSharedFavLockedId
-    fileSharedId = (await managerNodeActions.createFile(testData.fileShared.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
+      ]);
-    fileSharedFavId = (await managerNodeActions.createFile(testData.fileSharedFav.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
-    fileLockedId = (await managerNodeActions.createFile(testData.fileLocked.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
-    fileFavLockedId = (await managerNodeActions.createFile(testData.fileFavLocked.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
-    fileSharedLockedId = (await managerNodeActions.createFile(testData.fileSharedLocked.name, docLibId, '', '', '', true, ['cm:versionable'])).entry
-      .id;
-    fileSharedFavLockedId = (await managerNodeActions.createFile(testData.fileSharedFavLocked.name, docLibId, '', '', '', true, ['cm:versionable']))
-      .entry.id;
-    fileGranularPermissionId = (await managerNodeActions.createFile(testData.fileGranularPermission, docLibId, '', '', '', true, ['cm:versionable']))
-      .entry.id;
 
-    fileLockedByUserId = (await managerNodeActions.createFile(testData.fileLockedByUser, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
+      await consumerShareActions.shareFilesByIds([
-    await demotedUserFileActions.checkoutNode(fileLockedByUserId);
-    await demotedUserFavoritesActions.addFavoriteById('file', fileLockedByUserId);
-    await demotedUserShareActions.shareFileById(fileLockedByUserId);
-    await managerSiteActions.updateSiteMember(sitePrivate, userDemoted, Site.RoleEnum.SiteConsumer);
-
-    await managerNodeActions.createFolder(testData.folder.name, docLibId);
-    folderFavId = (await managerNodeActions.createFolder(testData.folderFav.name, docLibId)).entry.id;
-    folderFav2Id = (await managerNodeActions.createFolder(testData.folderFav2.name, docLibId)).entry.id;
-
-    await consumerFavoritesActions.addFavoritesByIds('folder', [folderFavId, folderFav2Id]);
-    await collaboratorFavoritesActions.addFavoritesByIds('file', [fileDocxSharedFavId, fileSharedFavId]);
-    await managerFavoritesActions.addFavoriteById('file', fileLockedByUserId);
-    await consumerFavoritesActions.addFavoritesByIds('file', [
-      fileDocxFavId,
-      fileFavId,
-      fileDocxSharedFavId,
-      fileSharedFavId,
-      fileFavLockedId,
-      fileSharedFavLockedId,
-      fileGranularPermissionId
-    ]);
-
-    await consumerShareActions.shareFilesByIds([
-      fileDocxSharedId,
-      fileDocxSharedFavId,
-      fileSharedId,
-      fileSharedFavId,
-      fileSharedLockedId,
-      fileSharedFavLockedId,
-      fileGranularPermissionId
-    ]);
-
-    await Promise.all([
-      managerFileActions.checkoutNode(fileLockedId),
-      managerFileActions.checkoutNode(fileFavLockedId),
-      managerFileActions.checkoutNode(fileSharedLockedId),
-      managerFileActions.checkoutNode(fileSharedFavLockedId)
-    ]);
-
-    await managerNodeActions.setGranularPermission(fileGranularPermissionId, userConsumer, Site.RoleEnum.SiteManager, false);
-
-    await collaboratorFavoritesActions.isFavoriteWithRetry(userCollaborator, fileSharedFavId, { expect: true });
-    await demotedUserFavoritesActions.isFavoriteWithRetry(userDemoted, fileLockedByUserId, { expect: true });
-    await managerFavoritesActions.isFavoriteWithRetry(userManager, fileLockedByUserId, { expect: true });
-    await Promise.all([
-      consumerFavoritesActions.waitForApi(userConsumer, { expect: consumerFavoritesTotalItems + 9 }),
-      managerUserShareActions.waitForFilesToBeShared([
         fileDocxSharedId,
         fileDocxSharedFavId,
         fileSharedId,
         fileSharedFavId,
         fileSharedLockedId,
-        fileSharedFavLockedId,
+        fileSharedFavLockedId
-        fileGranularPermissionId,
+      ]);
-        fileLockedByUserId
-      ]),
-      managerSearchActions.waitForApi(userManager, { expect: managerSearchTotalItems + 14 }),
-      collaboratorFavoritesActions.waitForApi(userCollaborator, { expect: collaboratorFavoritesTotalItems + 2 }),
-      demotedUserFavoritesActions.waitForApi(userDemoted, { expect: demotedUserFavoritesTotalItems + 1 }),
-      managerFavoritesActions.waitForApi(userManager, { expect: managerFavoritesTotalItems + 1 })
-    ]);
-  });
 
-  test.afterAll(async () => {
+      await managerNodeActions.lockNodes([fileLockedId, fileFavLockedId, fileSharedLockedId, fileSharedFavLockedId]);
-    await Utils.deleteNodesSitesEmptyTrashcan(undefined, undefined, 'afterAll failed', managerSiteActions, [sitePrivate]);
+
-  });
+      await Promise.all([
+        consumerFavoritesActions.waitForApi(userConsumer, { expect: consumerFavoritesTotalItems + 6 }),
+        consumerShareActions.waitForFilesToBeShared([
+          fileDocxSharedId,
+          fileDocxSharedFavId,
+          fileSharedId,
+          fileSharedFavId,
+          fileSharedLockedId,
+          fileSharedFavLockedId
+        ]),
+        managerSearchActions.waitForApi(userManager, { expect: managerSearchTotalItems + 13 })
+      ]);
+    });
+
+    test.afterAll(async () => {
+      await Utils.deleteNodesSitesEmptyTrashcan(undefined, undefined, 'afterAll failed', managerSiteActions, [sitePrivate]);
+    });
 
-  test.describe('Consumer', () => {
     test.describe('on Viewer', () => {
       viewerTests(userConsumer, sitePrivate);
     });
   });
 
   test.describe('Collaborator', () => {
+    const apiClientFactory = new ApiClientFactory();
+    const sitePrivate = `site-private-collaborator-${random}`;
+    const userManager = `manager-collaborator-${random}`;
+    const userCollaborator = `collaborator-${random}`;
+
+    let docLibId: string;
+    let fileDocxSharedFavId: string;
+    let fileSharedFavId: string;
+
+    let managerNodeActions: NodesApi;
+    let managerSiteActions: SitesApi;
+    let managerFileActions: FileActionsApi;
+    let managerSearchActions: SearchApi;
+    let managerShareActions: SharedLinksApi;
+    let collaboratorFavoritesActions: FavoritesPageApi;
+
+    test.beforeAll(async () => {
+      test.setTimeout(timeouts.extendedLongTest);
+      await apiClientFactory.setUpAcaBackend('admin');
+      await apiClientFactory.createUser({ username: userManager });
+      await apiClientFactory.createUser({ username: userCollaborator });
+
+      managerNodeActions = await NodesApi.initialize(userManager, userManager);
+      managerSiteActions = await SitesApi.initialize(userManager, userManager);
+      managerFileActions = await FileActionsApi.initialize(userManager, userManager);
+      managerSearchActions = await SearchApi.initialize(userManager, userManager);
+      managerShareActions = await SharedLinksApi.initialize(userManager, userManager);
+      collaboratorFavoritesActions = await FavoritesPageApi.initialize(userCollaborator, userCollaborator);
+
+      const collaboratorFavoritesTotalItems = await collaboratorFavoritesActions.getFavoritesTotalItems(userCollaborator);
+      const managerSearchTotalItems = await managerSearchActions.getTotalItems(userManager);
+
+      await managerSiteActions.createSite(sitePrivate, Site.VisibilityEnum.PRIVATE);
+      docLibId = await managerSiteActions.getDocLibId(sitePrivate);
+      await managerSiteActions.addSiteMember(sitePrivate, userCollaborator, Site.RoleEnum.SiteCollaborator);
+
+      fileDocxSharedFavId = (await managerFileActions.uploadFileWithRename(TEST_FILES.DOCX.path, testData.fileDocxSharedFav.name, docLibId)).entry.id;
+      fileSharedFavId = (await managerNodeActions.createFile(testData.fileSharedFav.name, docLibId, '', '', '', true, ['cm:versionable'])).entry.id;
+
+      await managerShareActions.shareFilesByIds([fileDocxSharedFavId, fileSharedFavId]);
+      await collaboratorFavoritesActions.addFavoritesByIds('file', [fileDocxSharedFavId, fileSharedFavId]);
+
+      await collaboratorFavoritesActions.isFavoriteWithRetry(userCollaborator, fileSharedFavId, { expect: true });
+      await Promise.all([
+        collaboratorFavoritesActions.waitForApi(userCollaborator, { expect: collaboratorFavoritesTotalItems + 2 }),
+        managerShareActions.waitForFilesToBeShared([fileDocxSharedFavId, fileSharedFavId]),
+        managerSearchActions.waitForApi(userManager, { expect: managerSearchTotalItems + 2 })
+      ]);
+    });
+
+    test.afterAll(async () => {
+      await Utils.deleteNodesSitesEmptyTrashcan(undefined, undefined, 'afterAll failed', managerSiteActions, [sitePrivate]);
+    });
+
     collaboratorTests(userCollaborator, sitePrivate);
   });
 
   test.describe('File locked - user is lock owner', () => {
+    const apiClientFactory = new ApiClientFactory();
+    const sitePrivate = `site-private-locked-owner-${random}`;
+    const userManager = `manager-locked-owner-${random}`;
+    const userDemoted = `demoted-owner-${random}`;
+
+    let docLibId: string;
+    let fileLockedByUserId: string;
+
+    let managerNodeActions: NodesApi;
+    let managerSiteActions: SitesApi;
+    let managerSearchActions: SearchApi;
+    let demotedUserActions: NodesApi;
+    let demotedUserFavoritesActions: FavoritesPageApi;
+    let demotedUserShareActions: SharedLinksApi;
+
+    test.beforeAll(async () => {
+      test.setTimeout(timeouts.extendedLongTest);
+      await apiClientFactory.setUpAcaBackend('admin');
+      await apiClientFactory.createUser({ username: userManager });
+      await apiClientFactory.createUser({ username: userDemoted });
+
+      managerNodeActions = await NodesApi.initialize(userManager, userManager);
+      managerSiteActions = await SitesApi.initialize(userManager, userManager);
+      managerSearchActions = await SearchApi.initialize(userManager, userManager);
+      demotedUserActions = await NodesApi.initialize(userDemoted, userDemoted);
+      demotedUserFavoritesActions = await FavoritesPageApi.initialize(userDemoted, userDemoted);
+      demotedUserShareActions = await SharedLinksApi.initialize(userDemoted, userDemoted);
+
+      const demotedUserFavoritesTotalItems = await demotedUserFavoritesActions.getFavoritesTotalItems(userDemoted);
+      const managerSearchTotalItems = await managerSearchActions.getTotalItems(userManager);
+
+      await managerSiteActions.createSite(sitePrivate, Site.VisibilityEnum.PRIVATE);
+      docLibId = await managerSiteActions.getDocLibId(sitePrivate);
+      await managerSiteActions.addSiteMember(sitePrivate, userDemoted, Site.RoleEnum.SiteManager);
+
+      fileLockedByUserId = (await managerNodeActions.createFile(testData.fileLockedByUser.name, docLibId, '', '', '', true, ['cm:versionable'])).entry
+        .id;
+      await demotedUserActions.lockNodes([fileLockedByUserId]);
+      await demotedUserFavoritesActions.addFavoriteById('file', fileLockedByUserId);
+      await demotedUserShareActions.shareFileById(fileLockedByUserId);
+      await managerSiteActions.updateSiteMember(sitePrivate, userDemoted, Site.RoleEnum.SiteConsumer);
+
+      await demotedUserFavoritesActions.isFavoriteWithRetry(userDemoted, fileLockedByUserId, { expect: true });
+      await Promise.all([
+        demotedUserFavoritesActions.waitForApi(userDemoted, { expect: demotedUserFavoritesTotalItems + 1 }),
+        demotedUserShareActions.waitForFilesToBeShared([fileLockedByUserId]),
+        managerSearchActions.waitForApi(userManager, { expect: managerSearchTotalItems + 1 })
+      ]);
+    });
+
+    test.afterAll(async () => {
+      await Utils.deleteNodesSitesEmptyTrashcan(undefined, undefined, 'afterAll failed', managerSiteActions, [sitePrivate]);
+    });
+
     filesLockedByCurrentUser(userDemoted, sitePrivate);
   });
 
   test.describe('File locked by other user - user is manager', () => {
+    const apiClientFactory = new ApiClientFactory();
+    const sitePrivate = `site-private-locked-other-${random}`;
+    const userManager = `manager-locked-other-${random}`;
+    const userDemoted = `demoted-other-${random}`;
+
+    let docLibId: string;
+    let fileLockedByUserId: string;
+
+    let managerNodeActions: NodesApi;
+    let managerSiteActions: SitesApi;
+    let managerSearchActions: SearchApi;
+    let managerFavoritesActions: FavoritesPageApi;
+    let demotedUserActions: NodesApi;
+    let demotedUserShareActions: SharedLinksApi;
+
+    test.beforeAll(async () => {
+      test.setTimeout(timeouts.extendedLongTest);
+      await apiClientFactory.setUpAcaBackend('admin');
+      await apiClientFactory.createUser({ username: userManager });
+      await apiClientFactory.createUser({ username: userDemoted });
+
+      managerNodeActions = await NodesApi.initialize(userManager, userManager);
+      managerSiteActions = await SitesApi.initialize(userManager, userManager);
+      managerSearchActions = await SearchApi.initialize(userManager, userManager);
+      managerFavoritesActions = await FavoritesPageApi.initialize(userManager, userManager);
+      demotedUserActions = await NodesApi.initialize(userDemoted, userDemoted);
+      demotedUserShareActions = await SharedLinksApi.initialize(userDemoted, userDemoted);
+
+      const managerFavoritesTotalItems = await managerFavoritesActions.getFavoritesTotalItems(userManager);
+      const managerSearchTotalItems = await managerSearchActions.getTotalItems(userManager);
+
+      await managerSiteActions.createSite(sitePrivate, Site.VisibilityEnum.PRIVATE);
+      docLibId = await managerSiteActions.getDocLibId(sitePrivate);
+      await managerSiteActions.addSiteMember(sitePrivate, userDemoted, Site.RoleEnum.SiteManager);
+
+      fileLockedByUserId = (await managerNodeActions.createFile(testData.fileLockedByUser.name, docLibId, '', '', '', true, ['cm:versionable'])).entry
+        .id;
+      await demotedUserActions.lockNodes([fileLockedByUserId]);
+      await demotedUserShareActions.shareFileById(fileLockedByUserId);
+      await managerFavoritesActions.addFavoriteById('file', fileLockedByUserId);
+
+      await managerFavoritesActions.isFavoriteWithRetry(userManager, fileLockedByUserId, { expect: true });
+      await Promise.all([
+        managerFavoritesActions.waitForApi(userManager, { expect: managerFavoritesTotalItems + 1 }),
+        demotedUserShareActions.waitForFilesToBeShared([fileLockedByUserId]),
+        managerSearchActions.waitForApi(userManager, { expect: managerSearchTotalItems + 1 })
+      ]);
+    });
+
+    test.afterAll(async () => {
+      await Utils.deleteNodesSitesEmptyTrashcan(undefined, undefined, 'afterAll failed', managerSiteActions, [sitePrivate]);
+    });
+
     filesLockedByOtherUser(userManager, sitePrivate);
   });
 });

e2e/playwright/special-permissions-actions-available/src/tests/viewer.ts

@@ -23,460 +23,253 @@
  */
 
 import { expect } from '@playwright/test';
-import { FavoritesPage, LoginPage, MyLibrariesPage, SearchPage, SharedPage, test } from '@alfresco/aca-playwright-shared';
+import { FavoritesPage, LoginPage, MyLibrariesPage, SearchPage, SharedPage, TestFileData, test } from '@alfresco/aca-playwright-shared';
 import * as testData from '@alfresco/aca-playwright-shared';
 
+type ViewerCapablePage = MyLibrariesPage | FavoritesPage | SharedPage | SearchPage;
+
 export function viewerTests(userConsumer: string, siteName: string) {
+  const login = async (loginPage: LoginPage): Promise<void> => {
+    await loginPage.navigate();
+    await loginPage.loginUser({ username: userConsumer, password: userConsumer });
+  };
+
+  const verifyViewerActions = async (page: ViewerCapablePage, data: TestFileData, expectNoManageVersions = false): Promise<void> => {
+    expect(await page.viewer.isViewerOpened(), 'Viewer is not opened').toBe(true);
+    await page.viewer.verifyViewerPrimaryActions(data.viewerToolbarPrimary);
+    await page.viewer.toolbar.clickMoreActions();
+    await page.matMenu.verifyActualMoreActions(data.viewerToolbarMore);
+
+    if (expectNoManageVersions) {
+      const actualMoreActions = await page.matMenu.getActualMoreActions();
+      expect(actualMoreActions.includes('Manage Versions'), 'Manage Versions should not be visible for a non-versionable file').toBe(false);
+    }
+  };
+
   test.describe('Consumer available actions : ', () => {
     test.describe('file opened from File Libraries', () => {
-      async function checkViewerActions(
+      const openInViewer = async (myLibrariesPage: MyLibrariesPage, loginPage: LoginPage, item: string): Promise<void> => {
-        loginPage: LoginPage,
+        await login(loginPage);
-        myLibrariesPage: MyLibrariesPage,
-        item: string,
-        expectedToolbarPrimary: string[],
-        expectedToolbarMore: string[]
-      ): Promise<void> {
-        await loginPage.navigate();
-        await loginPage.loginUser({ username: userConsumer, password: userConsumer });
         await myLibrariesPage.navigate();
         await myLibrariesPage.dataTable.performClickFolderOrFileToOpen(siteName);
         await myLibrariesPage.dataTable.performClickFolderOrFileToOpen(item);
-        expect(await myLibrariesPage.viewer.isViewerOpened(), 'Viewer is not opened').toBe(true);
+      };
-        await myLibrariesPage.viewer.verifyViewerPrimaryActions(expectedToolbarPrimary);
-        await myLibrariesPage.viewer.toolbar.clickMoreActions();
-        await myLibrariesPage.matMenu.verifyActualMoreActions(expectedToolbarMore);
-      }
 
       test('[XAT-4808] Actions for Consumer on a file Office', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileDocx.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileDocx);
-          myLibrariesPage,
-          testData.fileDocx.name,
-          testData.fileDocx.viewerToolbarPrimary,
-          testData.fileDocx.viewerToolbarMore
-        );
       });
 
       test('[XAT-4809] Actions for Consumer on a file Office, favorite', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileDocxFav.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileDocxFav);
-          myLibrariesPage,
-          testData.fileDocxFav.name,
-          testData.fileDocxFav.viewerToolbarPrimary,
-          testData.fileDocxFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4810] Actions for Consumer on a file, not Office', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(loginPage, myLibrariesPage, testData.file.name, testData.file.viewerToolbarPrimary, testData.file.viewerToolbarMore);
+        await openInViewer(myLibrariesPage, loginPage, testData.file.name);
+        await verifyViewerActions(myLibrariesPage, testData.file);
       });
 
       test('[XAT-4811] Actions for Consumer on a file, not Office, favorite', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileFav.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileFav);
-          myLibrariesPage,
-          testData.fileFav.name,
-          testData.fileFav.viewerToolbarPrimary,
-          testData.fileFav.viewerToolbarMore
-        );
       });
 
-      test('[XAT-19608] Manage Versions is not shown for a file without cm:versionable aspect', async ({ loginPage, myLibrariesPage }) => {
+      test('[XAT-20145] Manage Versions is not shown for a file without cm:versionable aspect', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileNotVersionable.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileNotVersionable, true);
-          myLibrariesPage,
-          testData.fileNotVersionable.name,
-          testData.fileNotVersionable.viewerToolbarPrimary,
-          testData.fileNotVersionable.viewerToolbarMore
-        );
-        const actualMoreActions = await myLibrariesPage.matMenu.getActualMoreActions();
-        expect(actualMoreActions.includes('Manage Versions'), 'Manage Versions should not be visible for a non-versionable file').toBe(false);
       });
 
       test('[XAT-4814] Actions for Consumer on a file Office, shared', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileDocxShared.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileDocxShared);
-          myLibrariesPage,
-          testData.fileDocxShared.name,
-          testData.fileDocxShared.viewerToolbarPrimary,
-          testData.fileDocxShared.viewerToolbarMore
-        );
       });
 
       test('[XAT-4815] Actions for Consumer on a file Office, shared, favorite', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileDocxSharedFav.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileDocxSharedFav);
-          myLibrariesPage,
-          testData.fileDocxSharedFav.name,
-          testData.fileDocxSharedFav.viewerToolbarPrimary,
-          testData.fileDocxSharedFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4816] Actions for Consumer on a file, not Office, shared', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileShared.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileShared);
-          myLibrariesPage,
-          testData.fileShared.name,
-          testData.fileShared.viewerToolbarPrimary,
-          testData.fileShared.viewerToolbarMore
-        );
       });
 
       test('[XAT-4817] Actions for Consumer on a file, not Office, shared, favorite', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileSharedFav.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileSharedFav);
-          myLibrariesPage,
-          testData.fileSharedFav.name,
-          testData.fileSharedFav.viewerToolbarPrimary,
-          testData.fileSharedFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4812] Actions for Consumer on a file, locked', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileLocked.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileLocked);
-          myLibrariesPage,
-          testData.fileLocked.workingCopyName,
-          testData.fileLocked.viewerToolbarPrimary,
-          testData.fileLocked.viewerToolbarMore
-        );
       });
 
       test('[XAT-4813] Actions for Consumer on a file, locked, favorite', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileFavLocked.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileFavLocked);
-          myLibrariesPage,
-          testData.fileFavLocked.workingCopyName,
-          testData.fileFavLocked.viewerToolbarPrimary,
-          testData.fileFavLocked.workingCopyViewerToolbarMore
-        );
       });
 
       test('[XAT-4818] Actions for Consumer on a file, locked, shared', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileSharedLocked.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileSharedLocked);
-          myLibrariesPage,
-          testData.fileSharedLocked.workingCopyName,
-          testData.fileSharedLocked.viewerToolbarPrimary,
-          testData.fileSharedLocked.viewerToolbarMore
-        );
       });
 
       test('[XAT-4819] Actions for Consumer on a file, locked, shared, favorite', async ({ loginPage, myLibrariesPage }) => {
-        await checkViewerActions(
+        await openInViewer(myLibrariesPage, loginPage, testData.fileSharedFavLocked.name);
-          loginPage,
+        await verifyViewerActions(myLibrariesPage, testData.fileSharedFavLocked);
-          myLibrariesPage,
-          testData.fileSharedFavLocked.workingCopyName,
-          testData.fileSharedFavLocked.viewerToolbarPrimary,
-          testData.fileSharedFavLocked.workingCopyViewerToolbarMore
-        );
       });
     });
 
     test.describe('file opened from Favorites', () => {
-      async function checkViewerActions(
+      const openInViewer = async (favoritePage: FavoritesPage, loginPage: LoginPage, item: string): Promise<void> => {
-        loginPage: LoginPage,
+        await login(loginPage);
-        favoritePage: FavoritesPage,
-        item: string,
-        expectedToolbarPrimary: string[],
-        expectedToolbarMore: string[]
-      ): Promise<void> {
-        await loginPage.navigate();
-        await loginPage.loginUser({ username: userConsumer, password: userConsumer });
         await favoritePage.navigate();
         await favoritePage.dataTable.performClickFolderOrFileToOpen(item);
-        expect(await favoritePage.viewer.isViewerOpened(), 'Viewer is not opened').toBe(true);
+      };
-        await favoritePage.viewer.verifyViewerPrimaryActions(expectedToolbarPrimary);
-        await favoritePage.viewer.toolbar.clickMoreActions();
-        await favoritePage.matMenu.verifyActualMoreActions(expectedToolbarMore);
-      }
 
       test('[XAT-4820] File Office, favorite - ', async ({ loginPage, favoritePage }) => {
-        await checkViewerActions(
+        await openInViewer(favoritePage, loginPage, testData.fileDocxFav.name);
-          loginPage,
+        await verifyViewerActions(favoritePage, testData.fileDocxFav);
-          favoritePage,
-          testData.fileDocxFav.name,
-          testData.fileDocxFav.viewerToolbarPrimary,
-          testData.fileDocxFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4821] Actions for Consumer on a file, not Office, favorite', async ({ loginPage, favoritePage }) => {
-        await checkViewerActions(
+        await openInViewer(favoritePage, loginPage, testData.fileFav.name);
-          loginPage,
+        await verifyViewerActions(favoritePage, testData.fileFav);
-          favoritePage,
-          testData.fileFav.name,
-          testData.fileFav.viewerToolbarPrimary,
-          testData.fileFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4823] Actions for Consumer on a file Office, shared, favorite', async ({ loginPage, favoritePage }) => {
-        await checkViewerActions(
+        await openInViewer(favoritePage, loginPage, testData.fileDocxSharedFav.name);
-          loginPage,
+        await verifyViewerActions(favoritePage, testData.fileDocxSharedFav);
-          favoritePage,
-          testData.fileDocxSharedFav.name,
-          testData.fileDocxSharedFav.viewerToolbarPrimary,
-          testData.fileDocxSharedFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4824] Actions for Consumer on a file, not Office, shared, favorite', async ({ loginPage, favoritePage }) => {
-        await checkViewerActions(
+        await openInViewer(favoritePage, loginPage, testData.fileSharedFav.name);
-          loginPage,
+        await verifyViewerActions(favoritePage, testData.fileSharedFav);
-          favoritePage,
-          testData.fileSharedFav.name,
-          testData.fileSharedFav.viewerToolbarPrimary,
-          testData.fileSharedFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4822] Actions for Consumer on a file, locked, favorite', async ({ loginPage, favoritePage }) => {
-        await checkViewerActions(
+        await openInViewer(favoritePage, loginPage, testData.fileFavLocked.name);
-          loginPage,
+        await verifyViewerActions(favoritePage, testData.fileFavLocked);
-          favoritePage,
-          testData.fileFavLocked.name,
-          testData.fileFavLocked.viewerToolbarPrimary,
-          testData.fileFavLocked.viewerToolbarMore
-        );
       });
 
       test('[XAT-4825] Actions for Consumer on a file, locked, shared, favorite', async ({ loginPage, favoritePage }) => {
-        await checkViewerActions(
+        await openInViewer(favoritePage, loginPage, testData.fileSharedFavLocked.name);
-          loginPage,
+        await verifyViewerActions(favoritePage, testData.fileSharedFavLocked);
-          favoritePage,
-          testData.fileSharedFavLocked.name,
-          testData.fileSharedFavLocked.viewerToolbarPrimary,
-          testData.fileSharedFavLocked.viewerToolbarMore
-        );
       });
     });
 
     test.describe('file opened from Shared Files', () => {
-      async function checkViewerActions(
+      const openInViewer = async (sharedPage: SharedPage, loginPage: LoginPage, item: string): Promise<void> => {
-        loginPage: LoginPage,
+        await login(loginPage);
-        sharedPage: SharedPage,
-        item: string,
-        expectedToolbarPrimary: string[],
-        expectedToolbarMore: string[]
-      ): Promise<void> {
-        await loginPage.navigate();
-        await loginPage.loginUser({ username: userConsumer, password: userConsumer });
         await sharedPage.navigate();
         await sharedPage.dataTable.performClickFolderOrFileToOpen(item);
-        expect(await sharedPage.viewer.isViewerOpened(), 'Viewer is not opened').toBe(true);
+      };
-        await sharedPage.viewer.verifyViewerPrimaryActions(expectedToolbarPrimary);
-        await sharedPage.viewer.toolbar.clickMoreActions();
-        await sharedPage.matMenu.verifyActualMoreActions(expectedToolbarMore);
-      }
 
       test('[XAT-4826] Actions for Consumer on a file Office, shared', async ({ loginPage, sharedPage }) => {
-        await checkViewerActions(
+        await openInViewer(sharedPage, loginPage, testData.fileDocxShared.name);
-          loginPage,
+        await verifyViewerActions(sharedPage, testData.fileDocxShared);
-          sharedPage,
-          testData.fileDocxShared.name,
-          testData.fileDocxShared.viewerToolbarPrimary,
-          testData.fileDocxShared.viewerToolbarMore
-        );
       });
 
       test('[XAT-4827] Actions for Consumer on a file Office, shared, favorite', async ({ loginPage, sharedPage }) => {
-        await checkViewerActions(
+        await openInViewer(sharedPage, loginPage, testData.fileDocxSharedFav.name);
-          loginPage,
+        await verifyViewerActions(sharedPage, testData.fileDocxSharedFav);
-          sharedPage,
-          testData.fileDocxSharedFav.name,
-          testData.fileDocxSharedFav.viewerToolbarPrimary,
-          testData.fileDocxSharedFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4828] Actions for Consumer on a file, not Office, shared', async ({ loginPage, sharedPage }) => {
-        await checkViewerActions(
+        await openInViewer(sharedPage, loginPage, testData.fileShared.name);
-          loginPage,
+        await verifyViewerActions(sharedPage, testData.fileShared);
-          sharedPage,
-          testData.fileShared.name,
-          testData.fileShared.viewerToolbarPrimary,
-          testData.fileShared.viewerToolbarMore
-        );
       });
 
       test('[XAT-4829] Actions for Consumer on a file, not Office, shared, favorite', async ({ loginPage, sharedPage }) => {
-        await checkViewerActions(
+        await openInViewer(sharedPage, loginPage, testData.fileSharedFav.name);
-          loginPage,
+        await verifyViewerActions(sharedPage, testData.fileSharedFav);
-          sharedPage,
-          testData.fileSharedFav.name,
-          testData.fileSharedFav.viewerToolbarPrimary,
-          testData.fileSharedFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4830] Actions for Consumer on a file, locked, shared', async ({ loginPage, sharedPage }) => {
-        await checkViewerActions(
+        await openInViewer(sharedPage, loginPage, testData.fileSharedLocked.name);
-          loginPage,
+        await verifyViewerActions(sharedPage, testData.fileSharedLocked);
-          sharedPage,
-          testData.fileSharedLocked.name,
-          testData.fileSharedLocked.viewerToolbarPrimary,
-          testData.fileSharedLocked.viewerToolbarMore
-        );
       });
 
       test('[XAT-4831] Actions for Consumer on a file, locked, shared, favorite', async ({ loginPage, sharedPage }) => {
-        await checkViewerActions(
+        await openInViewer(sharedPage, loginPage, testData.fileSharedFavLocked.name);
-          loginPage,
+        await verifyViewerActions(sharedPage, testData.fileSharedFavLocked);
-          sharedPage,
-          testData.fileSharedFavLocked.name,
-          testData.fileSharedFavLocked.viewerToolbarPrimary,
-          testData.fileSharedFavLocked.viewerToolbarMore
-        );
       });
     });
 
     test.describe('file opened from Search Results', () => {
-      async function checkViewerActions(
+      const openInViewer = async (searchPage: SearchPage, loginPage: LoginPage, data: TestFileData): Promise<void> => {
-        loginPage: LoginPage,
+        await login(loginPage);
-        searchPage: SearchPage,
+        await searchPage.searchWithin(data.random, 'filesAndFolders', 'formula');
-        item: string,
+        await searchPage.dataTable.performClickFolderOrFileToOpen(data.name);
-        expectedToolbarPrimary: string[],
+      };
-        expectedToolbarMore: string[]
-      ): Promise<void> {
-        await loginPage.navigate();
-        await loginPage.loginUser({ username: userConsumer, password: userConsumer });
-        await searchPage.searchWithin(item, 'filesAndFolders');
-        await searchPage.dataTable.performClickFolderOrFileToOpen(item);
-        expect(await searchPage.viewer.isViewerOpened(), 'Viewer is not opened').toBe(true);
-        await searchPage.viewer.verifyViewerPrimaryActions(expectedToolbarPrimary);
-        await searchPage.viewer.toolbar.clickMoreActions();
-        await searchPage.matMenu.verifyActualMoreActions(expectedToolbarMore);
-      }
 
       test('[XAT-4832] Actions for Consumer on a file Office', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileDocx);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileDocx);
-          searchPage,
-          testData.fileDocx.name,
-          testData.fileDocx.viewerToolbarPrimary,
-          testData.fileDocx.viewerToolbarMore
-        );
       });
 
       test('[XAT-4833] Actions for Consumer on a file Office, favorite', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileDocxFav);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileDocxFav);
-          searchPage,
-          testData.fileDocxFav.name,
-          testData.fileDocxFav.viewerToolbarPrimary,
-          testData.fileDocxFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4834] Actions for Consumer on a file, not Office', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(loginPage, searchPage, testData.file.name, testData.file.viewerToolbarPrimary, testData.file.viewerToolbarMore);
+        await openInViewer(searchPage, loginPage, testData.file);
+        await verifyViewerActions(searchPage, testData.file);
       });
 
       test('[XAT-4835] Actions for Consumer on a file, not Office, favorite', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileFav);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileFav);
-          searchPage,
-          testData.fileFav.name,
-          testData.fileFav.viewerToolbarPrimary,
-          testData.fileFav.viewerToolbarMore
-        );
       });
 
-      test('[XAT-19609] Manage Versions is not shown for a file without cm:versionable aspect - Search Results', async ({
+      test('[XAT-20146] Manage Versions is not shown for a file without cm:versionable aspect - Search Results', async ({
         loginPage,
         searchPage
       }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileNotVersionable);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileNotVersionable, true);
-          searchPage,
-          testData.fileNotVersionable.name,
-          testData.fileNotVersionable.viewerToolbarPrimary,
-          testData.fileNotVersionable.viewerToolbarMore
-        );
-        const actualMoreActions = await searchPage.matMenu.getActualMoreActions();
-        expect(actualMoreActions.includes('Manage Versions'), 'Manage Versions should not be visible for a non-versionable file').toBe(false);
       });
 
       test('[XAT-4838] Actions for Consumer on a file Office, shared', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileDocxShared);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileDocxShared);
-          searchPage,
-          testData.fileDocxShared.name,
-          testData.fileDocxShared.viewerToolbarPrimary,
-          testData.fileDocxShared.viewerToolbarMore
-        );
       });
 
       test('[XAT-4839] Actions for Consumer on a file Office, shared, favorite', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileDocxSharedFav);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileDocxSharedFav);
-          searchPage,
-          testData.fileDocxSharedFav.name,
-          testData.fileDocxSharedFav.viewerToolbarPrimary,
-          testData.fileDocxSharedFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4840] Actions for Consumer on a file, not Office, shared', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileShared);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileShared);
-          searchPage,
-          testData.fileShared.name,
-          testData.fileShared.viewerToolbarPrimary,
-          testData.fileShared.viewerToolbarMore
-        );
       });
 
       test('[XAT-4841] Actions for Consumer on a file, not Office, shared, favorite', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileSharedFav);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileSharedFav);
-          searchPage,
-          testData.fileSharedFav.name,
-          testData.fileSharedFav.viewerToolbarPrimary,
-          testData.fileSharedFav.viewerToolbarMore
-        );
       });
 
       test('[XAT-4836] Actions for Consumer on a file, locked', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileLocked);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileLocked);
-          searchPage,
-          testData.fileLocked.workingCopyName,
-          testData.fileLocked.viewerToolbarPrimary,
-          testData.fileLocked.viewerToolbarMore
-        );
       });
 
       test('[XAT-4837] Actions for Consumer on a file, locked, favorite', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileFavLocked);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileFavLocked);
-          searchPage,
-          testData.fileFavLocked.workingCopyName,
-          testData.fileFavLocked.viewerToolbarPrimary,
-          testData.fileFavLocked.workingCopyViewerToolbarMore
-        );
       });
 
       test('[XAT-4842] Actions for Consumer on a file, locked, shared', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileSharedLocked);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileSharedLocked);
-          searchPage,
-          testData.fileSharedLocked.workingCopyName,
-          testData.fileSharedLocked.viewerToolbarPrimary,
-          testData.fileSharedLocked.viewerToolbarMore
-        );
       });
 
       test('[XAT-4843] Actions for Consumer on a file, locked, shared, favorite', async ({ loginPage, searchPage }) => {
-        await checkViewerActions(
+        await openInViewer(searchPage, loginPage, testData.fileSharedFavLocked);
-          loginPage,
+        await verifyViewerActions(searchPage, testData.fileSharedFavLocked);
-          searchPage,
-          testData.fileSharedFavLocked.workingCopyName,
-          testData.fileSharedFavLocked.viewerToolbarPrimary,
-          testData.fileSharedFavLocked.viewerToolbarMore
-        );
       });
     });
   });

projects/aca-playwright-shared/src/api/favorites-api.ts

@@ -111,7 +111,7 @@ export class FavoritesPageApi {
         if (attempts % 7 === 0) {
           logger.info(`FavoritesApi: waitForApi still waiting for ${username} - expected ${data.expect}, got ${totalItems} (attempt ${attempts})`);
         }
-        if (totalItems !== data.expect) {
+        if (totalItems < data.expect) {
           return Promise.reject(totalItems);
         }
         return totalItems;

projects/aca-playwright-shared/src/api/shared-links-api.ts

@@ -74,7 +74,7 @@ export class SharedLinksApi {
       };
       return await this.apiService.share.listSharedLinks(opts);
     } catch (error) {
-      logger.error(`SharedLinksApi getSharedLinks : catch : ${error}`);
+      logger.error(`SharedLinksApi getSharedLinks : catch : ${JSON.stringify(error)}`);
       return new SharedLinkPaging();
     }
   }

projects/aca-playwright-shared/src/resources/test-data/test-data-files-folders.ts

@@ -27,6 +27,20 @@ import { Utils } from '../../utils';
 const random = Utils.random();
 const multipleSelToolbarPrimary = ['Download', 'View Details', 'More Actions'];
 
+export interface FolderActionsData {
+  name: string;
+  description?: string;
+  contextMenu: string[];
+  toolbarPrimary: string[];
+  toolbarMore: string[];
+}
+
+export interface MultiSelectionData {
+  contextMenu: string[];
+  toolbarPrimary: string[];
+  toolbarMore: string[];
+}
+
 // ---- folders ---
 
 const folderContextMenu = ['Download', 'Edit', 'Favorite', 'Move', 'Copy', 'Delete', 'Edit Aspects', 'Permissions', 'Manage Rules'];
@@ -34,7 +48,7 @@ const folderFavContextMenu = ['Download', 'Edit', 'Remove Favorite', 'Move', 'Co
 const folderToolbarMore = ['Edit', 'Favorite', 'Move', 'Copy', 'Delete', 'Edit Aspects', 'Permissions', 'Manage Rules'];
 const folderFavToolbarMore = ['Edit', 'Remove Favorite', 'Move', 'Copy', 'Delete', 'Edit Aspects', 'Permissions', 'Manage Rules'];
 
-export const folderFile = {
+export const folderFile: FolderActionsData = {
   name: `folderActions-${random}`,
   description: 'folder not favorite',
   contextMenu: folderContextMenu,
@@ -42,7 +56,7 @@ export const folderFile = {
   toolbarMore: folderToolbarMore
 };
 
-export const folderFavFile = {
+export const folderFavFile: FolderActionsData = {
   name: `folderActions-fav-${random}`,
   contextMenu: folderFavContextMenu,
   toolbarPrimary: multipleSelToolbarPrimary,
@@ -54,7 +68,7 @@ export const folderFavFile = {
 const multipleSelContextMenu = ['Download', 'Favorite', 'Move', 'Copy', 'Delete'];
 const multipleSelToolbarMore = ['Favorite', 'Move', 'Copy', 'Delete'];
 
-export const multipleSelFile = {
+export const multipleSelFile: MultiSelectionData = {
   contextMenu: multipleSelContextMenu,
   toolbarPrimary: multipleSelToolbarPrimary,
   toolbarMore: multipleSelToolbarMore

projects/aca-playwright-shared/src/resources/test-data/test-data-permissions.ts

@@ -24,7 +24,46 @@
 
 import { Utils } from '../../utils';
 
-export const random = Utils.random();
+export interface TestNode {
+  /** Unique token in the name; use it as a precise search term. */
+  random: string;
+  name: string;
+}
+
+export interface TestFileData extends TestNode {
+  description: string;
+  contextMenu: string[];
+  toolbarPrimary: string[];
+  toolbarMore: string[];
+  viewerToolbarPrimary: string[];
+  viewerToolbarMore: string[];
+  searchToolbarPrimary: string[];
+  favoritesToolbarMore?: string[];
+  favoritesContextMenu?: string[];
+  sharedToolbarMore?: string[];
+  sharedContextMenu?: string[];
+}
+
+export interface TestFolderData {
+  name: string;
+  description: string;
+  contextMenu?: string[];
+  toolbarPrimary?: string[];
+  toolbarMore?: string[];
+  searchToolbarPrimary?: string[];
+  favoritesContextMenu?: string[];
+  favoritesToolbarMore?: string[];
+}
+
+const buildFileData = (buildName: (fileRandom: string) => string, data: Omit<TestFileData, 'name' | 'random'>): TestFileData => {
+  const fileRandom = Utils.random();
+  return { random: fileRandom, name: buildName(fileRandom), ...data };
+};
+
+const buildNode = (buildName: (fileRandom: string) => string): TestNode => {
+  const fileRandom = Utils.random();
+  return { random: fileRandom, name: buildName(fileRandom) };
+};
 
 // ----- files -----
 
@@ -42,8 +81,7 @@ const searchConsumerSharedToolbarPrimary = ['Shared Link Settings', 'Download',
 const consumerToolbarMore = ['Favorite', 'Copy', 'Manage Versions'];
 const consumerFavToolbarMore = ['Remove Favorite', 'Copy', 'Manage Versions'];
 
-export const collaboratorToolbarPrimary = ['Shared Link Settings', 'Download', 'View', 'View Details', 'More Actions'];
+export const collaboratorToolbarPrimary = ['Shared Link Settings', 'View', 'View Details', 'More Actions'];
-export const collaboratorWorkingCopyToolbarPrimary = ['View', 'View Details', 'More Actions'];
 export const collaboratorEditRowToolbarMore = [
   'Edit Offline',
   'Upload New Version',
@@ -53,16 +91,19 @@ export const collaboratorEditRowToolbarMore = [
   'Edit Aspects',
   'Permissions'
 ];
-export const favoritesCheckedOutCollaboratorToolbarMore = ['Cancel Editing', 'Upload New Version', 'Remove Favorite', 'Copy', 'Information'];
+export const favoritesCollaboratorToolbarMore = [
-export const favoritesCollaboratorToolbarMore = ['Upload New Version', 'Remove Favorite', 'Move', 'Copy', 'Delete', 'Manage Versions'];
+  'Edit Offline',
-export const collaboratorSharedToolbarPrimary = [
+  'Upload New Version',
-  'Activate full-screen mode',
+  'Remove Favorite',
-  'Shared Link Settings',
+  'Move',
-  'Download',
+  'Copy',
-  'Print',
+  'Delete',
-  'View Details',
+  'Manage Versions',
-  'More Actions'
+  'Edit Aspects',
+  'Permissions'
 ];
+export const collaboratorSharedToolbarPrimary = ['Activate full-screen mode', 'Shared Link Settings', 'Print', 'View Details', 'More Actions'];
+export const collaboratorViewerLockedToolbarPrimary = ['Activate full-screen mode', 'View Details', 'More Actions'];
 export const collaboratorDocToolbarMore = [
   'Edit in Microsoft Office™',
   'Edit Offline',
@@ -73,20 +114,9 @@ export const collaboratorDocToolbarMore = [
   'Edit Aspects',
   'Permissions'
 ];
-export const collaboratorSharedWorkingCopyToolbarPrimary = ['Activate full-screen mode', 'View Details', 'More Actions'];
+export const collaboratorLockCurrentUserToolbarMore = ['Cancel Editing', 'Upload New Version', 'Remove Favorite', 'Copy'];
-export const collaboratorLockedToolbarPrimary = ['Shared Link Settings', 'View', 'View Details', 'More Actions'];
+export const collaboratorLockOtherUserToolbarMore = ['Cancel Editing', 'Remove Favorite', 'Move', 'Copy', 'Permissions'];
-export const collaboratorLockedOriginalSharedViewerToolbarPrimary = [
+export const collaboratorLockOtherUserSearchToolbarMore = ['Cancel Editing', 'Remove Favorite', 'Copy', 'Permissions'];
-  'Activate full-screen mode',
-  'Shared Link Settings',
-  'View Details',
-  'More Actions'
-];
-export const collaboratorLockedSharedViewerToolbarMore = ['Cancel Editing', 'Upload New Version', 'Remove Favorite', 'Copy'];
-export const collaboratorLockCurrentUserToolbarMore = ['Cancel Editing', 'Upload New Version', 'Remove Favorite', 'Copy', 'Manage Versions'];
-export const collaboratorLockWorkingCopyToolbarMore = ['Cancel Editing', 'Upload New Version', 'Favorite', 'Copy'];
-export const lockedWorkingCopyToolbarMore = ['Cancel Editing', 'Upload New Version', 'Favorite', 'Move', 'Copy', 'Information', 'Permissions'];
-export const collaboratorLockOtherUserToolbarMore = ['Cancel Editing', 'Remove Favorite', 'Move', 'Copy', 'Delete', 'Manage Versions', 'Permissions'];
-export const collaboratorLockOtherUserSearchToolbarMore = ['Cancel Editing', 'Remove Favorite', 'Copy', 'Manage Versions', 'Permissions'];
 
 // ---- VIEWER ----
 
@@ -157,8 +187,7 @@ const sharedConsumerFavLockedContextMenu = [
   'Manage Versions'
 ];
 
-export const fileDocx = {
+export const fileDocx = buildFileData((fileRandom) => `file-${fileRandom}-docx.docx`, {
-  name: `file-${random}-docx.docx`,
   description: 'file not shared, not fav, office, not locked',
 
   contextMenu: consumerContextMenu,
@@ -168,10 +197,9 @@ export const fileDocx = {
   viewerToolbarMore: consumerViewerToolbarMore,
 
   searchToolbarPrimary: searchConsumerToolbarPrimary
-};
+});
 
-export const fileDocxFav = {
+export const fileDocxFav = buildFileData((fileRandom) => `file-${fileRandom}-docx-fav.docx`, {
-  name: `file-${random}-docx-fav.docx`,
   description: 'file not shared, fav, office, not locked',
 
   contextMenu: consumerFavContextMenu,
@@ -184,10 +212,9 @@ export const fileDocxFav = {
   favoritesContextMenu: favoritesConsumerContextMenu,
 
   searchToolbarPrimary: searchConsumerToolbarPrimary
-};
+});
 
-export const file = {
+export const file = buildFileData((fileRandom) => `file-${fileRandom}.txt`, {
-  name: `file-${random}.txt`,
   description: 'file not shared, not fav, not office, not locked',
 
   contextMenu: consumerContextMenu,
@@ -197,10 +224,9 @@ export const file = {
   viewerToolbarMore: consumerViewerToolbarMore,
 
   searchToolbarPrimary: searchConsumerToolbarPrimary
-};
+});
 
-export const fileFav = {
+export const fileFav = buildFileData((fileRandom) => `file-${fileRandom}-fav.txt`, {
-  name: `file-${random}-fav.txt`,
   description: 'file not shared, fav, not office, not locked',
 
   contextMenu: consumerFavContextMenu,
@@ -213,10 +239,9 @@ export const fileFav = {
   favoritesContextMenu: favoritesConsumerContextMenu,
 
   searchToolbarPrimary: searchConsumerToolbarPrimary
-};
+});
 
-export const fileDocxShared = {
+export const fileDocxShared = buildFileData((fileRandom) => `file-${fileRandom}-docx-shared.docx`, {
-  name: `file-${random}-docx-shared.docx`,
   description: 'file shared, not fav, office, not locked',
 
   contextMenu: consumerSharedContextMenu,
@@ -229,10 +254,9 @@ export const fileDocxShared = {
   sharedContextMenu: sharedConsumerContextMenu,
 
   searchToolbarPrimary: searchConsumerSharedToolbarPrimary
-};
+});
 
-export const fileDocxSharedFav = {
+export const fileDocxSharedFav = buildFileData((fileRandom) => `file-${fileRandom}-docx-shared-fav.docx`, {
-  name: `file-${random}-docx-shared-fav.docx`,
   description: 'file shared, fav, office, not locked',
 
   contextMenu: consumerSharedFavContextMenu,
@@ -248,10 +272,9 @@ export const fileDocxSharedFav = {
   sharedContextMenu: sharedConsumerFavContextMenu,
 
   searchToolbarPrimary: searchConsumerSharedToolbarPrimary
-};
+});
 
-export const fileShared = {
+export const fileShared = buildFileData((fileRandom) => `file-${fileRandom}-shared.txt`, {
-  name: `file-${random}-shared.txt`,
   description: 'file shared, not fav, not office, not locked',
 
   contextMenu: consumerSharedContextMenu,
@@ -264,10 +287,9 @@ export const fileShared = {
   sharedContextMenu: sharedConsumerContextMenu,
 
   searchToolbarPrimary: searchConsumerSharedToolbarPrimary
-};
+});
 
-export const fileSharedFav = {
+export const fileSharedFav = buildFileData((fileRandom) => `file-${fileRandom}-shared-fav.txt`, {
-  name: `file-${random}-shared-fav.txt`,
   description: 'file shared, fav, not office, not locked',
 
   contextMenu: consumerSharedFavContextMenu,
@@ -283,11 +305,9 @@ export const fileSharedFav = {
   sharedContextMenu: sharedConsumerFavContextMenu,
 
   searchToolbarPrimary: searchConsumerSharedToolbarPrimary
-};
+});
 
-export const fileLocked = {
+export const fileLocked = buildFileData((fileRandom) => `file-${fileRandom}-locked.txt`, {
-  name: `file-${random}-locked.txt`,
-  workingCopyName: `file-${random}-locked (Working Copy).txt`,
   description: 'file not shared, not fav, not office, locked',
 
   contextMenu: consumerContextMenu,
@@ -297,11 +317,9 @@ export const fileLocked = {
   viewerToolbarMore: consumerViewerLockedToolbarMore,
 
   searchToolbarPrimary: searchConsumerToolbarPrimary
-};
+});
 
-export const fileFavLocked = {
+export const fileFavLocked = buildFileData((fileRandom) => `file-${fileRandom}-fav-locked.txt`, {
-  name: `file-${random}-fav-locked.txt`,
-  workingCopyName: `file-${random}-fav-locked (Working Copy).txt`,
   description: 'file not shared, fav, not office, locked',
 
   contextMenu: consumerFavContextMenu,
@@ -309,17 +327,14 @@ export const fileFavLocked = {
   toolbarMore: consumerFavToolbarMore,
   viewerToolbarPrimary: consumerViewerLockedToolbarPrimary,
   viewerToolbarMore: consumerViewerLockedFavToolbarMore,
-  workingCopyViewerToolbarMore: consumerViewerLockedToolbarMore,
 
   favoritesToolbarMore: favoritesConsumerToolbarMore,
   favoritesContextMenu: favoritesConsumerContextMenu,
 
   searchToolbarPrimary: searchConsumerToolbarPrimary
-};
+});
 
-export const fileSharedLocked = {
+export const fileSharedLocked = buildFileData((fileRandom) => `file-${fileRandom}-shared-locked.txt`, {
-  name: `file-${random}-shared-locked.txt`,
-  workingCopyName: `file-${random}-shared-locked (Working Copy).txt`,
   description: 'file shared, not fav, not office, locked',
 
   contextMenu: consumerSharedContextMenu,
@@ -332,11 +347,9 @@ export const fileSharedLocked = {
   sharedContextMenu: sharedConsumerLockedContextMenu,
 
   searchToolbarPrimary: searchConsumerSharedToolbarPrimary
-};
+});
 
-export const fileSharedFavLocked = {
+export const fileSharedFavLocked = buildFileData((fileRandom) => `file-${fileRandom}-shared-fav-locked.txt`, {
-  name: `file-${random}-shared-fav-locked.txt`,
-  workingCopyName: `file-${random}-shared-fav-locked (Working Copy).txt`,
   description: 'file shared, fav, not office, locked',
 
   contextMenu: consumerSharedFavContextMenu,
@@ -344,7 +357,6 @@ export const fileSharedFavLocked = {
   toolbarMore: consumerFavToolbarMore,
   viewerToolbarPrimary: consumerViewerLockedToolbarPrimary,
   viewerToolbarMore: consumerViewerLockedFavToolbarMore,
-  workingCopyViewerToolbarMore: consumerViewerLockedToolbarMore,
 
   favoritesToolbarMore: favoritesConsumerToolbarMore,
   favoritesContextMenu: favoritesConsumerSharedContextMenu,
@@ -353,11 +365,9 @@ export const fileSharedFavLocked = {
   sharedContextMenu: sharedConsumerFavLockedContextMenu,
 
   searchToolbarPrimary: searchConsumerSharedToolbarPrimary
-};
+});
 
-export const fileGranularPermission = `file-${random}-granular.txt`;
+export const fileLockedByUser = buildNode((fileRandom) => `file-${fileRandom}-my-locked.txt`);
-export const fileLockedByUser = `file-${random}-my-locked.txt`;
-export const fileLockedByUserWorkingCopyName = `file-${random}-my-locked (Working Copy).txt`;
 
 // ---- non-versionable file (no cm:versionable aspect) ----
 
@@ -365,8 +375,7 @@ const consumerNotVersionableToolbarMore = ['Favorite', 'Copy'];
 const consumerNotVersionableContextMenu = ['Share', 'Download', 'View', 'Favorite', 'Copy'];
 const consumerViewerNotVersionableToolbarMore = ['Favorite', 'Copy'];
 
-export const fileNotVersionable = {
+export const fileNotVersionable = buildFileData((fileRandom) => `file-${fileRandom}-not-versionable.txt`, {
-  name: `file-${random}-not-versionable.txt`,
   description: 'file not shared, not fav, not office, not locked, not versionable - should not show Manage Versions',
 
   contextMenu: consumerNotVersionableContextMenu,
@@ -376,50 +385,7 @@ export const fileNotVersionable = {
   viewerToolbarMore: consumerViewerNotVersionableToolbarMore,
 
   searchToolbarPrimary: searchConsumerToolbarPrimary
-};
+});
-
-// ---- folders ---
-
-const consumerFolderContextMenu = ['Download', 'Favorite', 'Copy'];
-const consumerFolderToolbarPrimary = ['Download', 'View Details', 'More Actions'];
-const consumerFolderToolbarMore = ['Favorite', 'Copy'];
-const searchConsumerFolderToolbarPrimary = ['Download', 'View Details', 'More Actions'];
-const consumerFolderFavContextMenu = ['Download', 'Remove Favorite', 'Copy'];
-const consumerFolderFavToolbarMore = ['Remove Favorite', 'Copy'];
-
-// ---- FAVORITES workarounds ----
-
-const favoritesConsumerFolderContextMenu = ['Download', 'Edit', 'Remove Favorite', 'Move', 'Copy', 'Delete'];
-
-const favoritesConsumerFolderToolbarMore = ['Edit', 'Remove Favorite', 'Move', 'Copy', 'Delete'];
-
-export const folder = {
-  name: `folder-${random}`,
-  description: 'folder not favorite',
-  contextMenu: consumerFolderContextMenu,
-  toolbarPrimary: consumerFolderToolbarPrimary,
-  toolbarMore: consumerFolderToolbarMore,
-
-  searchToolbarPrimary: searchConsumerFolderToolbarPrimary
-};
-
-export const folderFav = {
-  name: `folder-fav-${random}`,
-  description: 'folder favorite',
-  contextMenu: consumerFolderFavContextMenu,
-  toolbarPrimary: consumerFolderToolbarPrimary,
-  toolbarMore: consumerFolderFavToolbarMore,
-
-  favoritesContextMenu: favoritesConsumerFolderContextMenu,
-  favoritesToolbarMore: favoritesConsumerFolderToolbarMore,
-
-  searchToolbarPrimary: searchConsumerFolderToolbarPrimary
-};
-
-export const folderFav2 = {
-  name: `folder-fav-2-${random}`,
-  description: 'folder 2 favorite'
-};
 
 // ---- multiple selection ---