- remove some awaits

- add try catch - small refactoring
2025-07-24 17:31:52 +00:00 · 2019-10-17 17:31:29 +03:00
parent 9fd47d3186
commit 227e05e3f9
39 changed files with 1243 additions and 905 deletions
--- a/e2e/components/breadcrumb/breadcrumb.ts
+++ b/e2e/components/breadcrumb/breadcrumb.ts
@@ -45,11 +45,11 @@ export class Breadcrumb extends Component {
  }

  async getNthItemName(nth: number) {
-      return await this.getNthItem(nth).getText();
+      return this.getNthItem(nth).getText();
  }

  async getItemsCount() {
-    return await this.items.count();
+    return this.items.count();
  }

  async getAllItems() {
@@ -60,7 +60,7 @@ export class Breadcrumb extends Component {
  }

  async getFirstItemName() {
-    return await this.items.get(0).getText();
+    return this.items.get(0).getText();
  }

  getCurrentItem() {
@@ -68,7 +68,7 @@ export class Breadcrumb extends Component {
  }

  async getCurrentItemName() {
-    return await this.currentItem.getText();
+    return this.currentItem.getText();
  }

  async clickItem(name: string) {
@@ -81,6 +81,6 @@ export class Breadcrumb extends Component {
  }

  async getNthItemTooltip(nth: number) {
-    return await this.getNthItem(nth).getAttribute('title');
+    return this.getNthItem(nth).getAttribute('title');
  }
 }
--- a/e2e/components/data-table/data-table.ts
+++ b/e2e/components/data-table/data-table.ts
@@ -85,11 +85,11 @@ export class DataTable extends Component {

  // Wait methods (waits for elements)
  async waitForHeader() {
-    return await browser.wait(EC.presenceOf(this.head), BROWSER_WAIT_TIMEOUT, '--- timeout waitForHeader ---');
+    await browser.wait(EC.presenceOf(this.head), BROWSER_WAIT_TIMEOUT, '--- timeout waitForHeader ---');
  }

  async waitForBody() {
-    return await browser.wait(EC.presenceOf(this.body), BROWSER_WAIT_TIMEOUT, '--- timeout waitForBody ---');
+    await browser.wait(EC.presenceOf(this.body), BROWSER_WAIT_TIMEOUT, '--- timeout waitForBody ---');
  }

  async waitForEmptyState() {
@@ -104,7 +104,7 @@ export class DataTable extends Component {

  async getColumnHeadersText() {
    const el = this.getColumnHeaders();
-    return await el.getText();
+    return el.getText();
  }

  getNthColumnHeader(nth: number) {
@@ -122,7 +122,7 @@ export class DataTable extends Component {
  }

  async getSortedColumnHeaderText() {
-    return await this.getSortedColumnHeader().getText();
+    return this.getSortedColumnHeader().getText();
  }

  async getSortingOrder(): Promise<string> {
@@ -151,7 +151,7 @@ export class DataTable extends Component {
  }

  async countRows() {
-    return await this.getRows().count();
+    return this.getRows().count();
  }

  getSelectedRows() {
@@ -159,7 +159,7 @@ export class DataTable extends Component {
  }

  async countSelectedRows() {
-    return await this.getSelectedRows().count();
+    return this.getSelectedRows().count();
  }

  getNthRow(nth: number) {
@@ -180,7 +180,7 @@ export class DataTable extends Component {
  }

  async getRowCellsCount(itemName: string) {
-    return await this.getRowCells(itemName).count();
+    return this.getRowCells(itemName).count();
  }

  getRowFirstCell(name: string, location: string = '') {
@@ -196,28 +196,28 @@ export class DataTable extends Component {
  }

  async getItemNameTooltip(name: string, location: string = '') {
-    return await this.getRowNameCellSpan(name, location).getAttribute('title');
+    return this.getRowNameCellSpan(name, location).getAttribute('title');
  }

  async hasCheckMarkIcon(itemName: string, location: string = '') {
    const row = this.getRowByName(itemName, location);
-    return await row.element(by.css(DataTable.selectors.selectedIcon)).isPresent();
+    return row.element(by.css(DataTable.selectors.selectedIcon)).isPresent();
  }

  async hasLockIcon(itemName: string, location: string = '') {
    const row = this.getRowByName(itemName, location);
-    return await row.element(by.css(DataTable.selectors.lockIcon)).isPresent();
+    return row.element(by.css(DataTable.selectors.lockIcon)).isPresent();
  }

  async hasLockOwnerInfo(itemName: string, location: string = '') {
    const row = this.getRowByName(itemName, location);
-    return await row.element(by.css(DataTable.selectors.lockOwner)).isPresent();
+    return row.element(by.css(DataTable.selectors.lockOwner)).isPresent();
  }

  async getLockOwner(itemName: string, location: string = '') {
    if (await this.hasLockOwnerInfo(itemName, location)) {
      const row = this.getRowByName(itemName, location);
-      return await row.$(DataTable.selectors.lockOwner).$('.locked_by--name').getText();
+      return row.$(DataTable.selectors.lockOwner).$('.locked_by--name').getText();
    }
    return '';
  }
@@ -227,7 +227,7 @@ export class DataTable extends Component {
  }

  async hasLinkOnName(itemName: string) {
-    return await this.getNameLink(itemName).isPresent();
+    return this.getNameLink(itemName).isPresent();
  }

  // Navigation/selection methods
@@ -303,7 +303,7 @@ export class DataTable extends Component {
  }

  async getItemLocation(name: string) {
-    return await this.getItemLocationEl(name).getText();
+    return this.getItemLocationEl(name).getText();
  }

  async getItemLocationTooltip(name: string) {
@@ -313,7 +313,7 @@ export class DataTable extends Component {
    await browser.actions().mouseMove(location).perform();

    await browser.wait(condition, BROWSER_WAIT_TIMEOUT);
-    return await location.getAttribute('title');
+    return location.getAttribute('title');
  }

  async clickItemLocation(name: string) {
@@ -322,17 +322,17 @@ export class DataTable extends Component {

  // empty state methods
  async isEmptyList() {
-    return await this.emptyList.isPresent();
+    return this.emptyList.isPresent();
  }

  async isEmptyWithDragAndDrop() {
-    return await this.emptyFolderDragAndDrop.isDisplayed();
+    return this.emptyFolderDragAndDrop.isDisplayed();
  }

  async getEmptyDragAndDropText(): Promise<string> {
    const isEmpty = await this.isEmptyWithDragAndDrop();
    if (isEmpty) {
-      return await this.emptyFolderDragAndDrop.getText();
+      return this.emptyFolderDragAndDrop.getText();
    }

    return '';
@@ -341,7 +341,7 @@ export class DataTable extends Component {
  async getEmptyStateTitle(): Promise<string> {
    const isEmpty = await this.isEmptyList();
    if (isEmpty) {
-      return await this.emptyListTitle.getText();
+      return this.emptyListTitle.getText();
    }

    return '';
@@ -350,7 +350,7 @@ export class DataTable extends Component {
  async getEmptyStateSubtitle(): Promise<string> {
    const isEmpty = await this.isEmptyList();
    if (isEmpty) {
-      return await this.emptyListSubtitle.getText();
+      return this.emptyListSubtitle.getText();
    }

    return '';
@@ -359,14 +359,14 @@ export class DataTable extends Component {
  async getEmptyStateText(): Promise<string> {
    const isEmpty = await this.isEmptyList();
    if (isEmpty) {
-      return await this.emptyListText.getText();
+      return this.emptyListText.getText();
    }

    return '';
  }

  async getEmptySearchResultsText() {
-    return await this.emptySearchText.getText();
+    return this.emptySearchText.getText();
  }

  async getCellsContainingName(name: string) {
@@ -380,11 +380,11 @@ export class DataTable extends Component {
  }

  async getLibraryRole(name: string) {
-    return await this.getRowByName(name).element(by.css(DataTable.selectors.libraryRole)).getText();
+    return this.getRowByName(name).element(by.css(DataTable.selectors.libraryRole)).getText();
  }

  async isItemPresent(name: string, location? : string) {
-    return await this.getRowByName(name, location).isPresent();
+    return this.getRowByName(name, location).isPresent();
  }

  async getEntireDataTableText() {
@@ -423,7 +423,7 @@ export class DataTable extends Component {
  }

  async getSearchResultLinesCount(name: string, location: string = '') {
-    return await this.getSearchResultRowLines(name, location).count();
+    return this.getSearchResultRowLines(name, location).count();
  }

  getSearchResultNthLine(name: string, location: string = '', index: number) {
@@ -431,19 +431,19 @@ export class DataTable extends Component {
  }

  async getSearchResultNameAndTitle(name: string, location: string = '') {
-    return await this.getSearchResultNthLine(name, location, 0).getText();
+    return this.getSearchResultNthLine(name, location, 0).getText();
  }

  async getSearchResultDescription(name: string, location: string = '') {
-    return await this.getSearchResultNthLine(name, location, 1).getText();
+    return this.getSearchResultNthLine(name, location, 1).getText();
  }

  async getSearchResultModified(name: string, location: string = '') {
-    return await this.getSearchResultNthLine(name, location, 2).getText();
+    return this.getSearchResultNthLine(name, location, 2).getText();
  }

  async getSearchResultLocation(name: string, location: string = '') {
-    return await this.getSearchResultNthLine(name, location, 3).getText();
+    return this.getSearchResultNthLine(name, location, 3).getText();
  }

  getSearchResultNameLink(itemName: string, location: string = '') {
@@ -451,7 +451,7 @@ export class DataTable extends Component {
  }

  async hasLinkOnSearchResultName(itemName: string, location: string = '') {
-    return await this.getSearchResultNameLink(itemName, location).isPresent();
+    return this.getSearchResultNameLink(itemName, location).isPresent();
  }

  async clickSearchResultNameLink(itemName: string, location: string = '') {
--- a/e2e/components/datetime-picker/datetime-picker.ts
+++ b/e2e/components/datetime-picker/datetime-picker.ts
@@ -61,15 +61,15 @@ export class DateTimePicker extends Component {
  }

  async isCalendarOpen() {
-    return await browser.isElementPresent(by.css(DateTimePicker.selectors.root));
+    return browser.isElementPresent(by.css(DateTimePicker.selectors.root));
  }

  async getDate() {
-    return await this.headerDate.getText();
+    return this.headerDate.getText();
  }

  async getYear() {
-    return await this.headerYear.getText();
+    return this.headerYear.getText();
  }

  async setDefaultDay() {
--- a/e2e/components/dialog/confirm-dialog.ts
+++ b/e2e/components/dialog/confirm-dialog.ts
@@ -57,15 +57,15 @@ export class ConfirmDialog extends Component {
  }

  async isDialogOpen() {
-    return await browser.isElementPresent(by.css(ConfirmDialog.selectors.root));
+    return browser.isElementPresent(by.css(ConfirmDialog.selectors.root));
  }

  async getTitle() {
-    return await this.title.getText();
+    return this.title.getText();
  }

  async getText() {
-    return await this.content.getText();
+    return this.content.getText();
  }

  getButtonByName(name: string) {
@@ -79,49 +79,49 @@ export class ConfirmDialog extends Component {

  async isButtonEnabled(name: string) {
    const button = this.getButtonByName(name);
-    return await button.isEnabled();
+    return button.isEnabled();
  }


  async isOkEnabled() {
-    return await this.isButtonEnabled('OK');
+    return this.isButtonEnabled('OK');
  }

  async isCancelEnabled() {
-    return await this.isButtonEnabled('Cancel');
+    return this.isButtonEnabled('Cancel');
  }

  async isKeepEnabled() {
-    return await this.isButtonEnabled('Keep');
+    return this.isButtonEnabled('Keep');
  }

  async isDeleteEnabled() {
-    return await this.isButtonEnabled('Delete');
+    return this.isButtonEnabled('Delete');
  }

  async isRemoveEnabled() {
-    return await this.isButtonEnabled('Remove');
+    return this.isButtonEnabled('Remove');
  }


  async clickOk() {
-    return await this.clickButton('OK');
+    await this.clickButton('OK');
  }

  async clickCancel() {
-    return await this.cancelButton.click();
+    await this.cancelButton.click();
  }

  async clickKeep() {
-    return await this.clickButton('Keep');
+    await this.clickButton('Keep');
  }

  async clickDelete() {
-    return await this.clickButton('Delete');
+    await this.clickButton('Delete');
  }

  async clickRemove() {
-    return await this.clickButton('Remove');
+    await this.clickButton('Remove');
  }

 }
--- a/e2e/components/dialog/copy-move-dialog.ts
+++ b/e2e/components/dialog/copy-move-dialog.ts
@@ -78,11 +78,11 @@ export class CopyMoveDialog extends Component {
  }

  async isDialogOpen() {
-    return await browser.$(CopyMoveDialog.selectors.root).isDisplayed();
+    return browser.$(CopyMoveDialog.selectors.root).isDisplayed();
  }

  async getTitle() {
-    return await this.title.getText();
+    return this.title.getText();
  }

  async clickCancel() {
--- a/e2e/components/dialog/create-edit-folder-dialog.ts
+++ b/e2e/components/dialog/create-edit-folder-dialog.ts
@@ -61,15 +61,15 @@ export class CreateOrEditFolderDialog extends Component {
  }

  async isDialogOpen() {
-    return await browser.isElementPresent(by.css(CreateOrEditFolderDialog.selectors.root));
+    return browser.isElementPresent(by.css(CreateOrEditFolderDialog.selectors.root));
  }

  async getTitle() {
-    return await this.title.getText();
+    return this.title.getText();
  }

  async isValidationMessageDisplayed() {
-    return await this.validationMessage.isDisplayed();
+    return this.validationMessage.isDisplayed();
  }

  async isUpdateButtonEnabled() {
@@ -85,24 +85,24 @@ export class CreateOrEditFolderDialog extends Component {
  }

  async isNameDisplayed() {
-    return await this.nameInput.isDisplayed();
+    return this.nameInput.isDisplayed();
  }

  async isDescriptionDisplayed() {
-    return await this.descriptionTextArea.isDisplayed();
+    return this.descriptionTextArea.isDisplayed();
  }

  async getValidationMessage() {
    await this.isValidationMessageDisplayed();
-    return await this.validationMessage.getText();
+    return this.validationMessage.getText();
  }

  async getName() {
-    return await this.nameInput.getAttribute('value');
+    return this.nameInput.getAttribute('value');
  }

  async getDescription() {
-    return await this.descriptionTextArea.getAttribute('value');
+    return this.descriptionTextArea.getAttribute('value');
  }

  async enterName(name: string) {
--- a/e2e/components/dialog/create-library-dialog.ts
+++ b/e2e/components/dialog/create-library-dialog.ts
@@ -67,44 +67,44 @@ export class CreateLibraryDialog extends Component {
  }

  async isDialogOpen() {
-    return await browser.isElementPresent(by.css(CreateLibraryDialog.selectors.root));
+    return browser.isElementPresent(by.css(CreateLibraryDialog.selectors.root));
  }

  async getTitle() {
-    return await this.title.getText();
+    return this.title.getText();
  }

  async isErrorMessageDisplayed() {
-    return await this.errorMessage.isDisplayed();
+    return this.errorMessage.isDisplayed();
  }

  async getErrorMessage() {
    await this.isErrorMessageDisplayed();
-    return await this.errorMessage.getText();
+    return this.errorMessage.getText();
  }

  async isNameDisplayed() {
-    return await this.nameInput.isDisplayed();
+    return this.nameInput.isDisplayed();
  }

  async isLibraryIdDisplayed() {
-    return await this.libraryIdInput.isDisplayed();
+    return this.libraryIdInput.isDisplayed();
  }

  async isDescriptionDisplayed() {
-    return await this.descriptionTextArea.isDisplayed();
+    return this.descriptionTextArea.isDisplayed();
  }

  async isPublicDisplayed() {
-    return await this.visibilityPublic.isDisplayed();
+    return this.visibilityPublic.isDisplayed();
  }

  async isModeratedDisplayed() {
-    return await this.visibilityModerated.isDisplayed();
+    return this.visibilityModerated.isDisplayed();
  }

  async isPrivateDisplayed() {
-    return await this.visibilityPrivate.isDisplayed();
+    return this.visibilityPrivate.isDisplayed();
  }

  async enterName(name: string) {
@@ -128,11 +128,11 @@ export class CreateLibraryDialog extends Component {
  }

  async isCreateEnabled() {
-    return await this.createButton.isEnabled();
+    return this.createButton.isEnabled();
  }

  async isCancelEnabled() {
-    return await this.cancelButton.isEnabled();
+    return this.cancelButton.isEnabled();
  }

  async clickCreate() {
@@ -146,17 +146,17 @@ export class CreateLibraryDialog extends Component {

  async isPublicChecked() {
    const elemClass = await this.visibilityPublic.element(by.xpath('..')).getAttribute('class');
-    return await elemClass.includes(CreateLibraryDialog.selectors.radioChecked);
+    return elemClass.includes(CreateLibraryDialog.selectors.radioChecked);
  }

  async isModeratedChecked() {
    const elemClass = await this.visibilityModerated.element(by.xpath('..')).getAttribute('class');
-    return await elemClass.includes(CreateLibraryDialog.selectors.radioChecked);
+    return elemClass.includes(CreateLibraryDialog.selectors.radioChecked);
  }

  async isPrivateChecked() {
    const elemClass = await this.visibilityPrivate.element(by.xpath('..')).getAttribute('class');
-    return await elemClass.includes(CreateLibraryDialog.selectors.radioChecked);
+    return elemClass.includes(CreateLibraryDialog.selectors.radioChecked);
  }

  async selectPublic() {
--- a/e2e/components/dialog/manage-versions-dialog.ts
+++ b/e2e/components/dialog/manage-versions-dialog.ts
@@ -45,19 +45,19 @@ export class ManageVersionsDialog extends Component {
  }

  async waitForDialogToClose() {
-    return await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT);
+    await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT);
  }

  async isDialogOpen() {
-    return await browser.$(ManageVersionsDialog.selectors.root).isDisplayed();
+    return browser.$(ManageVersionsDialog.selectors.root).isDisplayed();
  }

  async getTitle() {
-    return await this.title.getText();
+    return this.title.getText();
  }

  async getText() {
-    return await this.content.getText();
+    return this.content.getText();
  }

  async clickClose() {
--- a/e2e/components/dialog/password-dialog.ts
+++ b/e2e/components/dialog/password-dialog.ts
@@ -58,33 +58,33 @@ export class PasswordDialog extends Component {
  }

  async isDialogOpen() {
-    return await browser.isElementPresent(by.css(PasswordDialog.selectors.root));
+    return browser.isElementPresent(by.css(PasswordDialog.selectors.root));
  }

  async getTitle() {
-    return await this.title.getText();
+    return this.title.getText();
  }

  async isCloseEnabled() {
-    return await this.closeButton.isEnabled();
+    return this.closeButton.isEnabled();
  }

  async isSubmitEnabled() {
-    return await this.submitButton.isEnabled();
+    return this.submitButton.isEnabled();
  }

  async clickClose() {
-    return await this.closeButton.click();
+    await this.closeButton.click();
  }

  async clickSubmit() {
-    return await this.submitButton.click();
+    await this.submitButton.click();
  }

  async isPasswordInputDisplayed() {
    const present = await browser.isElementPresent(this.passwordInput);
    if (present) {
-      return await this.passwordInput.isDisplayed();
+      return this.passwordInput.isDisplayed();
    } else {
      return false;
    }
@@ -92,12 +92,12 @@ export class PasswordDialog extends Component {

  async isErrorDisplayed() {
    const elem = await browser.wait(until.elementLocated(by.css(PasswordDialog.selectors.errorMessage)), BROWSER_WAIT_TIMEOUT, '------- timeout waiting for error message to appear')
-    return await browser.isElementPresent(elem);
+    return browser.isElementPresent(elem);
  }

  async getErrorMessage() {
    if (await this.isErrorDisplayed()) {
-      return await this.errorMessage.getText();
+      return this.errorMessage.getText();
    }
    return '';
  }
--- a/e2e/components/dialog/share-dialog.ts
+++ b/e2e/components/dialog/share-dialog.ts
@@ -71,15 +71,15 @@ export class ShareDialog extends Component {
  }

  async isDialogOpen() {
-    return await browser.isElementPresent(by.css(ShareDialog.selectors.root));
+    return browser.isElementPresent(by.css(ShareDialog.selectors.root));
  }

  async getTitle() {
-    return await this.title.getText();
+    return this.title.getText();
  }

  async getInfoText() {
-    return await this.infoText.getText();
+    return this.infoText.getText();
  }

  getLabels() {
@@ -87,15 +87,15 @@ export class ShareDialog extends Component {
  }

  async getLinkUrl() {
-    return await this.url.getAttribute('value');
+    return this.url.getAttribute('value');
  }

  async isUrlReadOnly() {
-    return await this.url.getAttribute('readonly');
+    return this.url.getAttribute('readonly');
  }

  async isCloseEnabled() {
-    return await this.closeButton.isEnabled();
+    return this.closeButton.isEnabled();
  }

  async clickClose() {
@@ -131,21 +131,21 @@ export class ShareDialog extends Component {
  }

  async copyUrl() {
-    return await this.urlAction.click();
+    await this.urlAction.click();
  }

  async openDatetimePicker() {
-    return await this.datetimePickerButton.click();
+    await this.datetimePickerButton.click();
  }

  async closeDatetimePicker() {
    if (await this.dateTimePicker.isCalendarOpen()) {
-      return await this.datetimePickerButton.click();
+      await this.datetimePickerButton.click();
    }
  }

  async getExpireDate() {
-    return await this.getExpireInput().getAttribute('value');
+    return this.getExpireInput().getAttribute('value');
  }

  async clickExpirationToggle() {
--- a/e2e/components/dialog/upload-new-version-dialog.ts
+++ b/e2e/components/dialog/upload-new-version-dialog.ts
@@ -56,32 +56,32 @@ export class UploadNewVersionDialog extends Component {
  }

  async waitForDialogToClose() {
-    return await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT);
+    await browser.wait(EC.stalenessOf(this.title), BROWSER_WAIT_TIMEOUT);
  }

  async isDialogOpen() {
-    return await browser.$(UploadNewVersionDialog.selectors.root).isDisplayed();
+    return browser.$(UploadNewVersionDialog.selectors.root).isDisplayed();
  }

  async getTitle() {
-    return await this.title.getText();
+    return this.title.getText();
  }

  async getText() {
-    return await this.content.getText();
+    return this.content.getText();
  }


  async isDescriptionDisplayed() {
-    return await this.description.isDisplayed();
+    return this.description.isDisplayed();
  }

  async isMinorOptionDisplayed() {
-    return await this.minorOption.isDisplayed();
+    return this.minorOption.isDisplayed();
  }

  async isMajorOptionDisplayed() {
-    return await this.majorOption.isDisplayed();
+    return this.majorOption.isDisplayed();
  }

  async isCancelButtonEnabled() {
@@ -105,11 +105,11 @@ export class UploadNewVersionDialog extends Component {


  async clickMajor() {
-    return await this.majorOption.click();
+    await this.majorOption.click();
  }

  async clickMinor() {
-    return await this.minorOption.click();
+    await this.minorOption.click();
  }


--- a/e2e/components/header/header.ts
+++ b/e2e/components/header/header.ts
@@ -62,19 +62,19 @@ export class Header extends Component {
  }

  async isSignOutDisplayed() {
-    return await this.userInfo.menu.isMenuItemPresent('Sign out');
+    return this.userInfo.menu.isMenuItemPresent('Sign out');
  }

  async clickSidenavToggle() {
    await this.sidenavToggle.click();
  }

-  async isExpandedSidenav() {
-    return await browser.isElementPresent(Header.selectors.expandedSidenav);
+  async isSidenavExpanded() {
+    return browser.isElementPresent(Header.selectors.expandedSidenav);
  }

  async expandSideNav() {
-    const expanded = await this.isExpandedSidenav();
+    const expanded = await this.isSidenavExpanded();
    if ( !expanded ) {
      await this.clickSidenavToggle();
      await browser.wait(until.elementLocated(Header.selectors.expandedSidenav), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for expanded sidenav' );
@@ -82,7 +82,7 @@ export class Header extends Component {
  }

  async collapseSideNav() {
-    const expanded = await this.isExpandedSidenav();
+    const expanded = await this.isSidenavExpanded();
    if ( expanded ) {
      await this.clickSidenavToggle();
      await browser.wait(until.elementLocated(Header.selectors.collapsedSidenav), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for collapsed sidenav')
--- a/e2e/components/info-drawer/info-drawer-comments-tab.ts
+++ b/e2e/components/info-drawer/info-drawer-comments-tab.ts
@@ -67,73 +67,73 @@ export class CommentsTab extends Component {
  }

  async getCommentsTabHeaderText() {
-    return await this.commentsHeader.getText();
+    return this.commentsHeader.getText();
  }

  async isCommentTextAreaDisplayed() {
-    return await browser.isElementPresent(this.commentTextarea);
+    return browser.isElementPresent(this.commentTextarea);
  }

  async isAddCommentButtonEnabled() {
    const present = await browser.isElementPresent(this.addCommentButton);
    if (present) {
-      return await this.addCommentButton.isEnabled();
+      return this.addCommentButton.isEnabled();
    }
    return false;
  }

  async getCommentListItem() {
-    return await browser.wait(until.elementLocated(this.commentListItem), BROWSER_WAIT_TIMEOUT / 2);
+    return browser.wait(until.elementLocated(this.commentListItem), BROWSER_WAIT_TIMEOUT / 2);
  }

  async getCommentById(commentId?: string) {
    if (commentId) {
-      return await browser.wait(until.elementLocated(by.id(`${CommentsTab.selectors.commentById}${commentId}`)), BROWSER_WAIT_TIMEOUT / 2);
+      return browser.wait(until.elementLocated(by.id(`${CommentsTab.selectors.commentById}${commentId}`)), BROWSER_WAIT_TIMEOUT / 2);
    }
-    return await this.getCommentListItem();
+    return this.getCommentListItem();
  }

  async isCommentDisplayed(commentId?: string) {
-    return await browser.isElementPresent(await this.getCommentById(commentId));
+    return browser.isElementPresent(await this.getCommentById(commentId));
  }

  async isCommentUserAvatarDisplayed(commentId?: string) {
    const commentElement = await this.getCommentById(commentId);
-    return await browser.isElementPresent(commentElement.findElement(this.commentUserAvatar));
+    return browser.isElementPresent(commentElement.findElement(this.commentUserAvatar));
  }

  async getCommentText(commentId?: string) {
    const commentElement = await this.getCommentById(commentId);
    const message = await commentElement.findElement(this.commentText);
-    return await message.getText();
+    return message.getText();
  }

  async getCommentUserName(commentId?: string) {
    const commentElement = await this.getCommentById(commentId);
    const user = await commentElement.findElement(this.commentUser);
-    return await user.getText();
+    return user.getText();
  }

  async getCommentTime(commentId?: string) {
    const commentElement = await this.getCommentById(commentId);
    const time = await commentElement.findElement(this.commentTime);
-    return await time.getText();
+    return time.getText();
  }

  async getNthCommentId(index: number) {
-    return await this.commentsList.get(index - 1).getAttribute('id');
+    return this.commentsList.get(index - 1).getAttribute('id');
  }

  async typeComment(text: string) {
-    return await this.commentTextarea.sendKeys(text);
+    await this.commentTextarea.sendKeys(text);
  }

  async clickAddButton() {
-    return await this.addCommentButton.click();
+    await this.addCommentButton.click();
  }

  async getCommentTextFromTextArea() {
-    return await this.commentTextarea.getAttribute('value');
+    return this.commentTextarea.getAttribute('value');
  }

 }
--- a/e2e/components/info-drawer/info-drawer-metadata-content.ts
+++ b/e2e/components/info-drawer/info-drawer-metadata-content.ts
@@ -58,11 +58,11 @@ export class ContentMetadata extends Component {
  }

  async isPropertiesListExpanded() {
-    return await browser.isElementPresent(this.expandedPanel);
+    return browser.isElementPresent(this.expandedPanel);
  }

  async waitForImagePropertiesPanelToExpand() {
-    return await browser.wait(EC.visibilityOf(this.expandedImagePropertiesPanel), BROWSER_WAIT_TIMEOUT);
+    await browser.wait(EC.visibilityOf(this.expandedImagePropertiesPanel), BROWSER_WAIT_TIMEOUT);
  }

  async getVisiblePropertiesLabels() {
@@ -98,19 +98,19 @@ export class ContentMetadata extends Component {
  }

  async isLessInfoButtonDisplayed() {
-    return await browser.isElementPresent(this.lessInfoButton);
+    return browser.isElementPresent(this.lessInfoButton);
  }

  async isMoreInfoButtonDisplayed() {
-    return await browser.isElementPresent(this.moreInfoButton);
+    return browser.isElementPresent(this.moreInfoButton);
  }

  async clickLessInformationButton() {
-    return await this.lessInfoButton.click();
+    await this.lessInfoButton.click();
  }

  async clickMoreInformationButton() {
-    return await this.moreInfoButton.click();
+    await this.moreInfoButton.click();
  }

  async isImagePropertiesPanelDisplayed() {
@@ -118,7 +118,7 @@ export class ContentMetadata extends Component {
  }

  async clickImagePropertiesPanel() {
-    return await this.imagePropertiesPanel.click();
+    await this.imagePropertiesPanel.click();
  }

 }
--- a/e2e/components/info-drawer/info-drawer-metadata-library.ts
+++ b/e2e/components/info-drawer/info-drawer-metadata-library.ts
@@ -72,7 +72,7 @@ export class LibraryMetadata extends Component {
  }

  async isFieldDisplayed(fieldName: string) {
-    return await browser.isElementPresent(this.getFieldByName(fieldName));
+    return browser.isElementPresent(this.getFieldByName(fieldName));
  }

  async isInputEnabled(fieldName: string) {
@@ -80,13 +80,13 @@ export class LibraryMetadata extends Component {
  }

  async getValueOfField(fieldName: string) {
-    return await this.getFieldByName(fieldName).getText();
+    return this.getFieldByName(fieldName).getText();
  }

  async enterTextInInput(fieldName: string, text: string) {
    const input = this.getFieldByName(fieldName);
    await input.clear();
-    return await input.sendKeys(text);
+    await input.sendKeys(text);
  }


@@ -99,11 +99,11 @@ export class LibraryMetadata extends Component {
  }

  async isButtonEnabled(button: string) {
-    return await this.getButton(button).isEnabled();
+    return this.getButton(button).isEnabled();
  }

  async clickButton(button: string) {
-    return await this.getButton(button).click();
+    await this.getButton(button).click();
  }

  async waitForVisibilityDropDownToOpen() {
@@ -115,68 +115,68 @@ export class LibraryMetadata extends Component {
  }

  async isMessageDisplayed() {
-    return await browser.isElementPresent(this.hint);
+    return browser.isElementPresent(this.hint);
  }

  async getMessage() {
-    return await this.hint.getText();
+    return this.hint.getText();
  }

  async isErrorDisplayed() {
-    return await browser.isElementPresent(this.error);
+    return browser.isElementPresent(this.error);
  }

  async getError() {
-    return await this.error.getText();
+    return this.error.getText();
  }


  async isNameDisplayed() {
-    return await this.isFieldDisplayed('Name');
+    return this.isFieldDisplayed('Name');
  }

  async isNameEnabled() {
-    return await this.isInputEnabled('Name');
+    return this.isInputEnabled('Name');
  }

  async getName() {
-    return await this.getValueOfField('Name');
+    return this.getValueOfField('Name');
  }

  async enterName(name: string) {
-    return await this.enterTextInInput('Name', name);
+    await this.enterTextInInput('Name', name);
  }


  async isDescriptionDisplayed() {
-    return await this.isFieldDisplayed('Description');
+    return this.isFieldDisplayed('Description');
  }

  async isDescriptionEnabled() {
-    return await this.isInputEnabled('Description');
+    return this.isInputEnabled('Description');
  }

  async getDescription() {
-    return await this.getValueOfField('Description');
+    return this.getValueOfField('Description');
  }

  async enterDescription(desc: string) {
-    return await this.enterTextInInput('Description', desc);
+    await this.enterTextInInput('Description', desc);
  }


  async isVisibilityEnabled() {
    const wrapper = this.getLabelWrapper('Visibility');
    const field = wrapper.element(by.xpath('..')).element(by.css(LibraryMetadata.selectors.dropDown));
-    return await field.isEnabled();
+    return field.isEnabled();
  }

  async isVisibilityDisplayed() {
-    return await this.isFieldDisplayed('Visibility');
+    return this.isFieldDisplayed('Visibility');
  }

  async getVisibility() {
-    return await this.getValueOfField('Visibility');
+    return this.getValueOfField('Visibility');
  }

  async setVisibility(visibility: string) {
@@ -200,54 +200,54 @@ export class LibraryMetadata extends Component {


  async isLibraryIdDisplayed() {
-    return await this.isFieldDisplayed('Library ID');
+    return this.isFieldDisplayed('Library ID');
  }

  async isLibraryIdEnabled() {
-    return await this.isInputEnabled('Library ID');
+    return this.isInputEnabled('Library ID');
  }

  async getLibraryId() {
-    return await this.getValueOfField('Library ID');
+    return this.getValueOfField('Library ID');
  }


  async isEditLibraryPropertiesEnabled() {
-    return await this.isButtonEnabled('Edit');
+    return this.isButtonEnabled('Edit');
  }

  async isEditLibraryPropertiesDisplayed() {
-    return await this.isButtonDisplayed('Edit');
+    return this.isButtonDisplayed('Edit');
  }

  async clickEditLibraryProperties() {
-    return await this.clickButton('Edit');
+    await this.clickButton('Edit');
  }


  async isUpdateEnabled() {
-    return await this.isButtonEnabled('Update');
+    return this.isButtonEnabled('Update');
  }

  async isUpdateDisplayed() {
-    return await this.isButtonDisplayed('Update');
+    return this.isButtonDisplayed('Update');
  }

  async clickUpdate() {
-    return await this.clickButton('Update');
+    await this.clickButton('Update');
  }


  async isCancelEnabled() {
-    return await this.isButtonEnabled('Cancel');
+    return this.isButtonEnabled('Cancel');
  }

  async isCancelDisplayed() {
-    return await this.isButtonDisplayed('Cancel');
+    return this.isButtonDisplayed('Cancel');
  }

  async clickCancel() {
-    return await this.clickButton('Cancel');
+    await this.clickButton('Cancel');
  }

 }
--- a/e2e/components/info-drawer/info-drawer.ts
+++ b/e2e/components/info-drawer/info-drawer.ts
@@ -69,11 +69,11 @@ export class InfoDrawer extends Component {
  }

  async waitForInfoDrawerToOpen() {
-    return await browser.wait(EC.presenceOf(this.header), BROWSER_WAIT_TIMEOUT);
+    await browser.wait(EC.presenceOf(this.header), BROWSER_WAIT_TIMEOUT);
  }

  async isOpen() {
-    return await browser.isElementPresent(this.header);
+    return browser.isElementPresent(this.header);
  }

  async isEmpty() {
@@ -85,27 +85,27 @@ export class InfoDrawer extends Component {
  }

  async getTabsCount() {
-    return await this.component.all(by.css(InfoDrawer.selectors.tabLabel)).count();
+    return this.component.all(by.css(InfoDrawer.selectors.tabLabel)).count();
  }

  async isTabPresent(title: string) {
-    return await this.getTabByTitle(title).isPresent();
+    return this.getTabByTitle(title).isPresent();
  }

  async isTabDisplayed(title: string): Promise<boolean> {
    if (await browser.isElementPresent(this.getTabByTitle(title))) {
-      return await this.getTabByTitle(title).isDisplayed();
+      return this.getTabByTitle(title).isDisplayed();
    }

    return false;
  }

  async getTabTitle(index: number) {
-    return await this.tabLabelsList.get(index - 1).getAttribute('innerText');
+    return this.tabLabelsList.get(index - 1).getAttribute('innerText');
  }

  async getActiveTabTitle() {
-    return await this.tabActiveLabel.getText();
+    return this.tabActiveLabel.getText();
  }

  async clickTab(title: string) {
@@ -113,19 +113,19 @@ export class InfoDrawer extends Component {
  }

  async getComponentIdOfTab() {
-    return await this.tabActiveContent.getAttribute('data-automation-id');
+    return this.tabActiveContent.getAttribute('data-automation-id');
  }

  async getHeaderTitle() {
-    return await this.headerTitle.getText();
+    return this.headerTitle.getText();
  }

  async isAboutTabDisplayed() {
-    return await this.isTabDisplayed('About');
+    return this.isTabDisplayed('About');
  }

  async isPropertiesTabDisplayed() {
-    return await this.isTabDisplayed('Properties');
+    return this.isTabDisplayed('Properties');
  }

  async isPropertiesTabActive() {
@@ -133,7 +133,7 @@ export class InfoDrawer extends Component {
  }

  async isCommentsTabDisplayed() {
-    return await this.isTabDisplayed('Comments');
+    return this.isTabDisplayed('Comments');
  }

  async clickCommentsTab() {
@@ -145,8 +145,7 @@ export class InfoDrawer extends Component {
        browser.wait(EC.invisibilityOf(this.propertiesTab.component), BROWSER_WAIT_TIMEOUT)
      ]);
    } catch (error) {
-      console.error('--- catch error on clickCommentsTab ---');
-      throw error;
+      console.error('--- info-drawer clickCommentsTab catch error: ', error);
    }
  }

--- a/e2e/components/login/login.ts
+++ b/e2e/components/login/login.ts
@@ -73,7 +73,7 @@ export class LoginComponent extends Component {
  }

  async clickPasswordVisibility() {
-    return await this.passwordVisibility.click();
+    await this.passwordVisibility.click();
  }

  async getPasswordVisibility(): Promise<boolean> {
@@ -105,15 +105,15 @@ export class LoginComponent extends Component {
  }

  async isUsernameEnabled() {
-    return await this.usernameInput.isEnabled();
+    return this.usernameInput.isEnabled();
  }

  async isPasswordEnabled() {
-    return await this.passwordInput.isEnabled();
+    return this.passwordInput.isEnabled();
  }

  async isSubmitEnabled() {
-    return await this.submitButton.isEnabled();
+    return this.submitButton.isEnabled();
  }

  async isPasswordHidden() {
--- a/e2e/components/menu/menu.ts
+++ b/e2e/components/menu/menu.ts
@@ -112,19 +112,19 @@ export class Menu extends Component {
  }

  async getItemTooltip(menuItem: string) {
-    return await this.getItemByLabel(menuItem).getAttribute('title');
+    return this.getItemByLabel(menuItem).getAttribute('title');
  }

  async getItemIconText(menuItem: string) {
-    return await this.getItemByLabel(menuItem).element(by.css(Menu.selectors.icon)).getText();
+    return this.getItemByLabel(menuItem).element(by.css(Menu.selectors.icon)).getText();
  }

  async getItemIdAttribute(menuItem: string) {
-    return await this.getItemByLabel(menuItem).getAttribute('id');
+    return this.getItemByLabel(menuItem).getAttribute('id');
  }

  async getItemsCount() {
-    return await this.items.count();
+    return this.items.count();
  }

  async getMenuItems(): Promise<string[]> {
@@ -190,15 +190,15 @@ export class Menu extends Component {
  }

  async isMenuItemPresent(title: string) {
-    return await browser.element(by.cssContainingText(Menu.selectors.item, title)).isPresent();
+    return browser.element(by.cssContainingText(Menu.selectors.item, title)).isPresent();
  }

  async isSubMenuItemPresent(title: string) {
-    return await browser.element(by.cssContainingText(Menu.selectors.submenu, title)).isPresent();
+    return browser.element(by.cssContainingText(Menu.selectors.submenu, title)).isPresent();
  }

  async getSubmenuItemsCount() {
-    return await this.submenus.count();
+    return this.submenus.count();
  }

  async isMenuItemDisabled(title: string): Promise<string | null> {
@@ -217,7 +217,7 @@ export class Menu extends Component {
  }

  async clickEditFolder() {
-    return await this.editFolderAction.click();
+    await this.editFolderAction.click();
  }

  async clickShare() {
@@ -232,127 +232,126 @@ export class Menu extends Component {


  async isViewPresent() {
-    return await this.viewAction.isPresent();
+    return this.viewAction.isPresent();
  }

  async isDownloadPresent() {
-    return await this.downloadAction.isPresent();
+    return this.downloadAction.isPresent();
  }

  async isEditFolderPresent() {
-    return await this.editFolderAction.isPresent();
+    return this.editFolderAction.isPresent();
  }

  async isEditOfflinePresent() {
-    return await this.editOfflineAction.isPresent();
+    return this.editOfflineAction.isPresent();
  }

  async isCancelEditingPresent() {
-    return await this.cancelEditingAction.isPresent();
+    return this.cancelEditingAction.isPresent();
  }

  async isCopyPresent() {
-    return await this.copyAction.isPresent();
+    return this.copyAction.isPresent();
  }

  async isMovePresent() {
-    return await this.moveAction.isPresent();
+    return this.moveAction.isPresent();
  }

  async isDeletePresent() {
-    return await this.deleteAction.isPresent();
+    return this.deleteAction.isPresent();
  }

  async isManagePermissionsPresent() {
-    return await this.managePermissionsAction.isPresent();
+    return this.managePermissionsAction.isPresent();
  }

  async isManageVersionsPresent() {
-    return await this.manageVersionsAction.isPresent();
+    return this.manageVersionsAction.isPresent();
  }

  async isUploadNewVersionPresent() {
-    return await this.uploadNewVersionAction.isPresent();
+    return this.uploadNewVersionAction.isPresent();
  }

  async isFavoritePresent() {
-    return await this.favoriteAction.isPresent();
+    return this.favoriteAction.isPresent();
  }

  async isRemoveFavoritePresent() {
-    return await this.removeFavoriteAction.isPresent();
+    return this.removeFavoriteAction.isPresent();
  }

  async isToggleFavoritePresent() {
-    return await this.toggleFavoriteAction.isPresent();
+    return this.toggleFavoriteAction.isPresent();
  }

  async isToggleRemoveFavoritePresent() {
-    return await this.toggleRemoveFavoriteAction.isPresent();
+    return this.toggleRemoveFavoriteAction.isPresent();
  }

  async isJoinLibraryPresent() {
-    return await this.joinAction.isPresent();
+    return this.joinAction.isPresent();
  }

  async isCancelJoinPresent() {
-    return await this.cancelJoinAction.isPresent();
+    return this.cancelJoinAction.isPresent();
  }

  async isLeaveLibraryPresent() {
-    return await this.leaveAction.isPresent();
+    return this.leaveAction.isPresent();
  }

  async isPermanentDeletePresent() {
-    return await this.permanentDeleteAction.isPresent();
+    return this.permanentDeleteAction.isPresent();
  }

  async isRestorePresent() {
-    return await this.restoreAction.isPresent();
+    return this.restoreAction.isPresent();
  }

  async isSharePresent() {
-    return await this.shareAction.isPresent();
+    return this.shareAction.isPresent();
  }

  async isSharedLinkSettingsPresent() {
-    return await this.shareEditAction.isPresent();
+    return this.shareEditAction.isPresent();
  }

  async isViewDetailsPresent() {
-    return await this.viewDetailsAction.isPresent();
+    return this.viewDetailsAction.isPresent();
  }

  async isCreateFolderPresent() {
-    return await this.createFolderAction.isPresent();
+    return this.createFolderAction.isPresent();
  }
  async isCreateFolderEnabled() {
-    return await this.createFolderAction.isEnabled();
+    return this.createFolderAction.isEnabled();
  }

  async isCreateLibraryPresent() {
-    return await this.createLibraryAction.isPresent();
+    return this.createLibraryAction.isPresent();
  }
  async isCreateLibraryEnabled() {
-    return await this.createLibraryAction.isEnabled();
+    return this.createLibraryAction.isEnabled();
  }

  async isUploadFilePresent() {
-    return await this.uploadFileAction.isPresent();
+    return this.uploadFileAction.isPresent();
  }
  async isUploadFileEnabled() {
-    return await this.uploadFileAction.isEnabled();
+    return this.uploadFileAction.isEnabled();
  }

  async isUploadFolderPresent() {
-    return await this.uploadFolderAction.isPresent();
+    return this.uploadFolderAction.isPresent();
  }
  async isUploadFolderEnabled() {
-    return await this.uploadFolderAction.isEnabled();
+    return this.uploadFolderAction.isEnabled();
  }


-
  async clickCreateFolder() {
    const action = this.createFolderAction;
    await action.click();
--- a/e2e/components/metadata-card/metadata-card.ts
+++ b/e2e/components/metadata-card/metadata-card.ts
@@ -44,7 +44,7 @@ export class MetadataCard extends Component {
  }

  async isExpandPresent() {
-    return await this.expandButton.isPresent();
+    return this.expandButton.isPresent();
  }

  async clickExpandButton() {
@@ -52,15 +52,15 @@ export class MetadataCard extends Component {
  }

  async waitForFirstExpansionPanel() {
-    return await browser.wait(EC.presenceOf(this.expansionPanels.get(0)), BROWSER_WAIT_TIMEOUT);
+    await browser.wait(EC.presenceOf(this.expansionPanels.get(0)), BROWSER_WAIT_TIMEOUT);
  }

  async isExpansionPanelPresent(index) {
-    return await this.expansionPanels.get(index).isPresent();
+    return this.expansionPanels.get(index).isPresent();
  }

  async getComponentIdOfPanel(index) {
-    return await this.expansionPanels.get(index).getAttribute('data-automation-id');
+    return this.expansionPanels.get(index).getAttribute('data-automation-id');
  }
 }

--- a/e2e/components/pagination/pagination.ts
+++ b/e2e/components/pagination/pagination.ts
@@ -110,54 +110,54 @@ export class Pagination extends Component {
  }

  async isNextEnabled() {
-    return await this.nextButton.isEnabled();
+    return this.nextButton.isEnabled();
  }

  async isPreviousEnabled() {
-    return await this.previousButton.isEnabled();
+    return this.previousButton.isEnabled();
  }

  async isPagesButtonPresent() {
-    return await browser.isElementPresent(this.pagesButton);
+    return browser.isElementPresent(this.pagesButton);
  }

  async isRangePresent() {
-    return await this.range.isPresent();
+    return this.range.isPresent();
  }

  async isMaxItemsPresent() {
-    return await this.maxItems.isPresent();
+    return this.maxItems.isPresent();
  }

  async isCurrentPagePresent() {
-    return await this.currentPage.isPresent();
+    return this.currentPage.isPresent();
  }

  async isTotalPagesPresent() {
-    return await this.totalPages.isPresent();
+    return this.totalPages.isPresent();
  }

  async isPreviousButtonPresent() {
-    return await this.previousButton.isPresent();
+    return this.previousButton.isPresent();
  }

  async isNextButtonPresent() {
-    return await this.nextButton.isPresent();
+    return this.nextButton.isPresent();
  }

  async getCurrentPage() {
-    return await this.currentPage.getText();
+    return this.currentPage.getText();
  }

  async getRange() {
-    return await this.range.getText();
+    return this.range.getText();
  }

  async getMaxItems() {
-    return await this.maxItems.getText();
+    return this.maxItems.getText();
  }

  async getTotalPages() {
-    return await this.totalPages.getText();
+    return this.totalPages.getText();
  }
 }
--- a/e2e/components/search/search-input.ts
+++ b/e2e/components/search/search-input.ts
@@ -55,7 +55,7 @@ export class SearchInput extends Component {
  }

  async waitForSearchControl() {
-    return await browser.wait(EC.presenceOf(this.searchControl), BROWSER_WAIT_TIMEOUT, '--- timeout waitForSearchControl ---');
+    await browser.wait(EC.presenceOf(this.searchControl), BROWSER_WAIT_TIMEOUT, '--- timeout waitForSearchControl ---');
  }

  async isSearchContainerDisplayed() {
@@ -70,22 +70,22 @@ export class SearchInput extends Component {

  async isOptionsAreaDisplayed() {
    await browser.wait(until.elementLocated(by.css(SearchInput.selectors.searchControl)), BROWSER_WAIT_TIMEOUT);
-    return await browser.isElementPresent(this.searchOptionsArea);
+    return browser.isElementPresent(this.searchOptionsArea);
  }

  async clickFilesOption() {
    await browser.wait(EC.elementToBeClickable(this.searchFilesOption), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for Files to be clickable');
-    return await this.searchFilesOption.click();
+    await this.searchFilesOption.click();
  }

  async clickFoldersOption() {
    await browser.wait(EC.elementToBeClickable(this.searchFoldersOption), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for Folders to be clickable');
-    return await this.searchFoldersOption.click();
+    await this.searchFoldersOption.click();
  }

  async clickLibrariesOption() {
    await browser.wait(EC.elementToBeClickable(this.searchLibrariesOption), BROWSER_WAIT_TIMEOUT, '--- timeout waiting for Libraries to be clickable');
-    return await this.searchLibrariesOption.click();
+    await this.searchLibrariesOption.click();
  }

  async isFilesOptionEnabled() {
@@ -131,12 +131,12 @@ export class SearchInput extends Component {
  }

  async isClearSearchButtonPresent() {
-    return await browser.isElementPresent(this.clearSearchButton);
+    return browser.isElementPresent(this.clearSearchButton);
  }

  async clickClearSearchButton() {
    if (await this.isClearSearchButtonPresent()) {
-      return await this.clearSearchButton.click();
+      await this.clearSearchButton.click();
    }
  }

--- a/e2e/components/sidenav/sidenav.ts
+++ b/e2e/components/sidenav/sidenav.ts
@@ -146,7 +146,7 @@ export class Sidenav extends Component {

    await browser.wait(condition, BROWSER_WAIT_TIMEOUT);

-    return await link.getAttribute('title');
+    return link.getAttribute('title');
  }

  async clickLink(name: string) {
@@ -154,18 +154,17 @@ export class Sidenav extends Component {
      const link = this.getLinkLabel(name);
      await Utils.waitUntilElementClickable(link);
      return await link.click();
-
-    } catch (e){
-      console.log('---- sidebar navigation catch clickLink: ', e);
+    } catch (error) {
+      console.log('---- sidebar navigation clickLink catch error: ', error);
    }
  }

  async isFileLibrariesMenuExpanded() {
-    return await element(by.cssContainingText('.mat-expanded', SIDEBAR_LABELS.FILE_LIBRARIES)).isPresent();
+    return element(by.cssContainingText('.mat-expanded', SIDEBAR_LABELS.FILE_LIBRARIES)).isPresent();
  }

  async expandFileLibraries() {
-    return await this.expandMenu(SIDEBAR_LABELS.FILE_LIBRARIES);
+    await this.expandMenu(SIDEBAR_LABELS.FILE_LIBRARIES);
  }

 }
--- a/e2e/components/toolbar/toolbar.ts
+++ b/e2e/components/toolbar/toolbar.ts
@@ -74,7 +74,7 @@ export class Toolbar extends Component {
  }

  async numberOfAvailableActions() {
-    return await this.buttons.count();
+    return this.buttons.count();
  }

  async getButtons(): Promise<string[]> {
@@ -85,7 +85,7 @@ export class Toolbar extends Component {

  async isButtonPresent(title: string) {
    const elem = this.component.element(by.css(`${Toolbar.selectors.button}[title="${title}"]`));
-    return await elem.isPresent();
+    return elem.isPresent();
  }

  getButtonByLabel(label: string) {
@@ -112,7 +112,7 @@ export class Toolbar extends Component {
  }

  async getButtonTooltip(button: ElementFinder) {
-    return await button.getAttribute('title');
+    return button.getAttribute('title');
  }

  async clickButton(title: string) {
@@ -122,47 +122,47 @@ export class Toolbar extends Component {


  async isSharedLinkSettingsPresent() {
-    return await browser.isElementPresent(this.shareEditButton);
+    return browser.isElementPresent(this.shareEditButton);
  }

  async isSharePresent() {
-    return await browser.isElementPresent(this.shareButton);
+    return browser.isElementPresent(this.shareButton);
  }

  async isViewPresent() {
-    return await browser.isElementPresent(this.viewButton);
+    return browser.isElementPresent(this.viewButton);
  }

  async isToggleSearchFiltersPresent() {
-    return await browser.isElementPresent(this.searchFiltersToggleButton);
+    return browser.isElementPresent(this.searchFiltersToggleButton);
  }

  async isDownloadPresent() {
-    return await browser.isElementPresent(this.downloadButton);
+    return browser.isElementPresent(this.downloadButton);
  }

  async isPermanentlyDeletePresent() {
-    return await browser.isElementPresent(this.permanentlyDeleteButton);
+    return browser.isElementPresent(this.permanentlyDeleteButton);
  }

  async isRestorePresent() {
-    return await browser.isElementPresent(this.restoreButton);
+    return browser.isElementPresent(this.restoreButton);
  }

  async isEditFolderPresent() {
-    return await browser.isElementPresent(this.editFolderButton);
+    return browser.isElementPresent(this.editFolderButton);
  }

  async isViewDetailsPresent() {
-    return await browser.isElementPresent(this.viewDetailsButton);
+    return browser.isElementPresent(this.viewDetailsButton);
  }

  async isPrintPresent() {
-    return await browser.isElementPresent(this.printButton);
+    return browser.isElementPresent(this.printButton);
  }

  async isFullScreenPresent() {
-    return await browser.isElementPresent(this.fullScreenButton);
+    return browser.isElementPresent(this.fullScreenButton);
  }


@@ -177,84 +177,84 @@ export class Toolbar extends Component {
  }

  async clickView() {
-    return await this.viewButton.click();
+    await this.viewButton.click();
  }

  async clickEditFolder() {
-    return await this.editFolderButton.click();
+    await this.editFolderButton.click();
  }

  async clickViewDetails() {
-    return await this.viewDetailsButton.click();
+    await this.viewDetailsButton.click();
  }

  async clickDownload() {
-    return await this.downloadButton.click();
+    await this.downloadButton.click();
  }

  async clickJoin() {
-    return await this.joinButton.click();
+    await this.joinButton.click();
  }

  async clickLeave() {
-    return await this.leaveButton.click();
+    await this.leaveButton.click();
  }

  async clickPermanentlyDelete() {
-    return await this.permanentlyDeleteButton.click();
+    await this.permanentlyDeleteButton.click();
  }
  async clickRestore() {
-    return await this.restoreButton.click();
+    await this.restoreButton.click();
  }


  async clickMoreActionsFavorite() {
    await this.openMoreMenu();
-    return await this.menu.clickMenuItem('Favorite');
+    await this.menu.clickMenuItem('Favorite');
  }

  async clickMoreActionsRemoveFavorite() {
    await this.openMoreMenu();
-    return await this.menu.clickMenuItem('Remove Favorite');
+    await this.menu.clickMenuItem('Remove Favorite');
  }

  async clickMoreActionsDelete() {
    await this.openMoreMenu();
-    return await this.menu.clickMenuItem('Delete');
+    await this.menu.clickMenuItem('Delete');
  }

  async clickMoreActionsManageVersions() {
    await this.openMoreMenu();
-    return await this.menu.clickMenuItem('Manage Versions');
+    await this.menu.clickMenuItem('Manage Versions');
  }

  async clickMoreActionsMove() {
    await this.openMoreMenu();
-    return await this.menu.clickMenuItem('Move');
+    await this.menu.clickMenuItem('Move');
  }

  async clickMoreActionsCopy() {
    await this.openMoreMenu();
-    return await this.menu.clickMenuItem('Copy');
+    await this.menu.clickMenuItem('Copy');
  }

  async clickMoreActionsEditOffline() {
    await this.openMoreMenu();
-    return await this.menu.clickMenuItem('Edit Offline');
+    await this.menu.clickMenuItem('Edit Offline');
  }

  async clickMoreActionsCancelEditing() {
    await this.openMoreMenu();
-    return await this.menu.clickMenuItem('Cancel Editing');
+    await this.menu.clickMenuItem('Cancel Editing');
  }

  async clickMoreActionsUploadNewVersion() {
    await this.openMoreMenu();
-    return await this.menu.clickMenuItem('Upload New Version');
+    await this.menu.clickMenuItem('Upload New Version');
  }

  async clickFullScreen() {
-    return await this.fullScreenButton.click();
+    await this.fullScreenButton.click();
  }

 }
--- a/e2e/components/viewer/viewer.ts
+++ b/e2e/components/viewer/viewer.ts
@@ -65,23 +65,23 @@ export class Viewer extends Component {
  }

  async isViewerOpened() {
-    return await browser.isElementPresent(this.viewerLayout);
+    return browser.isElementPresent(this.viewerLayout);
  }

  async isViewerContentDisplayed() {
-    return await browser.isElementPresent(this.viewerContainer);
+    return browser.isElementPresent(this.viewerContainer);
  }

  async isViewerToolbarDisplayed() {
-    return await browser.isElementPresent(this.toolbar.component);
+    return browser.isElementPresent(this.toolbar.component);
  }

  async isCloseButtonDisplayed() {
-    return await browser.isElementPresent(this.closeButton);
+    return browser.isElementPresent(this.closeButton);
  }

  async isFileTitleDisplayed() {
-    return await browser.isElementPresent(this.fileTitle);
+    return browser.isElementPresent(this.fileTitle);
  }

  async clickClose() {
@@ -89,23 +89,23 @@ export class Viewer extends Component {
  }

  async getCloseButtonTooltip() {
-    return await this.toolbar.getButtonTooltip(this.closeButton);
+    return this.toolbar.getButtonTooltip(this.closeButton);
  }

  async getFileTitle() {
-    return await this.fileTitle.getText();
+    return this.fileTitle.getText();
  }

  async isCustomContentPresent() {
-    return await browser.isElementPresent(this.viewerExtensionContent);
+    return browser.isElementPresent(this.viewerExtensionContent);
  }

-  async getComponentIdOfView(): Promise<string|null> {
+  async getComponentIdOfView(): Promise<string> {
    if (await this.isCustomContentPresent()) {
-      return await this.viewerExtensionContent.getAttribute('data-automation-id');
+      return this.viewerExtensionContent.getAttribute('data-automation-id');
    }

-    return null;
+    return '';
  }

  async isPdfViewerContentDisplayed() {