add back try-catch around api calls (#1815)

* add back try-catch around api calls to avoid UnhandledPromiseRejectionWarning

* minor fixes for pagination to account for parallel runs

* missed one

* a few more fixes

* search only files to get correct and consistent number of results

* try something

* add try catch in upload output

* fix cleanup on Create file / folder from template to account for parallel running

* fix incorrect test case id
fix for undefined properties
unexclude some tests to see if still failing

* revert change in order to fix test

* unused import

* exclude test due to missing EXIF aspect

* trigger one more run

projects/aca-testing-shared/src/components/dialog/share-dialog.ts

@@ -70,7 +70,7 @@ export class ShareDialog extends GenericDialog {
   }
 
   async clickClose(): Promise<void> {
-    await BrowserActions.click(this.closeButton);
+    await this.closeButton.click();
     await this.waitForDialogToClose();
   }
 

projects/aca-testing-shared/src/utilities/admin-actions.ts

@@ -45,15 +45,30 @@ export class AdminActions extends UserActions {
   }
 
   async getDataDictionaryId(): Promise<string> {
-    return this.nodes.getNodeIdFromParent('Data Dictionary', '-root-');
+    try {
+      return this.nodes.getNodeIdFromParent('Data Dictionary', '-root-');
+    } catch (error) {
+      super.handleError('Admin Actions - getDataDictionaryId failed : ', error);
+      return '';
+    }
   }
 
   async getNodeTemplatesFolderId(): Promise<string> {
-    return this.nodes.getNodeIdFromParent('Node Templates', await this.getDataDictionaryId());
+    try {
+      return this.nodes.getNodeIdFromParent('Node Templates', await this.getDataDictionaryId());
+    } catch (error) {
+      super.handleError('Admin Actions - getNodeTemplatesFolderId failed : ', error);
+      return '';
+    }
   }
 
   async getSpaceTemplatesFolderId(): Promise<string> {
-    return this.nodes.getNodeIdFromParent('Space Templates', await this.getDataDictionaryId());
+    try {
+      return this.nodes.getNodeIdFromParent('Space Templates', await this.getDataDictionaryId());
+    } catch (error) {
+      super.handleError('Admin Actions - getSpaceTemplatesFolderId failed : ', error);
+      return '';
+    }
   }
 
   async createUser(user: PersonModel): Promise<PersonEntry> {
@@ -61,74 +76,154 @@ export class AdminActions extends UserActions {
     const peopleApi = new PeopleApi(this.alfrescoApi);
 
     await this.login();
-    return peopleApi.createPerson(person);
+    try {
+      return peopleApi.createPerson(person);
+    } catch (error) {
+      super.handleError('Admin Actions - createUser failed : ', error);
+      return null;
+    }
   }
 
   async disableUser(username: string): Promise<PersonEntry> {
     const peopleApi = new PeopleApi(this.alfrescoApi);
 
     await this.login();
-    return peopleApi.updatePerson(username, { enabled: false });
+    try {
+      return peopleApi.updatePerson(username, { enabled: false });
+    } catch (error) {
+      super.handleError('Admin Actions - createUser failed : ', error);
+      return null;
+    }
   }
 
   async changePassword(username: string, newPassword: string): Promise<PersonEntry> {
     const peopleApi = new PeopleApi(this.alfrescoApi);
 
     await this.login();
-    return peopleApi.updatePerson(username, { password: newPassword });
+    try {
+      return peopleApi.updatePerson(username, { password: newPassword });
+    } catch (error) {
+      super.handleError('Admin Actions - changePassword failed : ', error);
+      return null;
+    }
   }
 
   async createNodeTemplate(name: string, title: string = '', description: string = '', author: string = ''): Promise<NodeEntry> {
-    const templatesRootFolderId: string = await this.getNodeTemplatesFolderId();
+    try {
+      const templatesRootFolderId: string = await this.getNodeTemplatesFolderId();
 
-    return this.nodes.createFile(name, templatesRootFolderId, title, description, author);
+      return this.nodes.createFile(name, templatesRootFolderId, title, description, author);
+    } catch (error) {
+      super.handleError('Admin Actions - createNodeTemplate failed : ', error);
+      return null;
+    }
   }
 
   async createNodeTemplatesHierarchy(hierarchy: NodeContentTree): Promise<any> {
-    return this.nodes.createContent(hierarchy, `Data Dictionary/Node Templates`);
+    try {
+      return this.nodes.createContent(hierarchy, `Data Dictionary/Node Templates`);
+    } catch (error) {
+      super.handleError('Admin Actions - createNodeTemplatesHierarchy failed : ', error);
+    }
   }
 
   async createSpaceTemplate(name: string, title: string = '', description: string = ''): Promise<NodeEntry> {
-    const templatesRootFolderId: string = await this.getSpaceTemplatesFolderId();
+    try {
+      const templatesRootFolderId: string = await this.getSpaceTemplatesFolderId();
 
-    return this.nodes.createFolder(name, templatesRootFolderId, title, description);
+      return this.nodes.createFolder(name, templatesRootFolderId, title, description);
+    } catch (error) {
+      super.handleError('Admin Actions - createSpaceTemplate failed : ', error);
+      return null;
+    }
   }
 
   async createSpaceTemplatesHierarchy(hierarchy: NodeContentTree): Promise<any> {
-    return this.nodes.createContent(hierarchy, `Data Dictionary/Space Templates`);
+    try {
+      return this.nodes.createContent(hierarchy, `Data Dictionary/Space Templates`);
+    } catch (error) {
+      super.handleError('Admin Actions - createSpaceTemplatesHierarchy failed : ', error);
+    }
   }
 
   async removeUserAccessOnNodeTemplate(nodeName: string): Promise<NodeEntry> {
-    const templatesRootFolderId = await this.getNodeTemplatesFolderId();
-    const nodeId: string = await this.nodes.getNodeIdFromParent(nodeName, templatesRootFolderId);
+    try {
+      const templatesRootFolderId = await this.getNodeTemplatesFolderId();
+      const nodeId: string = await this.nodes.getNodeIdFromParent(nodeName, templatesRootFolderId);
 
-    return this.nodes.setInheritPermissions(nodeId, false);
+      return this.nodes.setInheritPermissions(nodeId, false);
+    } catch (error) {
+      super.handleError('Admin Actions - removeUserAccessOnNodeTemplate failed : ', error);
+      return null;
+    }
   }
 
   async removeUserAccessOnSpaceTemplate(nodeName: string): Promise<NodeEntry> {
-    const templatesRootFolderId = await this.getSpaceTemplatesFolderId();
-    const nodeId: string = await this.nodes.getNodeIdFromParent(nodeName, templatesRootFolderId);
+    try {
+      const templatesRootFolderId = await this.getSpaceTemplatesFolderId();
+      const nodeId: string = await this.nodes.getNodeIdFromParent(nodeName, templatesRootFolderId);
 
-    return this.nodes.setInheritPermissions(nodeId, false);
+      return this.nodes.setInheritPermissions(nodeId, false);
+    } catch (error) {
+      super.handleError('Admin Actions - removeUserAccessOnSpaceTemplate failed : ', error);
+      return null;
+    }
   }
 
   async cleanupNodeTemplatesFolder(): Promise<void> {
-    return this.nodes.deleteNodeChildren(await this.getNodeTemplatesFolderId());
+    try {
+      return this.nodes.deleteNodeChildren(await this.getNodeTemplatesFolderId());
+    } catch (error) {
+      super.handleError('Admin Actions - cleanupNodeTemplatesFolder failed : ', error);
+    }
+  }
+
+  async cleanupNodeTemplatesItems(nodeNames: string[]): Promise<void> {
+    try {
+      const templatesFolderId = await this.getNodeTemplatesFolderId();
+      for (const nodeName of nodeNames) {
+        const nodeId = await this.nodes.getNodeIdFromParent(nodeName, templatesFolderId);
+        await this.nodes.deleteNodeById(nodeId);
+      }
+    } catch (error) {
+      super.handleError('Admin Actions - cleanupNodeTemplatesItems failed : ', error);
+    }
   }
 
   async cleanupSpaceTemplatesFolder(): Promise<void> {
-    const spaceTemplatesNodeId = await this.getSpaceTemplatesFolderId();
+    try {
+      const spaceTemplatesNodeId = await this.getSpaceTemplatesFolderId();
 
-    // folder links are deleted automatically when original folder is deleted
-    // Software Engineering Project is the default folder template coming from ACS, should not be deleted
-    const nodesToDelete = (await this.nodes.getNodeChildren(spaceTemplatesNodeId)).list.entries
-      .filter((node) => node.entry.nodeType !== 'app:folderlink' && node.entry.name !== 'Software Engineering Project')
-      .map((node) => node.entry.id);
-    return this.nodes.deleteNodesById(nodesToDelete);
+      // folder links are deleted automatically when original folder is deleted
+      // Software Engineering Project is the default folder template coming from ACS, should not be deleted
+      const nodesToDelete = (await this.nodes.getNodeChildren(spaceTemplatesNodeId)).list.entries
+        .filter((node) => node.entry.nodeType !== 'app:folderlink' && node.entry.name !== 'Software Engineering Project')
+        .map((node) => node.entry.id);
+      return this.nodes.deleteNodesById(nodesToDelete);
+    } catch (error) {
+      super.handleError('Admin Actions - cleanupSpaceTemplatesFolder failed : ', error);
+    }
+  }
+
+  async cleanupSpaceTemplatesItems(nodeNames: string[]): Promise<void> {
+    try {
+      const spaceTemplatesNodeId = await this.getSpaceTemplatesFolderId();
+      for (const nodeName of nodeNames) {
+        const nodeId = await this.nodes.getNodeIdFromParent(nodeName, spaceTemplatesNodeId);
+        await this.nodes.deleteNodeById(nodeId);
+      }
+    } catch (error) {
+      super.handleError('Admin Actions - cleanupSpaceTemplatesFolder failed : ', error);
+    }
   }
 
   async createLinkToFileId(originalFileId: string, destinationParentId: string): Promise<NodeEntry> {
-    return this.nodes.createFileLink(originalFileId, destinationParentId);
+    try {
+      return this.nodes.createFileLink(originalFileId, destinationParentId);
+    } catch (error) {
+      super.handleError('Admin Actions - createLinkToFileId failed : ', error);
+      return null;
+    }
   }
 
   async createLinkToFileName(originalFileName: string, originalFileParentId: string, destinationParentId?: string): Promise<NodeEntry> {
@@ -136,13 +231,23 @@ export class AdminActions extends UserActions {
       destinationParentId = originalFileParentId;
     }
 
-    const nodeId = await this.nodes.getNodeIdFromParent(originalFileName, originalFileParentId);
+    try {
+      const nodeId = await this.nodes.getNodeIdFromParent(originalFileName, originalFileParentId);
 
-    return this.createLinkToFileId(nodeId, destinationParentId);
+      return this.createLinkToFileId(nodeId, destinationParentId);
+    } catch (error) {
+      super.handleError('Admin Actions - createLinkToFileName failed : ', error);
+      return null;
+    }
   }
 
   async createLinkToFolderId(originalFolderId: string, destinationParentId: string): Promise<NodeEntry> {
-    return this.nodes.createFolderLink(originalFolderId, destinationParentId);
+    try {
+      return this.nodes.createFolderLink(originalFolderId, destinationParentId);
+    } catch (error) {
+      super.handleError('Admin Actions - createLinkToFolderId failed : ', error);
+      return null;
+    }
   }
 
   async createLinkToFolderName(originalFolderName: string, originalFolderParentId: string, destinationParentId?: string): Promise<NodeEntry> {
@@ -150,8 +255,13 @@ export class AdminActions extends UserActions {
       destinationParentId = originalFolderParentId;
     }
 
-    const nodeId = await this.nodes.getNodeIdFromParent(originalFolderName, originalFolderParentId);
+    try {
+      const nodeId = await this.nodes.getNodeIdFromParent(originalFolderName, originalFolderParentId);
 
-    return this.createLinkToFolderId(nodeId, destinationParentId);
+      return this.createLinkToFolderId(nodeId, destinationParentId);
+    } catch (error) {
+      super.handleError('Admin Actions - createLinkToFolderName failed : ', error);
+      return null;
+    }
   }
 }

projects/aca-testing-shared/src/utilities/user-actions.ts

@@ -23,6 +23,7 @@
  * along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
  */
 
+import { Logger } from '@alfresco/adf-testing';
 import { AlfrescoApi, Comment, CommentsApi, NodesApi, TrashcanApi, SitesApi, SharedlinksApi } from '@alfresco/js-api';
 import { browser } from 'protractor';
 import { Utils } from './utils';
@@ -54,17 +55,30 @@ export class UserActions {
     this.username = username || this.username;
     this.password = password || this.password;
 
-    return this.alfrescoApi.login(this.username, this.password);
+    try {
+      return this.alfrescoApi.login(this.username, this.password);
+    } catch (error) {
+      this.handleError('User Actions - login failed : ', error);
+    }
   }
 
   async logout(): Promise<any> {
-    await this.alfrescoApi.login(this.username, this.password);
-    return this.alfrescoApi.logout();
+    try {
+      await this.alfrescoApi.login(this.username, this.password);
+      return this.alfrescoApi.logout();
+    } catch (error) {
+      this.handleError('User Actions - logout failed : ', error);
+    }
   }
 
-  async createComment(nodeId: string, content: string): Promise<Comment> {
-    const comment = await this.commentsApi.createComment(nodeId, { content });
-    return comment?.entry;
+  async createComment(nodeId: string, content: string): Promise<Comment | null> {
+    try {
+      const comment = await this.commentsApi.createComment(nodeId, { content });
+      return comment?.entry;
+    } catch (error) {
+      this.handleError('User Actions - createComment failed : ', error);
+      return null;
+    }
   }
 
   /**
@@ -73,8 +87,12 @@ export class UserActions {
    * @param permanent Delete permanently, without moving to the trashcan? (default: true)
    */
   async deleteNodes(nodeIds: string[], permanent: boolean = true): Promise<any> {
-    for (const nodeId of nodeIds) {
-      await this.nodesApi.deleteNode(nodeId, { permanent });
+    try {
+      for (const nodeId of nodeIds) {
+        await this.nodesApi.deleteNode(nodeId, { permanent });
+      }
+    } catch (error) {
+      this.handleError('User Actions - deleteNodes failed : ', error);
     }
   }
 
@@ -82,18 +100,22 @@ export class UserActions {
    * Empties the trashcan. Uses multiple batches 1000 nodes each.
    */
   async emptyTrashcan(): Promise<any> {
-    const nodes = await this.trashcanApi.listDeletedNodes({
-      maxItems: 1000
-    });
+    try {
+      const nodes = await this.trashcanApi.listDeletedNodes({
+        maxItems: 1000
+      });
 
-    if (nodes?.list?.entries && nodes?.list?.entries?.length > 0) {
-      const ids = nodes.list.entries.map((entries) => entries.entry.id);
+      if (nodes?.list?.entries && nodes?.list?.entries?.length > 0) {
+        const ids = nodes.list.entries.map((entries) => entries.entry.id);
 
-      for (const nodeId of ids) {
-        await this.trashcanApi.deleteDeletedNode(nodeId);
+        for (const nodeId of ids) {
+          await this.trashcanApi.deleteDeletedNode(nodeId);
+        }
+
+        await this.emptyTrashcan();
       }
-
-      await this.emptyTrashcan();
+    } catch (error) {
+      this.handleError('User Actions - emptyTrashcan failed : ', error);
     }
   }
 
@@ -102,11 +124,16 @@ export class UserActions {
    * TODO: limited to 1000 items only, needs improvements.
    */
   async getTrashcanSize(): Promise<number> {
-    const response = await this.trashcanApi.listDeletedNodes({
-      maxItems: 1000
-    });
+    try {
+      const response = await this.trashcanApi.listDeletedNodes({
+        maxItems: 1000
+      });
 
-    return response?.list?.pagination?.totalItems || 0;
+      return response?.list?.pagination?.totalItems || 0;
+    } catch (error) {
+      this.handleError('User Actions - getTrashcanSize failed : ', error);
+      return -1;
+    }
   }
 
   /**
@@ -115,15 +142,20 @@ export class UserActions {
    * @param expectedSize Size of the trashcan to wait for.
    */
   async waitForTrashcanSize(expectedSize: number): Promise<number> {
-    return Utils.retryCall(async () => {
-      const totalItems = await this.getTrashcanSize();
+    try {
+      return Utils.retryCall(async () => {
+        const totalItems = await this.getTrashcanSize();
 
-      if (totalItems !== expectedSize) {
-        return Promise.reject(totalItems);
-      } else {
-        return Promise.resolve(totalItems);
-      }
-    });
+        if (totalItems !== expectedSize) {
+          return Promise.reject(totalItems);
+        } else {
+          return Promise.resolve(totalItems);
+        }
+      });
+    } catch (error) {
+      this.handleError('User Actions - waitForTrashcanSize failed : ', error);
+      return -1;
+    }
   }
 
   /**
@@ -131,8 +163,12 @@ export class UserActions {
    * @param nodeIds The list of node IDs to unlock.
    */
   async unlockNodes(nodeIds: string[]): Promise<any> {
-    for (const nodeId of nodeIds) {
-      await this.nodesApi.unlockNode(nodeId);
+    try {
+      for (const nodeId of nodeIds) {
+        await this.nodesApi.unlockNode(nodeId);
+      }
+    } catch (error) {
+      this.handleError('User Actions - unlockNodes failed : ', error);
     }
   }
 
@@ -142,10 +178,14 @@ export class UserActions {
    * @param permanent Delete permanently, without moving to the trashcan? (default: true)
    */
   async deleteSites(siteIds: string[], permanent: boolean = true) {
-    if (siteIds && siteIds.length > 0) {
-      for (const siteId of siteIds) {
-        await this.sitesApi.deleteSite(siteId, { permanent });
+    try {
+      if (siteIds && siteIds.length > 0) {
+        for (const siteId of siteIds) {
+          await this.sitesApi.deleteSite(siteId, { permanent });
+        }
       }
+    } catch (error) {
+      this.handleError('User Actions - deleteSites failed : ', error);
     }
   }
 
@@ -155,11 +195,31 @@ export class UserActions {
    * @param expiresAt (optional) Expiration date.
    */
   async shareNodes(nodeIds: string[], expiresAt?: Date): Promise<any> {
-    for (const nodeId of nodeIds) {
-      await this.sharedLinksApi.createSharedLink({
-        nodeId,
-        expiresAt
-      });
+    try {
+      for (const nodeId of nodeIds) {
+        await this.sharedLinksApi.createSharedLink({
+          nodeId,
+          expiresAt
+        });
+      }
+    } catch (error) {
+      this.handleError('User Actions - shareNodes failed : ', error);
     }
   }
+
+  protected handleError(message: string, response: any) {
+    Logger.error(`\n--- ${message} error :`);
+    Logger.error('\t>>> username: ', this.username);
+    Logger.error('\t>>> JSON: ', JSON.stringify(browser.params.config));
+    if (response.status && response.response) {
+      try {
+        Logger.error('\t>>> Status: ', response.status);
+        Logger.error('\t>>> Text: ', response.response.text);
+        Logger.error('\t>>> Method: ', response.response.error.method);
+        Logger.error('\t>>> Path: ', response.response.error.path);
+      } catch {
+        Logger.error('\t>>> ', response);
+      }
+    } else Logger.error('\t>>> ', response);
+  }
 }