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

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,20 @@ 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);
+        });
+    }
+
+    public createAndOpenWorkspaceFromGitRepository(factoryUrl: string): void {
+        test(`Create and open new workspace from factory:${factoryUrl}`, async () => {
+            await this.dashboard.waitPage();
+            Logger.debug(`Fetching user kubernetes namespace, storing auth token by getting workspaces API URL.`);
+            await this.apiUrlResolver.getWorkspacesApiUrl();
+            await this.dashboard.clickCreateWorkspaceButton();
+            await this.createWorkspace.waitPage();
+            WorkspaceHandlingTests.parentGUID = await this.browserTabsUtil.getCurrentWindowHandle();
+            await this.createWorkspace.importFromGitUsingUI(factoryUrl);
             await this.browserTabsUtil.waitAndSwitchToAnotherWindow(WorkspaceHandlingTests.parentGUID, TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
         });
     }
@@ -110,8 +119,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/tslint.json

@@ -95,11 +95,11 @@
     ],
     "typedef": [
       true,
-      // "call-signature",
-      // "member-variable-declaration",
+      "call-signature",
+      "member-variable-declaration",
       "parameter",
-      "property-declaration"
-      // "variable-declaration"
+      "property-declaration",
+      "variable-declaration"
     ],
     "typedef-whitespace": [
       true,

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';
@@ -19,7 +18,7 @@ import { TimeoutConstants } from '../constants/TimeoutConstants';
 export class BrowserTabsUtil {
     constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
 
-    async switchToWindow(windowHandle: string) {
+    async switchToWindow(windowHandle: string): Promise<void> {
         Logger.debug('BrowserTabsUtil.switchToWindow');
         await this.driverHelper.getDriver().switchTo().window(windowHandle);
     }
@@ -36,20 +35,20 @@ export class BrowserTabsUtil {
         return await this.driverHelper.getDriver().getWindowHandle();
     }
 
-    async navigateTo(url: string) {
+    async navigateTo(url: string): Promise<void> {
         Logger.debug(`BrowserTabsUtil.navigateTo ${url}`);
 
         await this.driverHelper.getDriver().navigate().to(url);
     }
 
-    async navigateAndWaitToUrl(url: string, timeout: number = TimeoutConstants.TS_SELENIUM_WAIT_FOR_URL) {
+    async navigateAndWaitToUrl(url: string, timeout: number = TimeoutConstants.TS_SELENIUM_WAIT_FOR_URL): Promise<void> {
         Logger.trace(`BrowserTabsUtil.navigateAndWaitToUrl ${url}`);
 
         await this.navigateTo(url);
         await this.waitURL(url, timeout);
     }
 
-    async waitAndSwitchToAnotherWindow(currentWindowHandle: string, timeout: number) {
+    async waitAndSwitchToAnotherWindow(currentWindowHandle: string, timeout: number): Promise<void> {
         Logger.debug('BrowserTabsUtil.waitAndSwitchToAnotherWindow');
 
         await this.driverHelper.waitUntilTrue(async () => {
@@ -60,45 +59,24 @@ 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() {
+    async refreshPage(): Promise<void> {
         Logger.debug('BrowserTabsUtil.refreshPage');
 
         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();
     }
 
-    async waitURL(expectedUrl: string, timeout: number) {
+    async waitURL(expectedUrl: string, timeout: number): Promise<void> {
         Logger.trace(`BrowserTabsUtil.waitURL ${expectedUrl}`);
 
         await this.driverHelper.getDriver().wait(async () => {
@@ -111,7 +89,7 @@ export class BrowserTabsUtil {
         }, timeout);
     }
 
-    public async maximize() {
+    public async maximize(): Promise<void> {
         Logger.trace(`BrowserTabsUtil.maximize`);
 
         await this.driverHelper.getDriver().manage().window().maximize();

package/utils/CheReporter.ts

@@ -20,6 +20,7 @@ import { TimeoutConstants } from '../constants/TimeoutConstants';
 import { Logger } from './Logger';
 import { Sanitizer } from './Sanitizer';
 import { e2eContainer } from '../configs/inversify.config';
+import { WriteStream } from 'fs';
 
 const driverHelper: DriverHelper = e2eContainer.get(CLASSES.DriverHelper);
 const screenCatcher: ScreenCatcher = e2eContainer.get(CLASSES.ScreenCatcher);
@@ -35,7 +36,7 @@ class CheReporter extends mocha.reporters.Spec {
   constructor(runner: mocha.Runner, options: mocha.MochaOptions) {
     super(runner, options);
 
-    runner.on('start', async (test: mocha.Test) => {
+    runner.on('start', async () => {
       let launchInformation: string =
         `################## Launch Information ##################
 
@@ -56,6 +57,9 @@ class CheReporter extends mocha.reporters.Spec {
       DELETE_WORKSPACE_ON_FAILED_TEST: ${TestConstants.DELETE_WORKSPACE_ON_FAILED_TEST}
       TS_SELENIUM_LOG_LEVEL: ${TestConstants.TS_SELENIUM_LOG_LEVEL}
       TS_SELENIUM_LAUNCH_FULLSCREEN: ${TestConstants.TS_SELENIUM_LAUNCH_FULLSCREEN}
+
+      ${process.env.MOCHA_DIRECTORY ? 'MOCHA_DIRECTORY: ' + process.env.MOCHA_DIRECTORY : 'MOCHA_DRIRECTORY is not set'}
+      ${process.env.USERSTORY ? 'USERSTORY: ' + process.env.USERSTORY : 'USERSTORY is not set'}
 `;
 
       if (TestConstants.TS_SELENIUM_PRINT_TIMEOUT_VARIABLES) {
@@ -73,7 +77,7 @@ class CheReporter extends mocha.reporters.Spec {
       rm.sync(TestConstants.TS_SELENIUM_REPORT_FOLDER);
     });
 
-    runner.on('test', async function (test: mocha.Test) {
+    runner.on('test', async function (test: mocha.Test): Promise<void> {
       if (!TestConstants.TS_SELENIUM_EXECUTION_SCREENCAST) {
         return;
       }
@@ -94,7 +98,7 @@ class CheReporter extends mocha.reporters.Spec {
       if (TestConstants.TS_LOAD_TESTS) {
         const loadTestReportFolder: string = TestConstants.TS_SELENIUM_LOAD_TEST_REPORT_FOLDER;
         const loadTestFilePath: string = loadTestReportFolder + '/load-test-results.txt';
-        const report = test.title + ': ' + test.duration + '\r';
+        const report: string = test.title + ': ' + test.duration + '\r';
         if (!fs.existsSync(loadTestReportFolder)) {
           fs.mkdirSync(loadTestReportFolder);
         }
@@ -103,7 +107,7 @@ class CheReporter extends mocha.reporters.Spec {
     });
 
 
-    runner.on('end', async function (test: mocha.Test) {
+    runner.on('end', async function (): Promise<void> {
       // ensure that fired events done
       await driverHelper.wait(5000);
 
@@ -116,7 +120,7 @@ class CheReporter extends mocha.reporters.Spec {
       }
     });
 
-    runner.on('fail', async function (test: mocha.Test) {
+    runner.on('fail', async function (test: mocha.Test): Promise<void> {
       Logger.error(`CheReporter runner.on.fail: ${test.fullTitle()} failed after ${test.duration}ms`);
       // raise flag for keeping the screencast
       deleteScreencast = false;
@@ -150,13 +154,13 @@ class CheReporter extends mocha.reporters.Spec {
 
       // take screenshot and write to file
       const screenshot: string = await driverHelper.getDriver().takeScreenshot();
-      const screenshotStream = fs.createWriteStream(screenshotFileName);
+      const screenshotStream: WriteStream = fs.createWriteStream(screenshotFileName);
       screenshotStream.write(Buffer.from(screenshot, 'base64'));
       screenshotStream.end();
 
       // take pagesource and write to file
       const pageSource: string = await driverHelper.getDriver().getPageSource();
-      const pageSourceStream = fs.createWriteStream(pageSourceFileName);
+      const pageSourceStream: WriteStream = fs.createWriteStream(pageSourceFileName);
       pageSourceStream.write(Buffer.from(pageSource));
       pageSourceStream.end();
 
@@ -168,7 +172,7 @@ class CheReporter extends mocha.reporters.Spec {
         browserLogs += `\"${log.level}\" \"${log.type}\" \"${log.message}\"\n`;
       });
 
-      const browserLogsStream = fs.createWriteStream(browserLogsFileName);
+      const browserLogsStream: WriteStream = fs.createWriteStream(browserLogsFileName);
       browserLogsStream.write(Buffer.from(browserLogs));
       browserLogsStream.end();
 

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,29 +31,18 @@ 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;
         }
     }
 
-    public async wait(milliseconds: number) {
+    public async wait(milliseconds: number): Promise<void> {
         Logger.trace(`DriverHelper.wait (${milliseconds} milliseconds)`);
 
         await this.driver.sleep(milliseconds);
@@ -66,7 +54,7 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitVisibilityBoolean ${locator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             const isVisible: boolean = await this.isVisible(locator);
 
             if (isVisible) {
@@ -85,7 +73,7 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitDisappearanceBoolean ${locator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             const isVisible: boolean = await this.isVisible(locator);
 
             if (!isVisible) {
@@ -104,7 +92,7 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitVisibility ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.driver.wait(until.elementLocated(elementLocator), polling);
@@ -131,7 +119,7 @@ export class DriverHelper {
             }
 
             try {
-                const visibleWebElement = await this.driver.wait(until.elementIsVisible(element), polling);
+                const visibleWebElement: WebElement = await this.driver.wait(until.elementIsVisible(element), polling);
                 Logger.trace('DriverHelper.waitVisibility - Element is located and is visible.');
                 return visibleWebElement;
             } catch (err) {
@@ -162,10 +150,9 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitPresence ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 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>> {
@@ -191,10 +178,9 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitAllPresence ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 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`);
@@ -214,7 +200,7 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum presence checkings attempts, problems with 'StaleElementReferenceError' of '${elementLocator}' element`);
     }
 
-    public async waitAllVisibility(locators: Array<By>, timeout: number) {
+    public async waitAllVisibility(locators: Array<By>, timeout: number): Promise<void> {
         Logger.trace(`DriverHelper.waitAllVisibility ${locators}`);
 
         for (const elementLocator of locators) {
@@ -224,18 +210,18 @@ export class DriverHelper {
 
     public async waitDisappearance(elementLocator: By,
         attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING) {
+        polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
 
         Logger.trace(`DriverHelper.waitDisappearance ${elementLocator}`);
 
-        const isDisappeared = await this.waitDisappearanceBoolean(elementLocator, attempts, polling);
+        const isDisappeared: boolean = await this.waitDisappearanceBoolean(elementLocator, attempts, polling);
 
         if (!isDisappeared) {
             throw new error.TimeoutError(`Waiting attempts exceeded, element '${elementLocator}' is still visible`);
         }
     }
 
-    public async waitDisappearanceWithTimeout(elementLocator: By, timeout: number) {
+    public async waitDisappearanceWithTimeout(elementLocator: By, timeout: number): Promise<void> {
         Logger.trace(`DriverHelper.waitDisappearanceWithTimeout ${elementLocator}`);
 
         await this.getDriver().wait(async () => {
@@ -249,7 +235,7 @@ export class DriverHelper {
 
     public async waitAllDisappearance(locators: Array<By>,
         attemptsPerLocator: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        pollingPerLocator: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING) {
+        pollingPerLocator: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
 
         Logger.trace(`DriverHelper.waitAllDisappearance ${locators}`);
 
@@ -258,13 +244,13 @@ export class DriverHelper {
         }
     }
 
-    public async waitAndClick(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+    public async waitAndClick(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitAndClick ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.waitVisibility(elementLocator, polling);
@@ -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,
@@ -309,7 +294,7 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitAndGetElementAttribute ${elementLocator} attribute: '${attribute}'`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.waitVisibility(elementLocator, polling);
@@ -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);
@@ -352,7 +336,7 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitAndGetCssValue ${elementLocator} cssAttribute: ${cssAttribute}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.waitVisibility(elementLocator, 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);
@@ -391,7 +374,7 @@ export class DriverHelper {
     public async waitAttributeValue(elementLocator: By,
         attribute: string,
         expectedValue: string,
-        timeout: number) {
+        timeout: number): Promise<void> {
 
         Logger.trace(`DriverHelper.waitAttributeValue ${elementLocator}`);
 
@@ -404,7 +387,7 @@ export class DriverHelper {
             `The '${attribute}' attribute value doesn't match with expected value '${expectedValue}'`);
     }
 
-    public async type(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+    public async type(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -414,7 +397,7 @@ export class DriverHelper {
             Logger.trace(`DriverHelper.type ${elementLocator} text: ${text}`);
         }
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.waitVisibility(elementLocator, polling);
@@ -450,13 +433,13 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum typing attempts, to the '${elementLocator}' element`);
     }
 
-    public async typeToInvisible(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+    public async typeToInvisible(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.typeToInvisible ${elementLocator} text: ${text}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.waitPresence(elementLocator, polling);
@@ -492,13 +475,13 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum typing attempts, to the '${elementLocator}' element`);
     }
 
-    public async clear(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+    public async clear(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.clear ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.waitVisibility(elementLocator, polling);
@@ -534,13 +517,13 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum clearing attempts, to the '${elementLocator}' element`);
     }
 
-    public async clearInvisible(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+    public async clearInvisible(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.clearInvisible ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.waitPresence(elementLocator, polling);
@@ -576,7 +559,7 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum clearing attempts, to the '${elementLocator}' element`);
     }
 
-    public async enterValue(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM) {
+    public async enterValue(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         if (elementLocator.toString().toLocaleLowerCase().includes('password')) {
             Logger.trace(`DriverHelper.enterValue ${elementLocator} text: ***`);
         } else {
@@ -590,7 +573,7 @@ export class DriverHelper {
         await this.waitAttributeValue(elementLocator, 'value', text, timeout);
     }
 
-    public async waitAndSwitchToFrame(iframeLocator: By, timeout: number) {
+    public async waitAndSwitchToFrame(iframeLocator: By, timeout: number): Promise<void> {
         Logger.trace(`DriverHelper.waitAndSwitchToFrame ${iframeLocator}`);
 
         await this.driver.wait(until.ableToSwitchToFrame(iframeLocator), timeout);
@@ -602,7 +585,7 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitAndGetText ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.waitVisibility(elementLocator, 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,71 +623,22 @@ 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) {
+    public async waitUntilTrue(callback: any, timeout: number): Promise<void> {
         Logger.trace('DriverHelper.waitUntilTrue');
 
         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) {
+    public async scrollTo(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.scrollTo ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             let element: WebElement;
             try {
                 element = await this.waitPresence(elementLocator, 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');