@eclipse-che/che-e2e 7.64.0-dev-20514b2 → 7.64.0-dev-db63138

package/specs/factory/RefusedOAuthFactory.spec.ts

@@ -0,0 +1,260 @@
+/*********************************************************************
+ * Copyright (c) 2021 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+
+import 'reflect-metadata';
+import { e2eContainer } from '../../configs/inversify.config';
+import {
+    ActivityBar,
+    ContextMenu,
+    EditorView,
+    error,
+    InputBox,
+    Locators,
+    ModalDialog,
+    NewScmView,
+    SideBarView,
+    SingleScmProvider,
+    TextEditor,
+    ViewControl,
+    ViewItem,
+    ViewSection
+} from 'monaco-page-objects';
+import { expect } from 'chai';
+import WebDriverError = error.WebDriverError;
+import { registerRunningWorkspace } from '../MochaHooks';
+import { BrowserTabsUtil } from '../../utils/BrowserTabsUtil';
+import { CLASSES } from '../../configs/inversify.types';
+import { WorkspaceHandlingTests } from '../../tests-library/WorkspaceHandlingTests';
+import { CheCodeLocatorLoader } from '../../pageobjects/ide/CheCodeLocatorLoader';
+import { ProjectAndFileTests } from '../../tests-library/ProjectAndFileTests';
+import { DriverHelper } from '../../utils/DriverHelper';
+import { TestConstants } from '../../constants/TestConstants';
+import { OauthPage } from '../../pageobjects/git-providers/OauthPage';
+import { GitUtil } from '../../utils/vsc/GitUtil';
+import { Logger } from '../../utils/Logger';
+import { TimeoutConstants } from '../../constants/TimeoutConstants';
+import { LoginTests } from '../../tests-library/LoginTests';
+
+const browserTabsUtil: BrowserTabsUtil = e2eContainer.get(CLASSES.BrowserTabsUtil);
+const workspaceHandlingTests: WorkspaceHandlingTests = e2eContainer.get(CLASSES.WorkspaceHandlingTests);
+const projectAndFileTests: ProjectAndFileTests = e2eContainer.get(CLASSES.ProjectAndFileTests);
+const webCheCodeLocators: Locators = new CheCodeLocatorLoader().webCheCodeLocators;
+const driverHelper: DriverHelper = e2eContainer.get(CLASSES.DriverHelper);
+const loginTests: LoginTests = e2eContainer.get(CLASSES.LoginTests);
+
+suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SELENIUM_FACTORY_GIT_PROVIDER} repository and deny the access`, async function () {
+    const oauthPage: OauthPage = new OauthPage(driverHelper);
+
+    let projectSection: ViewSection;
+    let scmProvider: SingleScmProvider;
+    let rest: SingleScmProvider[];
+    let scmContextMenu: ContextMenu;
+    const gitUtil: GitUtil = new GitUtil();
+
+    // test specific data
+    const timeToRefresh: number = 1500;
+    const changesToCommit: string = (new Date()).getTime().toString();
+    const fileToChange: string = 'Date.txt';
+    const commitChangesButtonLabel: string = `Commit Changes on "${TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_BRANCH}"`;
+    const refreshButtonLabel: string = 'Refresh';
+    const pushItemLabel: string = 'Push';
+    const label: string = TestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME;
+    const testRepoProjectName: string = gitUtil.getProjectNameFromGitUrl(TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_URL);
+    const isPrivateRepo: string = TestConstants.TS_SELENIUM_IS_PRIVATE_FACTORY_GIT_REPO ? 'private' : 'public';
+
+    loginTests.loginIntoChe();
+
+    test(`Navigate to the ${isPrivateRepo} repository factory URL`, async function () {
+        await browserTabsUtil.navigateTo(TestConstants.TS_SELENIUM_FACTORY_URL());
+    });
+
+    if (TestConstants.TS_SELENIUM_GIT_PROVIDER_OAUTH) {
+        test(`Authorize with a ${TestConstants.TS_SELENIUM_FACTORY_GIT_PROVIDER} OAuth and deny access`, async function () {
+            await oauthPage.login();
+            await oauthPage.waitOauthPage();
+            await oauthPage.denyAccess();
+        });
+    }
+
+    workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
+
+    test('The workspace starts with access deny flag in the url', async function () {
+        expect(await driverHelper.getDriver().getCurrentUrl()).contains('&error_code=access_denied');
+    });
+
+    test('Registering the running workspace', async function () {
+        registerRunningWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+    });
+
+    test('Wait the workspace readiness', async function () {
+        await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
+    });
+
+    test('Check if a project folder has been created', async function () {
+        Logger.debug(`new SideBarView().getContent().getSection: get ${testRepoProjectName}`);
+        projectSection = await new SideBarView().getContent().getSection(testRepoProjectName as unknown as string);
+    });
+
+    test('Accept the project as a trusted one', async function () {
+        // click somewhere to trigger "Welcome Content" dialog
+        try {
+            await driverHelper.waitAndClick(webCheCodeLocators.Workbench.notificationItem);
+        } catch (e) {
+            Logger.info(`Click on ${webCheCodeLocators.Workbench.notificationItem} to get "Welcome Content" dialog ${e as string}`);
+        }
+        // "Welcome Content" dialog can be shown before of after dialog with an error for private repo
+        try {
+            const buttonYesITrustTheAuthors: string = `Yes, I trust the authors`;
+            await driverHelper.waitVisibility(webCheCodeLocators.WelcomeContent.text, TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM);
+            const welcomeContentDialog: ModalDialog = new ModalDialog();
+            Logger.debug(`trustedProjectDialog.pushButton: "${buttonYesITrustTheAuthors}"`);
+            await welcomeContentDialog.pushButton(buttonYesITrustTheAuthors);
+            await driverHelper.waitDisappearance(webCheCodeLocators.WelcomeContent.text);
+        } catch (e) {
+            Logger.info(`"Accept the project as a trusted one" dialog was not shown firstly for "${isPrivateRepo}"`);
+            if (!TestConstants.TS_SELENIUM_IS_PRIVATE_FACTORY_GIT_REPO) {
+                throw new WebDriverError(e as string);
+            }
+        }
+    });
+
+    if (TestConstants.TS_SELENIUM_IS_PRIVATE_FACTORY_GIT_REPO) {
+        test('Check that project can not be cloned', async function () {
+            await driverHelper.waitVisibility(webCheCodeLocators.Dialog.message);
+            const workspaceDoesNotExistDialog: ModalDialog = new ModalDialog();
+            const message: string = await workspaceDoesNotExistDialog.getMessage();
+            expect(message).contains('space does not exist');
+        });
+
+        test('Check that project files were not imported', async function () {
+            const isFileImported: ViewItem | undefined = await projectSection.findItem(label);
+            expect(isFileImported).eqls(undefined);
+        });
+
+    } else {
+        test('Check if the project files were imported', async function () {
+            Logger.debug(`projectSection.findItem: find ${label}`);
+            const isFileImported: ViewItem | undefined = await projectSection.findItem(label);
+            // projectSection.findItem(label) can return undefined but test will goes on
+            expect(isFileImported).not.eqls(undefined);
+        });
+
+        test('Make changes to the file', async function () {
+            Logger.debug(`projectSection.openItem: "${fileToChange}"`);
+            await projectSection.openItem(fileToChange);
+            const editor: TextEditor = await new EditorView().openEditor(fileToChange) as TextEditor;
+            await driverHelper.waitVisibility(webCheCodeLocators.Editor.inputArea);
+            Logger.debug(`editor.clearText`);
+            await editor.clearText();
+            Logger.debug(`editor.typeTextAt: "${changesToCommit}"`);
+            await editor.typeTextAt(1, 1, changesToCommit);
+        });
+
+        test('Open a source control manager', async function () {
+            const viewSourceControl: string = `Source Control`;
+            const sourceControl: ViewControl = await new ActivityBar().getViewControl(viewSourceControl) as ViewControl;
+            Logger.debug(`sourceControl.openView: "${viewSourceControl}"`);
+            await sourceControl.openView();
+            const scmView: NewScmView = new NewScmView();
+            await driverHelper.waitVisibility(webCheCodeLocators.ScmView.actionConstructor(commitChangesButtonLabel));
+            [scmProvider, ...rest] = await scmView.getProviders();
+            Logger.debug(`scmView.getProviders: "${scmProvider}, ${scmProvider}"`);
+        });
+
+        test('Check if the changes is displayed in the source control manager', async function () {
+            await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
+            await driverHelper.wait(timeToRefresh);
+            Logger.debug(`scmProvider.takeAction: "${refreshButtonLabel}"`);
+            await scmProvider.takeAction(refreshButtonLabel);
+            // wait while changes counter will be refreshed
+            await driverHelper.wait(timeToRefresh);
+            const changes: number = await scmProvider.getChangeCount();
+            Logger.debug(`scmProvider.getChangeCount: number of changes is "${changes}"`);
+            expect(changes).eql(1);
+        });
+
+        test('Stage the changes', async function () {
+            await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
+            Logger.debug(`scmProvider.openMoreActions`);
+            scmContextMenu = await scmProvider.openMoreActions();
+            await driverHelper.waitVisibility(webCheCodeLocators.ContextMenu.contextView);
+            Logger.debug(`scmContextMenu.select: "Changes" -> "Stage All Changes"`);
+            await scmContextMenu.select('Changes', 'Stage All Changes');
+        });
+
+        test('Commit the changes', async function () {
+            await driverHelper.waitVisibility(webCheCodeLocators.ScmView.actionConstructor(commitChangesButtonLabel));
+            Logger.debug(`scmProvider.commitChanges: commit name "Commit ${changesToCommit}"`);
+            await scmProvider.commitChanges('Commit ' + changesToCommit);
+            await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
+            await driverHelper.wait(timeToRefresh);
+            Logger.debug(`scmProvider.takeAction: "${refreshButtonLabel}"`);
+            await scmProvider.takeAction(refreshButtonLabel);
+            // wait while changes counter will be refreshed
+            await driverHelper.wait(timeToRefresh);
+            const changes: number = await scmProvider.getChangeCount();
+            Logger.debug(`scmProvider.getChangeCount: number of changes is "${changes}"`);
+            expect(changes).eql(0);
+        });
+
+        test('Push the changes', async function () {
+            await driverHelper.waitVisibility(webCheCodeLocators.ScmView.actionConstructor(`Push 1 commits to origin/${TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_BRANCH}`));
+            await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
+            Logger.debug(`scmProvider.openMoreActions`);
+            scmContextMenu = await scmProvider.openMoreActions();
+            await driverHelper.waitVisibility(webCheCodeLocators.ContextMenu.itemConstructor(pushItemLabel));
+            Logger.debug(`scmContextMenu.select: "${pushItemLabel}"`);
+            await scmContextMenu.select(pushItemLabel);
+        });
+
+        test('Insert git credentials which were asked after push', async function () {
+            await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
+
+            try {
+                await driverHelper.waitVisibility(webCheCodeLocators.Input.inputBox);
+            } catch (e) {
+                Logger.info(`Workspace did not ask credentials before push - ${e};
+                Known issue for github.com - https://issues.redhat.com/browse/CRW-4066`);
+            }
+            const input: InputBox = new InputBox();
+            await input.setText(TestConstants.TS_SELENIUM_GIT_PROVIDER_USERNAME);
+            await input.confirm();
+            await driverHelper.wait(timeToRefresh);
+            await input.setText(TestConstants.TS_SELENIUM_GIT_PROVIDER_PASSWORD);
+            await input.confirm();
+            await driverHelper.wait(timeToRefresh);
+        });
+
+        test('Check if the changes were pushed', async function () {
+            try {
+                Logger.debug(`scmProvider.takeAction: "${refreshButtonLabel}"`);
+                await scmProvider.takeAction(refreshButtonLabel);
+            } catch (e) {
+                Logger.info('Check you use correct credentials.' +
+                    'For bitbucket.org ensure you use an app password: https://support.atlassian.com/bitbucket-cloud/docs/using-app-passwords/;' +
+                    'For github.com - personal access token instead of password.');
+            }
+            const isCommitButtonDisabled: string = await driverHelper.waitAndGetElementAttribute(webCheCodeLocators.ScmView.actionConstructor(commitChangesButtonLabel), 'aria-disabled');
+            expect(isCommitButtonDisabled).eql('true');
+        });
+    }
+
+    test(`Stop and remove the workspace`, async function () {
+        await workspaceHandlingTests.stopAndRemoveWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+    });
+
+    loginTests.logoutFromChe();
+
+    suiteTeardown('Close the browser', async function () {
+        if (!TestConstants.TS_DEBUG_MODE) {
+            await driverHelper.getDriver().close();
+        }
+    });
+});

package/specs/miscellaneous/PredefinedNamespace.spec.ts

@@ -0,0 +1,74 @@
+import { e2eContainer } from '../../configs/inversify.config';
+import { assert } from 'chai';
+import { registerRunningWorkspace } from '../MochaHooks';
+import { CLASSES } from '../../configs/inversify.types';
+import { WorkspaceHandlingTests } from '../../tests-library/WorkspaceHandlingTests';
+import { Logger } from '../../utils/Logger';
+import { LoginTests } from '../../tests-library/LoginTests';
+
+const loginTests: LoginTests = e2eContainer.get(CLASSES.LoginTests);
+const util: any = require('node:util');
+const exec: any = util.promisify(require('node:child_process').exec);
+const workspaceHandlingTests: WorkspaceHandlingTests = e2eContainer.get(CLASSES.WorkspaceHandlingTests);
+const predefinedNamespaceName: string = 'predefined-ns';
+
+async function runShellScript(shellCommandToExecution: string): Promise<string> {
+    const {stdout, stderr} = await exec(shellCommandToExecution);
+    console.log(stdout);
+    console.error(stderr);
+    return stdout;
+}
+
+suite(`Create predefined workspace and check it `, async function () {
+    let workspaceName: string = '';
+
+    const setEditRightsForUser: string = `oc adm policy add-role-to-user edit user -n ${predefinedNamespaceName}`;
+    const getDevWorkspaceFromPredefinedNameSpace: string = `oc get dw -n ${predefinedNamespaceName}`;
+    const deletePredefinedNamespace: string = `oc delete project ${predefinedNamespaceName}`;
+    const createPredefinedProjectCommand: string = 'cat <<EOF | oc apply -f - \n' +
+        'kind: Namespace\n' +
+        'apiVersion: v1\n' +
+        'metadata:\n' +
+        `  name: ${predefinedNamespaceName}\n` +
+        '  labels:\n' +
+        '    app.kubernetes.io/part-of: che.eclipse.org\n' +
+        '    app.kubernetes.io/component: workspaces-namespace\n' +
+        '  annotations:\n' +
+        '    che.eclipse.org/username: user\n' +
+        'EOF';
+    // create a predefined namespace for user using shell script and login into user dashboard
+    suiteSetup(async function () {
+        Logger.info('Test prerequisites:');
+        Logger.info(' (1) there is OCP user with username and user password that have been set in the TS_SELENIUM_USERNAME and TS_SELENIUM_PASSWORD variables');
+        Logger.info(' (2) \'oc\' client installed and logged into test OCP cluster with admin rights.');
+
+        await runShellScript(createPredefinedProjectCommand);
+        await runShellScript(setEditRightsForUser);
+    });
+
+    suiteTeardown(async () => {
+        const workspaceName: string = WorkspaceHandlingTests.getWorkspaceName();
+        try {
+            await runShellScript(deletePredefinedNamespace);
+        } catch (e) {
+            Logger.error(`Cannot remove the predefined project: ${workspaceName}, please fix it manually: ${e}`);
+        }
+    });
+
+    loginTests.loginIntoChe();
+    // create the Empty workspace using CHE Dashboard
+    workspaceHandlingTests.createAndOpenWorkspace('Empty Workspace');
+    workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
+
+    // verify that just created workspace with unique name is present in the predefined namespace
+    test('Validate the created workspace is present in predefined namespace', async function () {
+        workspaceName = WorkspaceHandlingTests.getWorkspaceName();
+        registerRunningWorkspace(workspaceName);
+        const ocDevWorkspaceOutput: string = await runShellScript(getDevWorkspaceFromPredefinedNameSpace);
+        await assert.isTrue(ocDevWorkspaceOutput.includes(workspaceName));
+    });
+
+    loginTests.logoutFromChe();
+});
+
+

package/tests-library/LoginTests.ts

@@ -14,12 +14,14 @@ import { TestConstants } from '../constants/TestConstants';
 import { BrowserTabsUtil } from '../utils/BrowserTabsUtil';
 import { Logger } from '../utils/Logger';
 import { inject, injectable } from 'inversify';
+import { Dashboard } from '../pageobjects/dashboard/Dashboard';
 
 @injectable()
 export class LoginTests {
     constructor(
         @inject(CLASSES.BrowserTabsUtil) private readonly browserTabsUtil: BrowserTabsUtil,
-        @inject(TYPES.CheLogin) private readonly loginPage: ICheLoginPage) {
+        @inject(TYPES.CheLogin) private readonly loginPage: ICheLoginPage,
+        @inject(CLASSES.Dashboard) private readonly dashboard: Dashboard) {
     }
 
     public loginIntoChe(): void {
@@ -32,4 +34,10 @@ export class LoginTests {
             }
         });
     }
+
+    public logoutFromChe(): void {
+        test('Logout', async () => {
+            await this.dashboard.logout();
+        });
+    }
 }

package/tests-library/WorkspaceHandlingTests.ts

@@ -29,10 +29,6 @@ export class WorkspaceHandlingTests {
         return WorkspaceHandlingTests.workspaceName;
     }
 
-    public static setWorkspaceName(workspaceName: string): void {
-        WorkspaceHandlingTests.workspaceName = workspaceName;
-    }
-
     private static WORKSPACE_NAME_LOCATOR: By = By.xpath(`//h1[contains(.,'Starting workspace ')]`);
     private static workspaceName: string = 'undefined';
     private static parentGUID: string;
@@ -61,7 +57,7 @@ export class WorkspaceHandlingTests {
             await this.dashboard.clickCreateWorkspaceButton();
             await this.createWorkspace.waitPage();
             WorkspaceHandlingTests.parentGUID = await this.browserTabsUtil.getCurrentWindowHandle();
-            await this.createWorkspace.clickOnSampleForSpecificEditor(stack);
+            await this.createWorkspace.clickOnSampleNoEditorSelection(stack);
             await this.browserTabsUtil.waitAndSwitchToAnotherWindow(WorkspaceHandlingTests.parentGUID, TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
         });
     }
@@ -110,8 +106,8 @@ export class WorkspaceHandlingTests {
                 Logger.info(`Obtained workspace name from workspace loader page: ${WorkspaceHandlingTests.workspaceName}`);
                 return;
             }
-            Logger.error(`WorkspaceHandlingTests.obtainWorkspaceNameFromSartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
-            throw new error.InvalidArgumentError(`WorkspaceHandlingTests.obtainWorkspaceNameFromSartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
+            Logger.error(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
+            throw new error.InvalidArgumentError(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
         });
     }
 

package/utils/BrowserTabsUtil.ts

@@ -9,7 +9,6 @@
  **********************************************************************/
 
 import { injectable, inject } from 'inversify';
