@eclipse-che/che-e2e 7.73.0 → 7.74.0-dev-41d1364

package/tests-library/LoginTests.ts

@@ -1,5 +1,5 @@
-/*********************************************************************
- * Copyright (c) 2019-2023 Red Hat, Inc.
+/** *******************************************************************
+ * copyright (c) 2019-2023 Red Hat, Inc.
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
@@ -14,40 +14,42 @@ import { BrowserTabsUtil } from '../utils/BrowserTabsUtil';
 import { inject, injectable } from 'inversify';
 import { Dashboard } from '../pageobjects/dashboard/Dashboard';
 import { IOcpLoginPage } from '../pageobjects/login/interfaces/IOcpLoginPage';
-import { BaseTestConstants } from '../constants/BaseTestConstants';
+import { BASE_TEST_CONSTANTS } from '../constants/BASE_TEST_CONSTANTS';
 
 @injectable()
 export class LoginTests {
-    constructor(
-        @inject(CLASSES.BrowserTabsUtil) private readonly browserTabsUtil: BrowserTabsUtil,
-        @inject(TYPES.CheLogin) private readonly productLoginPage: ICheLoginPage,
-        @inject(TYPES.OcpLogin) private readonly ocpLoginPage: IOcpLoginPage,
-        @inject(CLASSES.Dashboard) private readonly dashboard: Dashboard) {
-    }
+	constructor(
+		@inject(CLASSES.BrowserTabsUtil)
+		private readonly browserTabsUtil: BrowserTabsUtil,
+		@inject(TYPES.CheLogin)
+		private readonly productLoginPage: ICheLoginPage,
+		@inject(TYPES.OcpLogin) private readonly ocpLoginPage: IOcpLoginPage,
+		@inject(CLASSES.Dashboard) private readonly dashboard: Dashboard
+	) {}
 
-    loginIntoChe(): void {
-        test('Login', async () => {
-            if (!(await this.browserTabsUtil.getCurrentUrl()).includes(BaseTestConstants.TS_SELENIUM_BASE_URL)) {
-                await this.browserTabsUtil.navigateTo(BaseTestConstants.TS_SELENIUM_BASE_URL);
-            }
-            await this.productLoginPage.login();
-            await this.browserTabsUtil.maximize();
-            await this.dashboard.waitStartingPageLoaderDisappearance();
-        });
-    }
+	loginIntoChe(): void {
+		test('Login', async (): Promise<void> => {
+			if (!(await this.browserTabsUtil.getCurrentUrl()).includes(BASE_TEST_CONSTANTS.TS_SELENIUM_BASE_URL)) {
+				await this.browserTabsUtil.navigateTo(BASE_TEST_CONSTANTS.TS_SELENIUM_BASE_URL);
+			}
+			await this.productLoginPage.login();
+			await this.browserTabsUtil.maximize();
+			await this.dashboard.waitStartingPageLoaderDisappearance();
+		});
+	}
 
-    loginIntoOcpConsole(): void {
-        test('Login into ocp console', async () => {
-            const openshiftConsoleUrl: string = BaseTestConstants.TS_SELENIUM_BASE_URL.replace('devspaces', 'console-openshift-console');
-            await this.browserTabsUtil.navigateTo(openshiftConsoleUrl);
-            await this.ocpLoginPage.login();
-            await this.browserTabsUtil.maximize();
-        });
-    }
+	loginIntoOcpConsole(): void {
+		test('Login into ocp console', async (): Promise<void> => {
+			const openshiftConsoleUrl: string = BASE_TEST_CONSTANTS.TS_SELENIUM_BASE_URL.replace('devspaces', 'console-openshift-console');
+			await this.browserTabsUtil.navigateTo(openshiftConsoleUrl);
+			this.ocpLoginPage.login();
+			await this.browserTabsUtil.maximize();
+		});
+	}
 
-    logoutFromChe(): void {
-        test('Logout', async () => {
-            await this.dashboard.logout();
-        });
-    }
+	logoutFromChe(): void {
+		test('Logout', async (): Promise<void> => {
+			await this.dashboard.logout();
+		});
+	}
 }

package/tests-library/ProjectAndFileTests.ts

@@ -1,5 +1,5 @@
-/*********************************************************************
- * Copyright (c) 2019-2023 Red Hat, Inc.
+/** *******************************************************************
+ * copyright (c) 2019-2023 Red Hat, Inc.
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
@@ -14,24 +14,27 @@ import { By, until } from 'selenium-webdriver';
 import { DriverHelper } from '../utils/DriverHelper';
 import { CLASSES } from '../configs/inversify.types';
 import { Logger } from '../utils/Logger';
-import { TimeoutConstants } from '../constants/TimeoutConstants';
+import { TIMEOUT_CONSTANTS } from '../constants/TIMEOUT_CONSTANTS';
 
 @injectable()
 export class ProjectAndFileTests {
+	constructor(
+		@inject(CLASSES.DriverHelper)
+		private readonly driverHelper: DriverHelper
+	) {}
 
-    constructor(
-        @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) {}
-
-    async waitWorkspaceReadinessForCheCodeEditor(): Promise<void> {
-        Logger.debug(`${this.constructor.name}.${this.waitWorkspaceReadinessForCheCodeEditor.name} - Waiting for editor.`);
-        try {
-            const start: number = new Date().getTime();
-            await this.driverHelper.getDriver().wait(until.elementLocated(By.className('monaco-workbench')), TimeoutConstants.TS_SELENIUM_START_WORKSPACE_TIMEOUT);
-            const end: number = new Date().getTime();
-            Logger.debug(`${this.constructor.name}.${this.waitWorkspaceReadinessForCheCodeEditor.name} - editor was opened in ${end - start} seconds.`);
-        } catch (err) {
-            Logger.error(`ProjectAndFileTestsCheCode.waitWorkspaceReadinessForCheCodeEditor - waiting for workspace readiness failed: ${err}`);
-            throw err;
-        }
-    }
+	async waitWorkspaceReadinessForCheCodeEditor(): Promise<void> {
+		Logger.debug('waiting for editor.');
+		try {
+			const start: number = new Date().getTime();
+			await this.driverHelper
+				.getDriver()
+				.wait(until.elementLocated(By.className('monaco-workbench')), TIMEOUT_CONSTANTS.TS_SELENIUM_START_WORKSPACE_TIMEOUT);
+			const end: number = new Date().getTime();
+			Logger.debug(`editor was opened in ${end - start} seconds.`);
+		} catch (err) {
+			Logger.error(`waiting for workspace readiness failed: ${err}`);
+			throw err;
+		}
+	}
 }

package/tests-library/WorkspaceHandlingTests.ts

@@ -1,5 +1,5 @@
-/*********************************************************************
- * Copyright (c) 2019-2023 Red Hat, Inc.
+/** *******************************************************************
+ * copyright (c) 2019-2023 Red Hat, Inc.
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
@@ -13,129 +13,119 @@ import { inject, injectable } from 'inversify';
 import { CLASSES } from '../configs/inversify.types';
 import { Dashboard } from '../pageobjects/dashboard/Dashboard';
 import { CreateWorkspace } from '../pageobjects/dashboard/CreateWorkspace';
-import { Workspaces } from '../pageobjects/dashboard/Workspaces';
 import { BrowserTabsUtil } from '../utils/BrowserTabsUtil';
 import { Logger } from '../utils/Logger';
 import { ApiUrlResolver } from '../utils/workspace/ApiUrlResolver';
-import { TimeoutConstants } from '../constants/TimeoutConstants';
+import { TIMEOUT_CONSTANTS } from '../constants/TIMEOUT_CONSTANTS';
 import { DriverHelper } from '../utils/DriverHelper';
 import { By, error } from 'selenium-webdriver';
 
 @injectable()
 export class WorkspaceHandlingTests {
+	private static WORKSPACE_NAME_LOCATOR: By = By.xpath('//h1[contains(.,"Starting workspace ")]');
+	private static workspaceName: string = 'undefined';
+	private static parentGUID: string;
 
-    static getWorkspaceName(): string {
-        return WorkspaceHandlingTests.workspaceName;
-    }
+	constructor(
+		@inject(CLASSES.Dashboard) private readonly dashboard: Dashboard,
+		@inject(CLASSES.CreateWorkspace)
+		private readonly createWorkspace: CreateWorkspace,
+		@inject(CLASSES.BrowserTabsUtil)
+		private readonly browserTabsUtil: BrowserTabsUtil,
+		@inject(CLASSES.ApiUrlResolver)
+		private readonly apiUrlResolver: ApiUrlResolver,
+		@inject(CLASSES.DriverHelper)
+		private readonly driverHelper: DriverHelper
+	) {}
 
-    private static WORKSPACE_NAME_LOCATOR: By = By.xpath(`//h1[contains(.,'Starting workspace ')]`);
-    private static workspaceName: string = 'undefined';
-    private static parentGUID: string;
+	static getWorkspaceName(): string {
+		return WorkspaceHandlingTests.workspaceName;
+	}
 
-    constructor(
-        @inject(CLASSES.Dashboard) private readonly dashboard: Dashboard,
-        @inject(CLASSES.CreateWorkspace) private readonly createWorkspace: CreateWorkspace,
-        @inject(CLASSES.Workspaces) private readonly workspaces: Workspaces,
-        @inject(CLASSES.BrowserTabsUtil) private readonly browserTabsUtil: BrowserTabsUtil,
-        @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver,
-        @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) {}
+	setWindowHandle(guid: string): void {
+		WorkspaceHandlingTests.parentGUID = guid;
+	}
 
-    setWindowHandle(guid: string): void {
-        WorkspaceHandlingTests.parentGUID = guid;
-    }
+	getWindowHandle(): string {
+		return WorkspaceHandlingTests.parentGUID;
+	}
 
-    getWindowHandle(): string {
-        return WorkspaceHandlingTests.parentGUID;
-    }
+	async createAndOpenWorkspace(stack: string): Promise<void> {
+		await this.dashboard.clickWorkspacesButton();
+		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.clickOnSampleNoEditorSelection(stack);
+		await this.browserTabsUtil.waitAndSwitchToAnotherWindow(WorkspaceHandlingTests.parentGUID, TIMEOUT_CONSTANTS.TS_IDE_LOAD_TIMEOUT);
+	}
 
-    createAndOpenWorkspace(stack: string): void {
-        test(`Create and open new workspace, stack:${stack}`, async () => {
-            await this.dashboard.clickWorkspacesButton();
-            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.clickOnSampleNoEditorSelection(stack);
-            await this.browserTabsUtil.waitAndSwitchToAnotherWindow(WorkspaceHandlingTests.parentGUID, TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
-        });
-    }
+	async createAndOpenWorkspaceFromGitRepository(factoryUrl: string): Promise<void> {
+		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, TIMEOUT_CONSTANTS.TS_IDE_LOAD_TIMEOUT);
+	}
 
-    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);
-        });
-    }
+	async obtainWorkspaceNameFromStartingPage(): Promise<void> {
+		const timeout: number = TIMEOUT_CONSTANTS.TS_IDE_LOAD_TIMEOUT;
+		const polling: number = TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING;
+		const attempts: number = Math.ceil(timeout / polling);
 
-    openExistingWorkspace(workspaceName: string): void {
-        test('Open and start existing workspace', 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.clickWorkspacesButton();
-            await this.workspaces.waitPage();
-            await this.workspaces.clickOpenButton(workspaceName);
-        });
-    }
+		for (let i: number = 0; i < attempts; i++) {
+			try {
+				const startingWorkspaceLineContent: string = await this.driverHelper
+					.getDriver()
+					.findElement(WorkspaceHandlingTests.WORKSPACE_NAME_LOCATOR)
+					.getText();
+				Logger.trace(`obtained starting workspace getText():${startingWorkspaceLineContent}`);
+				// cutting away leading text
+				WorkspaceHandlingTests.workspaceName = startingWorkspaceLineContent.substring('Starting workspace '.length).trim();
+				Logger.trace(`trimmed workspace name from getText():${WorkspaceHandlingTests.workspaceName}`);
+				break;
+			} catch (err) {
+				if (err instanceof error.StaleElementReferenceError) {
+					Logger.trace('failed to obtain name from workspace start page, element possibly detached from DOM. Retrying.');
+					await this.driverHelper.wait(polling);
+					continue;
+				}
+				if (err instanceof error.NoSuchElementError) {
+					Logger.trace('failed to obtain name from workspace start page, element not visible yet. Retrying.');
+					await this.driverHelper.wait(polling);
+					continue;
+				}
+				Logger.error(`obtaining workspace name failed with an unexpected error:${err}`);
+				throw err;
+			}
+		}
+		if (WorkspaceHandlingTests.workspaceName !== '' && WorkspaceHandlingTests.workspaceName !== 'undefined') {
+			Logger.info(`obtained workspace name from workspace loader page: ${WorkspaceHandlingTests.workspaceName}`);
+			return;
+		}
+		Logger.error(`failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
+		throw new error.InvalidArgumentError(
+			`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`
+		);
+	}
 
-    obtainWorkspaceNameFromStartingPage(): void {
-        test('Obtain workspace name from workspace loader page', async() => {
-            const timeout: number = TimeoutConstants.TS_IDE_LOAD_TIMEOUT;
-            const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
-            const attempts: number = Math.ceil(timeout / polling);
+	async stopWorkspace(workspaceName: string): Promise<void> {
+		await this.dashboard.openDashboard();
+		await this.dashboard.stopWorkspaceByUI(workspaceName);
+	}
 
-            for (let i: number = 0; i < attempts; i++) {
-                try {
-                    let startingWorkspaceLineContent: string = await this.driverHelper.getDriver().findElement(WorkspaceHandlingTests.WORKSPACE_NAME_LOCATOR).getText();
-                    Logger.trace(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage obtained starting workspace getText():${startingWorkspaceLineContent}`);
-                    // cutting away leading text
-                    WorkspaceHandlingTests.workspaceName = startingWorkspaceLineContent.substring('Starting workspace '.length).trim();
-                    Logger.trace(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage trimmed workspace name from getText():${WorkspaceHandlingTests.workspaceName}`);
-                    break;
-                } catch (err) {
-                    if (err instanceof error.StaleElementReferenceError) {
-                        Logger.trace(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage Failed to obtain name from workspace start page, element possibly detached from DOM. Retrying.`);
-                        await this.driverHelper.wait(polling);
-                        continue;
-                    }
-                    if (err instanceof error.NoSuchElementError) {
-                        Logger.trace(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage Failed to obtain name from workspace start page, element not visible yet. Retrying.`);
-                        await this.driverHelper.wait(polling);
-                        continue;
-                    }
-                    Logger.error(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage Obtaining workspace name failed with an unexpected error:${err}`);
-                    throw err;
-                }
-            }
-            if (WorkspaceHandlingTests.workspaceName !== '' && WorkspaceHandlingTests.workspaceName !== 'undefined') {
-                Logger.info(`Obtained workspace name from workspace loader page: ${WorkspaceHandlingTests.workspaceName}`);
-                return;
-            }
-            Logger.error(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
-            throw new error.InvalidArgumentError(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
-        });
-    }
+	async removeWorkspace(workspaceName: string): Promise<void> {
+		await this.dashboard.openDashboard();
+		await this.dashboard.deleteStoppedWorkspaceByUI(workspaceName);
+	}
 
-    async stopWorkspace(workspaceName: string): Promise<void> {
-        await this.dashboard.openDashboard();
-        await this.dashboard.stopWorkspaceByUI(workspaceName);
-    }
-
-    async removeWorkspace(workspaceName: string): Promise<void> {
-        await this.dashboard.openDashboard();
-        await this.dashboard.deleteStoppedWorkspaceByUI(workspaceName);
-    }
-
-    async stopAndRemoveWorkspace(workspaceName: string): Promise<void> {
-        await this.dashboard.openDashboard();
-        await this.dashboard.stopAndRemoveWorkspaceByUI(workspaceName);
-    }
+	async stopAndRemoveWorkspace(workspaceName: string): Promise<void> {
+		await this.dashboard.openDashboard();
+		await this.dashboard.stopAndRemoveWorkspaceByUI(workspaceName);
+	}
 }

package/tsconfig.json

@@ -1,17 +1,17 @@
 {
-  "compilerOptions": {
-    "skipLibCheck": true,
-    "target": "es2017",
-    "module": "commonjs",
-    "strict": true,
-    "esModuleInterop": true,
-
-    "outDir": "dist",
-    "lib": ["es2017", "dom"],
-    "types": ["reflect-metadata", "@types/mocha", "@types/node"],
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "noImplicitReturns": false,
-    "sourceMap": true
-  }
+	"compilerOptions": {
+		"skipLibCheck": true,
+		"target": "es2017",
+		"module": "commonjs",
+		"strict": true,
+		"esModuleInterop": true,
+		"outDir": "dist",
+		"lib": ["es2017", "dom"],
+		"types": ["reflect-metadata", "@types/mocha", "@types/node"],
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true,
+		"noImplicitReturns": false,
+		"sourceMap": true
+	},
+	"include": [".eslintrc.js", "**/*.ts", "**/**/*.ts"]
 }

