@eclipse-che/che-e2e 7.64.0-dev-db63138 → 7.64.0-dev-f0466d9

package/specs/factory/RefusedOAuthFactory.spec.ts

@@ -49,7 +49,7 @@ const webCheCodeLocators: Locators = new CheCodeLocatorLoader().webCheCodeLocato
 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 () {
+suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SELENIUM_FACTORY_GIT_PROVIDER} repository and deny the access`, async function (): Promise<void> {
     const oauthPage: OauthPage = new OauthPage(driverHelper);
 
     let projectSection: ViewSection;
@@ -71,12 +71,12 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
 
     loginTests.loginIntoChe();
 
-    test(`Navigate to the ${isPrivateRepo} repository factory URL`, async function () {
+    test(`Navigate to the ${isPrivateRepo} repository factory URL`, async function (): Promise<void> {
         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 () {
+        test(`Authorize with a ${TestConstants.TS_SELENIUM_FACTORY_GIT_PROVIDER} OAuth and deny access`, async function (): Promise<void> {
             await oauthPage.login();
             await oauthPage.waitOauthPage();
             await oauthPage.denyAccess();
@@ -85,24 +85,24 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
 
     workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
 
-    test('The workspace starts with access deny flag in the url', async function () {
+    test('The workspace starts with access deny flag in the url', async function (): Promise<void> {
         expect(await driverHelper.getDriver().getCurrentUrl()).contains('&error_code=access_denied');
     });
 
-    test('Registering the running workspace', async function () {
+    test('Registering the running workspace', async function (): Promise<void> {
         registerRunningWorkspace(WorkspaceHandlingTests.getWorkspaceName());
     });
 
-    test('Wait the workspace readiness', async function () {
+    test('Wait the workspace readiness', async function (): Promise<void> {
         await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
     });
 
-    test('Check if a project folder has been created', async function () {
+    test('Check if a project folder has been created', async function (): Promise<void> {
         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 () {
+    test('Accept the project as a trusted one', async function (): Promise<void> {
         // click somewhere to trigger "Welcome Content" dialog
         try {
             await driverHelper.waitAndClick(webCheCodeLocators.Workbench.notificationItem);
@@ -126,27 +126,27 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
     });
 
     if (TestConstants.TS_SELENIUM_IS_PRIVATE_FACTORY_GIT_REPO) {
-        test('Check that project can not be cloned', async function () {
+        test('Check that project can not be cloned', async function (): Promise<void> {
             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 () {
+        test('Check that project files were not imported', async function (): Promise<void> {
             const isFileImported: ViewItem | undefined = await projectSection.findItem(label);
             expect(isFileImported).eqls(undefined);
         });
 
     } else {
-        test('Check if the project files were imported', async function () {
+        test('Check if the project files were imported', async function (): Promise<void> {
             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 () {
+        test('Make changes to the file', async function (): Promise<void> {
             Logger.debug(`projectSection.openItem: "${fileToChange}"`);
             await projectSection.openItem(fileToChange);
             const editor: TextEditor = await new EditorView().openEditor(fileToChange) as TextEditor;
@@ -157,7 +157,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
             await editor.typeTextAt(1, 1, changesToCommit);
         });
 
-        test('Open a source control manager', async function () {
+        test('Open a source control manager', async function (): Promise<void> {
             const viewSourceControl: string = `Source Control`;
             const sourceControl: ViewControl = await new ActivityBar().getViewControl(viewSourceControl) as ViewControl;
             Logger.debug(`sourceControl.openView: "${viewSourceControl}"`);
@@ -168,7 +168,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
             Logger.debug(`scmView.getProviders: "${scmProvider}, ${scmProvider}"`);
         });
 
-        test('Check if the changes is displayed in the source control manager', async function () {
+        test('Check if the changes is displayed in the source control manager', async function (): Promise<void> {
             await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
             await driverHelper.wait(timeToRefresh);
             Logger.debug(`scmProvider.takeAction: "${refreshButtonLabel}"`);
@@ -180,7 +180,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
             expect(changes).eql(1);
         });
 
-        test('Stage the changes', async function () {
+        test('Stage the changes', async function (): Promise<void> {
             await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
             Logger.debug(`scmProvider.openMoreActions`);
             scmContextMenu = await scmProvider.openMoreActions();
@@ -189,7 +189,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
             await scmContextMenu.select('Changes', 'Stage All Changes');
         });
 
-        test('Commit the changes', async function () {
+        test('Commit the changes', async function (): Promise<void> {
             await driverHelper.waitVisibility(webCheCodeLocators.ScmView.actionConstructor(commitChangesButtonLabel));
             Logger.debug(`scmProvider.commitChanges: commit name "Commit ${changesToCommit}"`);
             await scmProvider.commitChanges('Commit ' + changesToCommit);
@@ -204,7 +204,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
             expect(changes).eql(0);
         });
 
-        test('Push the changes', async function () {
+        test('Push the changes', async function (): Promise<void> {
             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`);
@@ -214,7 +214,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
             await scmContextMenu.select(pushItemLabel);
         });
 