-import { By, error } from 'selenium-webdriver';
 import { CLASSES } from '../configs/inversify.types';
 import { DriverHelper } from './DriverHelper';
 import { Logger } from './Logger';
@@ -60,18 +59,11 @@ export class BrowserTabsUtil {
 
         const windowHandles: string[] = await this.getAllWindowHandles();
 
-        windowHandles.forEach(async windowHandle => {
+        for (const windowHandle of windowHandles) {
             if (windowHandle !== currentWindowHandle) {
                 await this.switchToWindow(windowHandle);
-                return;
             }
-        });
-    }
-
-    async waitContentAvailableInTheNewTab(contentLocator: By, timeout: number) {
-        Logger.debug('BrowserTabsUtil.waitContentAvailableInTheNewTab');
-
-        await this.driverHelper.waitVisibility(contentLocator, timeout);
+        }
     }
 
     async refreshPage() {
@@ -80,20 +72,6 @@ export class BrowserTabsUtil {
         await (await this.driverHelper.getDriver()).navigate().refresh();
     }
 
-    async refreshForDebug() {
-        Logger.debug('BrowserTabsUtil.refreshForDebug');
-
-        // if refresh triggers debug breakpoint test stucks of the refreshing
-        // and fail with a timeout error.
-        try {
-            await (await this.driverHelper.getDriver()).navigate().refresh();
-        } catch (err) {
-            if (!(err instanceof error.TimeoutError)) {
-                throw err;
-            }
-        }
-    }
-
     async getCurrentUrl(): Promise<string> {
         return await this.driverHelper.getDriver().getCurrentUrl();
     }

package/utils/DriverHelper.ts

@@ -10,9 +10,8 @@
 import { IDriver } from '../driver/IDriver';
 import { inject, injectable } from 'inversify';
 import { TYPES } from '../configs/inversify.types';
-import { error, Actions } from 'selenium-webdriver';
+import { Actions, By, error, ThenableWebDriver, until, WebElement } from 'selenium-webdriver';
 import 'reflect-metadata';
-import { ThenableWebDriver, By, until, WebElement } from 'selenium-webdriver';
 import { TestConstants } from '../constants/TestConstants';
 import { Logger } from './Logger';
 import { TimeoutConstants } from '../constants/TimeoutConstants';
@@ -32,23 +31,12 @@ export class DriverHelper {
         return this.driver.actions();
     }
 
-    /**
-     * @deprecated Method deprecated. Use the next method instead.
-     * @see BrowserTabsUtil.maximize()
-     */
-    public async maximize() {
-        Logger.trace(`DriverHelper.maximize`);
-
-        await this.driver.manage().window().maximize();
-    }
-
     public async isVisible(locator: By): Promise<boolean> {
         Logger.trace(`DriverHelper.isVisible ${locator}`);
 
         try {
             const element: WebElement = await this.driver.findElement(locator);
-            const isVisible: boolean = await element.isDisplayed();
-            return isVisible;
+            return await element.isDisplayed();
         } catch {
             return false;
         }
@@ -164,8 +152,7 @@ export class DriverHelper {
 
         for (let i = 0; i < attempts; i++) {
             try {
-                const webElement: WebElement = await this.driver.wait(until.elementLocated(elementLocator), polling);
-                return webElement;
+                return await this.driver.wait(until.elementLocated(elementLocator), polling);
             } catch (err) {
                 if (err instanceof error.TimeoutError) {
                     Logger.trace(`DriverHelper.waitPresence - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
@@ -182,7 +169,7 @@ export class DriverHelper {
             }
         }
 
-        throw new error.TimeoutError(`Exceeded maximum presence checkings attempts, problems with 'StaleElementReferenceError' of '${elementLocator}' element`);
+        throw new error.TimeoutError(`Exceeded maximum presence checking attempts, problems with 'StaleElementReferenceError' of '${elementLocator}' element`);
     }
 
     public async waitAllPresence(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<Array<WebElement>> {
@@ -193,8 +180,7 @@ export class DriverHelper {
 
         for (let i = 0; i < attempts; i++) {
             try {
-                const webElements: Array<WebElement> = await this.driver.wait(until.elementsLocated(elementLocator), polling);
-                return webElements;
+                return await this.driver.wait(until.elementsLocated(elementLocator), polling);
             } catch (err) {
                 if (err instanceof error.TimeoutError) {
                     Logger.trace(`DriverHelper.waitAllPresence - Polling timed out attempt #${(i + 1)}, retrying with ${polling}ms timeout`);
@@ -299,7 +285,6 @@ export class DriverHelper {
         }
 
         throw new error.TimeoutError(`Exceeded maximum clicking attempts, the '${elementLocator}' element is not clickable`);
-
     }
 
     public async waitAndGetElementAttribute(elementLocator: By, attribute: string,
@@ -329,8 +314,7 @@ export class DriverHelper {
             }
 
             try {
-                const attributeValue = await element.getAttribute(attribute);
-                return attributeValue;
+                return await element.getAttribute(attribute);
             } catch (err) {
                 if (err instanceof error.StaleElementReferenceError) {
                     await this.wait(polling);
@@ -372,8 +356,7 @@ export class DriverHelper {
             }
 
             try {
-                const cssAttributeValue = await element.getCssValue(cssAttribute);
-                return cssAttributeValue;
+                return await element.getCssValue(cssAttribute);
             } catch (err) {
                 if (err instanceof error.StaleElementReferenceError) {
                     await this.wait(polling);
@@ -622,8 +605,7 @@ export class DriverHelper {
             }
 
             try {
-                const innerText: string = await element.getText();
-                return innerText;
+                return await element.getText();
             } catch (err) {
                 if (err instanceof error.StaleElementReferenceError) {
                     await this.wait(polling);
@@ -641,8 +623,7 @@ export class DriverHelper {
     public async waitAndGetValue(elementLocator: By, timeout: number): Promise<string> {
         Logger.trace(`DriverHelper.waitAndGetValue ${elementLocator}`);
 
-        const elementValue: string = await this.waitAndGetElementAttribute(elementLocator, 'value', timeout);
-        return elementValue;
+        return await this.waitAndGetElementAttribute(elementLocator, 'value', timeout);
     }
 
     public async waitUntilTrue(callback: any, timeout: number) {
@@ -651,54 +632,6 @@ export class DriverHelper {
         await this.driver.wait(callback, timeout);
     }
 
-    /**
-     * @deprecated Method deprecated. Use the next method instead.
-     * @see BrowserTabsUtil.refreshPage()
-     */
-    public async reloadPage() {
-        Logger.debug('DriverHelper.reloadPage');
-
-        await this.driver.navigate().refresh();
-    }
-
-    /**
-     * @deprecated Method deprecated. Use the next method instead.
-     * @see BrowserTabsUtil.navigateAndWaitToUrl()
-     */
-    public async navigateAndWaitToUrl(url: string, timeout: number = TimeoutConstants.TS_SELENIUM_WAIT_FOR_URL) {
-        Logger.trace(`DriverHelper.navigateAndWaitToUrl ${url}`);
-
-        await this.navigateToUrl(url);
-        await this.waitURL(url, timeout);
-    }
-
-    /**
-     * @deprecated Method deprecated. Use the next method instead.
-     * @see BrowserTabsUtil.navigateTo()
-     */
-    public async navigateToUrl(url: string) {
-        Logger.debug(`DriverHelper.navigateToUrl ${url}`);
-
-        await this.driver.navigate().to(url);
-    }
-
-    /**
-     * @deprecated Method deprecated. Use the next method instead.
-     * @see BrowserTabsUtil.waitURL()
-     */
-    public async waitURL(expectedUrl: string, timeout: number) {
-        Logger.trace(`DriverHelper.waitURL ${expectedUrl}`);
-
-        await this.getDriver().wait(async () => {
-            const currentUrl: string = await this.getDriver().getCurrentUrl();
-            const urlEquals: boolean = currentUrl === expectedUrl;
-
-            if (urlEquals) {
-                return true;
-            }
-        }, timeout);
-    }
-
     public async scrollTo(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
@@ -741,14 +674,6 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum mouse move attempts, for the '${elementLocator}' element`);
     }
 
-    /**
-     * @deprecated Method deprecated. Use the next method instead.
-     * @see BrowserTabsUtil.getCurrentUrl()
-     */
-    public async getCurrentUrl(): Promise<string> {
-        return await this.driver.getCurrentUrl();
-    }
-
     getDriver(): ThenableWebDriver {
         Logger.trace('DriverHelper.getDriver');
 

package/utils/Logger.ts

@@ -15,6 +15,7 @@ export abstract class Logger {
     /**
      * Uses for logging of fatal errors.
      * @param text log text
+     * @param indentLevel log level
      */
     public static error(text: string, indentLevel: number = 1) {
         this.logText(indentLevel, `[ERROR] ${text}`);
@@ -23,6 +24,7 @@ export abstract class Logger {
     /**
      * Uses for logging of recoverable errors and general warnings.
      * @param text log text
+     * @param indentLevel log level
      */
     public static warn(text: string, indentLevel: number = 1) {
         if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR') {
@@ -34,6 +36,7 @@ export abstract class Logger {
     /**
      * Uses for logging of the public methods of the pageobjects.
      * @param text log text
+     * @param indentLevel log level
      */
     public static info(text: string, indentLevel: number = 3) {
         if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
@@ -46,6 +49,7 @@ export abstract class Logger {
     /**
      * Uses for logging of the public methods of the pageobjects.
      * @param text log text
+     * @param indentLevel log level
      */
     public static debug(text: string, indentLevel: number = 5) {
         if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
@@ -60,6 +64,7 @@ export abstract class Logger {
      * Uses for logging of the public methods of the {@link DriverHelper} or
      * private methods inside of pageobjects.
      * @param text log text
+     * @param indentLevel log level
      */
     public static trace(text: string, indentLevel: number = 6) {
         if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||

package/utils/Sanitizer.ts

@@ -16,5 +16,4 @@ export class Sanitizer {
     public sanitize(arg: string): string {
         return arg.replace(/[\/]/g, '+').replace(/[\,]/g, '.').replace(/[\:]/g, '-').replace(/[\'\"]/g, '').replace(/[^a-z0-9\+\-\.\(\)\[\]\_]/gi, '_');
     }
-
 }