package/utils/BrowserTabsUtil.ts

@@ -1,5 +1,5 @@
-/*********************************************************************
- * Copyright (c) 2019-2023 Red Hat, Inc.
+/** *******************************************************************
+ * copyright (c) 2019-2023 Red Hat, Inc.
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
@@ -8,106 +8,112 @@
  * SPDX-License-Identifier: EPL-2.0
  **********************************************************************/
 
-import { injectable, inject } from 'inversify';
+import { inject, injectable } from 'inversify';
 import { CLASSES } from '../configs/inversify.types';
 import { DriverHelper } from './DriverHelper';
 import { Logger } from './Logger';
-import { TimeoutConstants } from '../constants/TimeoutConstants';
-import { ChromeDriverConstants } from '../constants/ChromeDriverConstants';
+import { TIMEOUT_CONSTANTS } from '../constants/TIMEOUT_CONSTANTS';
+import { CHROME_DRIVER_CONSTANTS } from '../constants/CHROME_DRIVER_CONSTANTS';
 
 @injectable()
 export class BrowserTabsUtil {
-    constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
-
-    async switchToWindow(windowHandle: string): Promise<void> {
-        Logger.debug('BrowserTabsUtil.switchToWindow');
-        await this.driverHelper.getDriver().switchTo().window(windowHandle);
-    }
-
-    async getAllWindowHandles(): Promise<string[]> {
-        Logger.debug('BrowserTabsUtil.getAllWindowHandles');
-
-        return (await this.driverHelper.getDriver()).getAllWindowHandles();
-    }
-
-    async getCurrentWindowHandle(): Promise<string> {
-        Logger.debug('BrowserTabsUtil.getCurrentWindowHandle');
-
-        return await this.driverHelper.getDriver().getWindowHandle();
-    }
-
-    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): Promise<void> {
-        Logger.trace(`BrowserTabsUtil.navigateAndWaitToUrl ${url}`);
-
-        await this.navigateTo(url);
-        await this.waitURL(url, timeout);
-    }
-
-    async waitAndSwitchToAnotherWindow(currentWindowHandle: string, timeout: number): Promise<void> {
-        Logger.debug('BrowserTabsUtil.waitAndSwitchToAnotherWindow');
-
-        await this.driverHelper.waitUntilTrue(async () => {
-            const windowHandles: string[] = await this.getAllWindowHandles();
-
-            return windowHandles.length > 1;
-        }, timeout);
-
-        const windowHandles: string[] = await this.getAllWindowHandles();
-
-        for (const windowHandle of windowHandles) {
-            if (windowHandle !== currentWindowHandle) {
-                await this.switchToWindow(windowHandle);
-            }
-        }
-    }
-
-    async refreshPage(): Promise<void> {
-        Logger.debug('BrowserTabsUtil.refreshPage');
-
-        await (await this.driverHelper.getDriver()).navigate().refresh();
-    }
-
-    async getCurrentUrl(): Promise<string> {
-        return await this.driverHelper.getDriver().getCurrentUrl();
-    }
-
-    async waitURL(expectedUrl: string, timeout: number): Promise<void> {
-        Logger.trace(`BrowserTabsUtil.waitURL ${expectedUrl}`);
-
-        await this.driverHelper.getDriver().wait(async () => {
-            const currentUrl: string = await this.driverHelper.getDriver().getCurrentUrl();
-            const urlEquals: boolean = currentUrl === expectedUrl;
-
-            if (urlEquals) {
-                return true;
-            }
-        }, timeout);
-    }
-
-    async maximize(): Promise<void> {
-        Logger.trace(`BrowserTabsUtil.maximize`);
-        if (ChromeDriverConstants.TS_SELENIUM_LAUNCH_FULLSCREEN) {
-            Logger.debug(`TS_SELENIUM_LAUNCH_FULLSCREEN is set to true, maximizing window.`);
-            await this.driverHelper.getDriver().manage().window().maximize();
-        }
-    }
-
-    async closeAllTabsExceptCurrent(): Promise<void> {
-        Logger.trace(`${this.constructor.name}.${this.closeAllTabsExceptCurrent.name}`);
-        const allTabsHandles: string[] = await this.getAllWindowHandles();
-        const currentTabHandle: string = await this.getCurrentWindowHandle();
-        allTabsHandles.splice(allTabsHandles.indexOf(currentTabHandle), 1);
-
-        for (const tabHandle of allTabsHandles) {
-            await this.switchToWindow(tabHandle);
-            await this.driverHelper.getDriver().close();
-        }
-        await this.switchToWindow(currentTabHandle);
-    }
+	constructor(
+		@inject(CLASSES.DriverHelper)
+		private readonly driverHelper: DriverHelper
+	) {}
+
+	async switchToWindow(windowHandle: string): Promise<void> {
+		Logger.debug();
+		await this.driverHelper.getDriver().switchTo().window(windowHandle);
+	}
+
+	async getAllWindowHandles(): Promise<string[]> {
+		Logger.debug();
+
+		return (await this.driverHelper.getDriver()).getAllWindowHandles();
+	}
+
+	async getCurrentWindowHandle(): Promise<string> {
+		Logger.debug();
+
+		return await this.driverHelper.getDriver().getWindowHandle();
+	}
+
+	async navigateTo(url: string): Promise<void> {
+		Logger.debug(`${url}`);
+
+		await this.driverHelper.getDriver().navigate().to(url);
+	}
+
+	async navigateAndWaitToUrl(url: string, timeout: number = TIMEOUT_CONSTANTS.TS_SELENIUM_WAIT_FOR_URL): Promise<void> {
+		Logger.trace(`${url}`);
+
+		await this.navigateTo(url);
+		await this.waitURL(url, timeout);
+	}
+
+	async waitAndSwitchToAnotherWindow(currentWindowHandle: string, timeout: number): Promise<void> {
+		Logger.debug();
+
+		await this.driverHelper.waitUntilTrue(async (): Promise<boolean> => {
+			const windowHandles: string[] = await this.getAllWindowHandles();
+
+			return windowHandles.length > 1;
+		}, timeout);
+
+		const windowHandles: string[] = await this.getAllWindowHandles();
+
+		for (const windowHandle of windowHandles) {
+			if (windowHandle !== currentWindowHandle) {
+				await this.switchToWindow(windowHandle);
+			}
+		}
+	}
+
+	async refreshPage(): Promise<void> {
+		Logger.debug();
+
+		await (await this.driverHelper.getDriver()).navigate().refresh();
+	}
+
+	async getCurrentUrl(): Promise<string> {
+		return await this.driverHelper.getDriver().getCurrentUrl();
+	}
+
+	async waitURL(expectedUrl: string, timeout: number): Promise<void> {
+		Logger.trace(`${expectedUrl}`);
+		try {
+			await this.driverHelper.getDriver().wait(async (): Promise<boolean | undefined> => {
+				const currentUrl: string = await this.driverHelper.getDriver().getCurrentUrl();
+				const urlEquals: boolean = currentUrl === expectedUrl;
+
+				if (urlEquals) {
+					return true;
+				}
+			}, timeout);
+		} catch (e) {
+			throw e;
+		}
+	}
+
+	async maximize(): Promise<void> {
+		Logger.trace();
+		if (CHROME_DRIVER_CONSTANTS.TS_SELENIUM_LAUNCH_FULLSCREEN) {
+			Logger.debug('TS_SELENIUM_LAUNCH_FULLSCREEN is set to true, maximizing window.');
+			await this.driverHelper.getDriver().manage().window().maximize();
+		}
+	}
+
+	async closeAllTabsExceptCurrent(): Promise<void> {
+		Logger.trace();
+		const allTabsHandles: string[] = await this.getAllWindowHandles();
+		const currentTabHandle: string = await this.getCurrentWindowHandle();
+		allTabsHandles.splice(allTabsHandles.indexOf(currentTabHandle), 1);
+
+		for (const tabHandle of allTabsHandles) {
+			await this.switchToWindow(tabHandle);
+			await this.driverHelper.getDriver().close();
+		}
+		await this.switchToWindow(currentTabHandle);
+	}
 }