-        test('Insert git credentials which were asked after push', async function () {
+        test('Insert git credentials which were asked after push', async function (): Promise<void> {
             await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
 
             try {
@@ -232,7 +232,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
             await driverHelper.wait(timeToRefresh);
         });
 
-        test('Check if the changes were pushed', async function () {
+        test('Check if the changes were pushed', async function (): Promise<void> {
             try {
                 Logger.debug(`scmProvider.takeAction: "${refreshButtonLabel}"`);
                 await scmProvider.takeAction(refreshButtonLabel);
@@ -246,13 +246,13 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
         });
     }
 
-    test(`Stop and remove the workspace`, async function () {
+    test(`Stop and remove the workspace`, async function (): Promise<void> {
         await workspaceHandlingTests.stopAndRemoveWorkspace(WorkspaceHandlingTests.getWorkspaceName());
     });
 
     loginTests.logoutFromChe();
 
-    suiteTeardown('Close the browser', async function () {
+    suiteTeardown('Close the browser', async function (): Promise<void> {
         if (!TestConstants.TS_DEBUG_MODE) {
             await driverHelper.getDriver().close();
         }

package/specs/miscellaneous/PredefinedNamespace.spec.ts

@@ -1,10 +1,10 @@
 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';
+import { registerRunningWorkspace } from '../MochaHooks';
 
 const loginTests: LoginTests = e2eContainer.get(CLASSES.LoginTests);
 const util: any = require('node:util');
@@ -19,7 +19,7 @@ async function runShellScript(shellCommandToExecution: string): Promise<string>
     return stdout;
 }
 
-suite(`Create predefined workspace and check it `, async function () {
+suite(`Create predefined workspace and check it `, async function (): Promise<void> {
     let workspaceName: string = '';
 
     const setEditRightsForUser: string = `oc adm policy add-role-to-user edit user -n ${predefinedNamespaceName}`;
@@ -37,7 +37,7 @@ suite(`Create predefined workspace and check it `, async function () {
         '    che.eclipse.org/username: user\n' +
         'EOF';
     // create a predefined namespace for user using shell script and login into user dashboard
-    suiteSetup(async function () {
+    suiteSetup(async function (): Promise<void> {
         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.');
@@ -46,7 +46,7 @@ suite(`Create predefined workspace and check it `, async function () {
         await runShellScript(setEditRightsForUser);
     });
 
-    suiteTeardown(async () => {
+    suiteTeardown(async (): Promise<void> => {
         const workspaceName: string = WorkspaceHandlingTests.getWorkspaceName();
         try {
             await runShellScript(deletePredefinedNamespace);
@@ -61,7 +61,7 @@ suite(`Create predefined workspace and check it `, async function () {
     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 () {
+    test('Validate the created workspace is present in predefined namespace', async function (): Promise<void> {
         workspaceName = WorkspaceHandlingTests.getWorkspaceName();
         registerRunningWorkspace(workspaceName);
         const ocDevWorkspaceOutput: string = await runShellScript(getDevWorkspaceFromPredefinedNameSpace);

package/tests-library/WorkspaceHandlingTests.ts

@@ -62,6 +62,19 @@ export class WorkspaceHandlingTests {
         });
     }
 
+    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);
+        });
+    }
+
     public openExistingWorkspace(workspaceName: string): void {
         test('Open and start existing workspace', async () => {
             await this.dashboard.waitPage();

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

@@ -18,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);
     }
@@ -35,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 () => {
@@ -66,7 +66,7 @@ export class BrowserTabsUtil {
         }
     }
 
-    async refreshPage() {
+    async refreshPage(): Promise<void> {
         Logger.debug('BrowserTabsUtil.refreshPage');
 
         await (await this.driverHelper.getDriver()).navigate().refresh();
@@ -76,7 +76,7 @@ export class BrowserTabsUtil {
         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 () => {
@@ -89,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

@@ -42,7 +42,7 @@ export class DriverHelper {
         }
     }
 
-    public async wait(milliseconds: number) {
+    public async wait(milliseconds: number): Promise<void> {
         Logger.trace(`DriverHelper.wait (${milliseconds} milliseconds)`);
 
         await this.driver.sleep(milliseconds);
@@ -54,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) {
@@ -73,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) {
@@ -92,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);
@@ -119,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) {
@@ -150,7 +150,7 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitPresence ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             try {
                 return await this.driver.wait(until.elementLocated(elementLocator), polling);
             } catch (err) {
@@ -178,7 +178,7 @@ export class DriverHelper {
 
         Logger.trace(`DriverHelper.waitAllPresence ${elementLocator}`);
 
-        for (let i = 0; i < attempts; i++) {
+        for (let i: number = 0; i < attempts; i++) {
             try {
                 return await this.driver.wait(until.elementsLocated(elementLocator), polling);
             } catch (err) {
@@ -200,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) {
@@ -210,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 () => {
@@ -235,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}`);
 
@@ -244,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);
@@ -294,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);
@@ -336,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);
@@ -374,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}`);
 
@@ -387,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);
 
@@ -397,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);
@@ -433,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);
@@ -475,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);
@@ -517,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);
@@ -559,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 {
@@ -573,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);
@@ -585,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);
@@ -626,19 +626,19 @@ export class DriverHelper {
         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);
     }
 
-    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);