@eclipse-che/che-e2e 7.70.0-dev-eacd975 → 7.70.0

package/utils/CheReporter.ts

@@ -11,7 +11,6 @@ import * as mocha from 'mocha';
 import { TYPES, CLASSES } from '../configs/inversify.types';
 import * as fs from 'fs';
 import * as rm from 'rimraf';
-import { TestConstants } from '../constants/TestConstants';
 import { logging } from 'selenium-webdriver';
 import { DriverHelper } from './DriverHelper';
 import { ScreenCatcher } from './ScreenCatcher';
@@ -21,6 +20,11 @@ import { Logger } from './Logger';
 import { e2eContainer } from '../configs/inversify.config';
 import { WriteStream } from 'fs';
 import { StringUtil } from './StringUtil';
+import { BaseTestConstants } from '../constants/BaseTestConstants';
+import { ChromeDriverConstants } from '../constants/ChromeDriverConstants';
+import { OAuthConstants } from '../constants/OAuthConstants';
+import { ReporterConstants } from '../constants/ReporterConstants';
+import { PluginsTestConstants } from '../constants/PluginsTestConstants';
 
 const driverHelper: DriverHelper = e2eContainer.get(CLASSES.DriverHelper);
 const screenCatcher: ScreenCatcher = e2eContainer.get(CLASSES.ScreenCatcher);
@@ -39,32 +43,32 @@ class CheReporter extends mocha.reporters.Spec {
       let launchInformation: string =
         `################## Launch Information ##################
 
-      TS_SELENIUM_BASE_URL: ${TestConstants.TS_SELENIUM_BASE_URL}
-      TS_SELENIUM_HEADLESS: ${TestConstants.TS_SELENIUM_HEADLESS}
-      TS_SELENIUM_OCP_USERNAME: ${TestConstants.TS_SELENIUM_OCP_USERNAME}
-      TS_SELENIUM_EDITOR:   ${TestConstants.TS_SELENIUM_EDITOR}
-
-      TS_SELENIUM_HAPPY_PATH_WORKSPACE_NAME: ${TestConstants.TS_SELENIUM_HAPPY_PATH_WORKSPACE_NAME}
-      TS_SELENIUM_DELAY_BETWEEN_SCREENSHOTS: ${TestConstants.TS_SELENIUM_DELAY_BETWEEN_SCREENSHOTS}
-      TS_SELENIUM_REPORT_FOLDER: ${TestConstants.TS_SELENIUM_REPORT_FOLDER}
-      TS_SELENIUM_EXECUTION_SCREENCAST: ${TestConstants.TS_SELENIUM_EXECUTION_SCREENCAST}
-      DELETE_SCREENCAST_IF_TEST_PASS: ${TestConstants.DELETE_SCREENCAST_IF_TEST_PASS}
-      TS_SELENIUM_REMOTE_DRIVER_URL: ${TestConstants.TS_SELENIUM_REMOTE_DRIVER_URL}
-      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}
+      TS_SELENIUM_BASE_URL: ${BaseTestConstants.TS_SELENIUM_BASE_URL}
+      TS_SELENIUM_HEADLESS: ${ChromeDriverConstants.TS_SELENIUM_HEADLESS}
+      TS_SELENIUM_OCP_USERNAME: ${OAuthConstants.TS_SELENIUM_OCP_USERNAME}
+      TS_SELENIUM_EDITOR:   ${BaseTestConstants.TS_SELENIUM_EDITOR}
+
+      TS_SELENIUM_HAPPY_PATH_WORKSPACE_NAME: ${BaseTestConstants.TS_SELENIUM_HAPPY_PATH_WORKSPACE_NAME}
+      TS_SELENIUM_DELAY_BETWEEN_SCREENSHOTS: ${ReporterConstants.TS_SELENIUM_DELAY_BETWEEN_SCREENSHOTS}
+      TS_SELENIUM_REPORT_FOLDER: ${ReporterConstants.TS_SELENIUM_REPORT_FOLDER}
+      TS_SELENIUM_EXECUTION_SCREENCAST: ${ReporterConstants.TS_SELENIUM_EXECUTION_SCREENCAST}
+      DELETE_SCREENCAST_IF_TEST_PASS: ${ReporterConstants.DELETE_SCREENCAST_IF_TEST_PASS}
+      TS_SELENIUM_REMOTE_DRIVER_URL: ${ChromeDriverConstants.TS_SELENIUM_REMOTE_DRIVER_URL}
+      DELETE_WORKSPACE_ON_FAILED_TEST: ${BaseTestConstants.DELETE_WORKSPACE_ON_FAILED_TEST}
+      TS_SELENIUM_LOG_LEVEL: ${ReporterConstants.TS_SELENIUM_LOG_LEVEL}
+      TS_SELENIUM_LAUNCH_FULLSCREEN: ${ChromeDriverConstants.TS_SELENIUM_LAUNCH_FULLSCREEN}
 
       TS_COMMON_DASHBOARD_WAIT_TIMEOUT: ${TimeoutConstants.TS_COMMON_DASHBOARD_WAIT_TIMEOUT}
       TS_SELENIUM_START_WORKSPACE_TIMEOUT: ${TimeoutConstants.TS_SELENIUM_START_WORKSPACE_TIMEOUT}
       TS_WAIT_LOADER_PRESENCE_TIMEOUT: ${TimeoutConstants.TS_WAIT_LOADER_PRESENCE_TIMEOUT}
 
-      TS_SAMPLE_LIST: ${TestConstants.TS_SAMPLE_LIST}
+      TS_SAMPLE_LIST: ${PluginsTestConstants.TS_SAMPLE_LIST}
 
       ${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) {
+      if (ReporterConstants.TS_SELENIUM_PRINT_TIMEOUT_VARIABLES) {
         launchInformation += `\n      TS_SELENIUM_PRINT_TIMEOUT_VARIABLES is set to true: \n`;
         Object.entries(TimeoutConstants).forEach(
           ([key, value]) => launchInformation += `\n         ${key}: ${value}`);
@@ -76,11 +80,11 @@ class CheReporter extends mocha.reporters.Spec {
 
       console.log(launchInformation);
 
-      rm.sync(TestConstants.TS_SELENIUM_REPORT_FOLDER);
+      rm.sync(ReporterConstants.TS_SELENIUM_REPORT_FOLDER);
     });
 
     runner.on('test', async function (test: mocha.Test): Promise<void> {
-      if (!TestConstants.TS_SELENIUM_EXECUTION_SCREENCAST) {
+      if (!ReporterConstants.TS_SELENIUM_EXECUTION_SCREENCAST) {
         return;
       }
 
@@ -92,13 +96,13 @@ class CheReporter extends mocha.reporters.Spec {
         await screenCatcher.catchMethodScreen(test.title, currentMethodIndex, iterationIndex);
         iterationIndex = iterationIndex + 1;
 
-        await driverHelper.wait(TestConstants.TS_SELENIUM_DELAY_BETWEEN_SCREENSHOTS);
+        await driverHelper.wait(ReporterConstants.TS_SELENIUM_DELAY_BETWEEN_SCREENSHOTS);
       }
     });
 
     runner.on('pass', async (test: mocha.Test) => {
-      if (TestConstants.TS_LOAD_TESTS) {
-        const loadTestReportFolder: string = TestConstants.TS_SELENIUM_LOAD_TEST_REPORT_FOLDER;
+      if (BaseTestConstants.TS_LOAD_TESTS) {
+        const loadTestReportFolder: string = ReporterConstants.TS_SELENIUM_LOAD_TEST_REPORT_FOLDER;
         const loadTestFilePath: string = loadTestReportFolder + '/load-test-results.txt';
         const report: string = test.title + ': ' + test.duration + '\r';
         if (!fs.existsSync(loadTestReportFolder)) {
@@ -117,8 +121,8 @@ class CheReporter extends mocha.reporters.Spec {
       await driverHelper.getDriver().quit();
 
       // delete screencast folder if conditions matched
-      if (deleteScreencast && TestConstants.DELETE_SCREENCAST_IF_TEST_PASS) {
-        rm.sync(TestConstants.TS_SELENIUM_REPORT_FOLDER);
+      if (deleteScreencast && ReporterConstants.DELETE_SCREENCAST_IF_TEST_PASS) {
+        rm.sync(ReporterConstants.TS_SELENIUM_REPORT_FOLDER);
       }
     });
 
@@ -134,17 +138,17 @@ class CheReporter extends mocha.reporters.Spec {
       const testTitle: string = StringUtil.sanitizeTitle(test.title);
       Logger.trace(`TestTitleSanitized:${testTitle}`);
 
-      const testReportDirPath: string = `${TestConstants.TS_SELENIUM_REPORT_FOLDER}/${testFullTitle}`;
+      const testReportDirPath: string = `${ReporterConstants.TS_SELENIUM_REPORT_FOLDER}/${testFullTitle}`;
       const screenshotFileName: string = `${testReportDirPath}/screenshot-${testTitle}.png`;
       const pageSourceFileName: string = `${testReportDirPath}/pagesource-${testTitle}.html`;
       const browserLogsFileName: string = `${testReportDirPath}/browserlogs-${testTitle}.txt`;
 
 
       // create reporter dir if not exist
-      const reportDirExists: boolean = fs.existsSync(TestConstants.TS_SELENIUM_REPORT_FOLDER);
+      const reportDirExists: boolean = fs.existsSync(ReporterConstants.TS_SELENIUM_REPORT_FOLDER);
 
       if (!reportDirExists) {
-        fs.mkdirSync(TestConstants.TS_SELENIUM_REPORT_FOLDER);
+        fs.mkdirSync(ReporterConstants.TS_SELENIUM_REPORT_FOLDER);
       }
 
       // create dir for failed test report if not exist
@@ -179,7 +183,7 @@ class CheReporter extends mocha.reporters.Spec {
       browserLogsStream.end();
 
       // stop and remove running workspace
-      if (TestConstants.DELETE_WORKSPACE_ON_FAILED_TEST) {
+      if (BaseTestConstants.DELETE_WORKSPACE_ON_FAILED_TEST) {
         Logger.warn('Property DELETE_WORKSPACE_ON_FAILED_TEST se to true - trying to stop and delete running workspace.');
         await testWorkspaceUtil.stopAndDeleteWorkspaceByName(CheReporter.latestWorkspace);
       }

package/utils/DevWorkspaceConfigurationHelper.ts

@@ -4,8 +4,8 @@ import { V1alpha2DevWorkspaceTemplate } from '@devfile/api';
 import YAML from 'yaml';
 import * as axios from 'axios';
 import { Logger } from './Logger';
-import { TestConstants } from '../constants/TestConstants';
 import { ShellExecutor } from './ShellExecutor';
+import { APITestConstants } from '../constants/APITestConstants';
 
 /**
  * to see more about IContextParams and generateDevfileContext(params) check README.md in "@eclipse-che/che-devworkspace-generator;
@@ -39,19 +39,19 @@ export class DevWorkspaceConfigurationHelper {
             params.editorEntry = 'che-incubator/che-code/latest';
         }
         // check if one or both has value
-        if (TestConstants.TS_API_TEST_UDI_IMAGE || params.defaultComponentImage) {
+        if (APITestConstants.TS_API_TEST_UDI_IMAGE || params.defaultComponentImage) {
             params.injectDefaultComponent = 'true';
             // check if not explicitly passed than assign value from the constants
             if (!params.defaultComponentImage) {
-                params.defaultComponentImage = TestConstants.TS_API_TEST_UDI_IMAGE;
+                params.defaultComponentImage = APITestConstants.TS_API_TEST_UDI_IMAGE;
             }
         }
         // assign value from the constants if not explicitly passed
-        if (TestConstants.TS_API_TEST_PLUGIN_REGISTRY_URL && !params.pluginRegistryUrl) {
-            params.pluginRegistryUrl = TestConstants.TS_API_TEST_PLUGIN_REGISTRY_URL;
+        if (APITestConstants.TS_API_TEST_PLUGIN_REGISTRY_URL && !params.pluginRegistryUrl) {
+            params.pluginRegistryUrl = APITestConstants.TS_API_TEST_PLUGIN_REGISTRY_URL;
         }
-        if (TestConstants.TS_API_TEST_CHE_CODE_EDITOR_DEVFILE_URI && !params.editorContent) {
-            params.editorContent = ShellExecutor.curl(TestConstants.TS_API_TEST_CHE_CODE_EDITOR_DEVFILE_URI).stdout;
+        if (APITestConstants.TS_API_TEST_CHE_CODE_EDITOR_DEVFILE_URI && !params.editorContent) {
+            params.editorContent = ShellExecutor.curl(APITestConstants.TS_API_TEST_CHE_CODE_EDITOR_DEVFILE_URI).stdout;
         }
         this.params = params;
     }

package/utils/DevfilesRegistryHelper.ts

@@ -7,10 +7,10 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  **********************************************************************/
-import { SupportedDevfilesRegistries, TestConstants } from '../constants/TestConstants';
 import axios, { AxiosResponse } from 'axios';
 import { Logger } from './Logger';
 import YAML from 'yaml';
+import { APITestConstants, SupportedDevfilesRegistries } from '../constants/APITestConstants';
 
 export class DevfilesRegistryHelper {
 
@@ -28,7 +28,7 @@ export class DevfilesRegistryHelper {
         Logger.debug(`${this.constructor.name}.${this.collectPathsToDevfilesFromRegistry.name}`);
         const devfileSamples: object[] = [];
         const sampleNames: string[] = [];
-        switch (TestConstants.TS_API_ACCEPTANCE_TEST_REGISTRY_URL()) {
+        switch (APITestConstants.TS_API_ACCEPTANCE_TEST_REGISTRY_URL()) {
             case (SupportedDevfilesRegistries.GIT_HUB_CHE_DEVFILE_REGISTRY_URL): {
                 const content: any[any] = await this.getGitHubCheDevfileRegistryContent();
                 content.forEach((e: any) => {
@@ -55,7 +55,7 @@ export class DevfilesRegistryHelper {
             }
                 break;
             default: {
-                Logger.error(`${this.constructor.name}.${this.collectPathsToDevfilesFromRegistry.name}: unsupported registry url - ${TestConstants.TS_API_ACCEPTANCE_TEST_REGISTRY_URL()}\n
+                Logger.error(`${this.constructor.name}.${this.collectPathsToDevfilesFromRegistry.name}: unsupported registry url - ${APITestConstants.TS_API_ACCEPTANCE_TEST_REGISTRY_URL()}\n
                 supported registries: ${JSON.stringify(SupportedDevfilesRegistries)}`);
             }
         }

package/utils/DriverHelper.ts

@@ -12,7 +12,6 @@ import { inject, injectable } from 'inversify';
 import { TYPES } from '../configs/inversify.types';
 import { Actions, By, error, ThenableWebDriver, until, WebElement } from 'selenium-webdriver';
 import 'reflect-metadata';
-import { TestConstants } from '../constants/TestConstants';
 import { Logger } from './Logger';
 import { TimeoutConstants } from '../constants/TimeoutConstants';
 
@@ -55,8 +54,8 @@ export class DriverHelper {
     }
 
     async waitVisibilityBoolean(locator: By,
-        attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
+        attempts: number = TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
+        polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
 
         Logger.trace(`DriverHelper.waitVisibilityBoolean ${locator}`);
 
@@ -74,8 +73,8 @@ export class DriverHelper {
     }
 
     async waitDisappearanceBoolean(locator: By,
-        attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
+        attempts: number = TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
+        polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
 
         Logger.trace(`DriverHelper.waitDisappearanceBoolean ${locator}`);
 
@@ -93,7 +92,7 @@ export class DriverHelper {
     }
 
     async waitVisibility(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<WebElement> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitVisibility ${elementLocator}`);
@@ -151,7 +150,7 @@ export class DriverHelper {
     }
 
     async waitPresence(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<WebElement> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitPresence ${elementLocator}`);
@@ -179,7 +178,7 @@ export class DriverHelper {
     }
 
     async waitAllPresence(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<Array<WebElement>> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitAllPresence ${elementLocator}`);
@@ -215,8 +214,8 @@ export class DriverHelper {
     }
 
     async waitDisappearance(elementLocator: By,
-        attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
+        attempts: number = TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
+        polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
 
         Logger.trace(`DriverHelper.waitDisappearance ${elementLocator}`);
 
@@ -240,8 +239,8 @@ export class DriverHelper {
     }
 
     async waitAllDisappearance(locators: Array<By>,
-        attemptsPerLocator: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        pollingPerLocator: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
+        attemptsPerLocator: number = TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
+        pollingPerLocator: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
 
         Logger.trace(`DriverHelper.waitAllDisappearance ${locators}`);
 
@@ -251,7 +250,7 @@ export class DriverHelper {
     }
 
     async waitAndClick(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitAndClick ${elementLocator}`);
@@ -310,7 +309,7 @@ export class DriverHelper {
 
     async waitAndGetElementAttribute(elementLocator: By, attribute: string,
         timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<string> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitAndGetElementAttribute ${elementLocator} attribute: '${attribute}'`);
@@ -352,7 +351,7 @@ export class DriverHelper {
 
     async waitAndGetCssValue(elementLocator: By, cssAttribute: string,
         timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<string> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitAndGetCssValue ${elementLocator} cssAttribute: ${cssAttribute}`);
@@ -409,7 +408,7 @@ export class DriverHelper {
     }
 
     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 polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         if (elementLocator.toString().toLocaleLowerCase().includes('password')) {
@@ -455,7 +454,7 @@ export class DriverHelper {
     }
 
     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 polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.typeToInvisible ${elementLocator} text: ${text}`);
@@ -497,7 +496,7 @@ export class DriverHelper {
     }
 
     async clear(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.clear ${elementLocator}`);
@@ -539,7 +538,7 @@ export class DriverHelper {
     }
 
     async clearInvisible(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.clearInvisible ${elementLocator}`);
@@ -601,7 +600,7 @@ export class DriverHelper {
     }
 
     async waitAndGetText(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<string> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitAndGetText ${elementLocator}`);
@@ -654,7 +653,7 @@ export class DriverHelper {
     }
 
     async scrollTo(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.scrollTo ${elementLocator}`);

package/utils/KubernetesCommandLineToolsExecutor.ts

@@ -1,15 +1,17 @@
 import { echo, exec, ShellString } from 'shelljs';
-import { KubernetesCommandLineTool, TestConstants } from '../constants/TestConstants';
 import { Logger } from './Logger';
 import { ShellExecutor } from './ShellExecutor';
 import * as path from 'path';
+import { APITestConstants, KubernetesCommandLineTool } from '../constants/APITestConstants';
+import { BaseTestConstants } from '../constants/BaseTestConstants';
+import { OAuthConstants } from '../constants/OAuthConstants';
 
 export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
     private static container: string;
     private static pod: string;
     private readonly namespace: string;
     private readonly workspaceName: string | undefined;
-    private readonly KUBERNETES_COMMAND_LINE_TOOL: string = TestConstants.TS_API_TEST_KUBERNETES_COMMAND_LINE_TOOL;
+    private readonly KUBERNETES_COMMAND_LINE_TOOL: string = APITestConstants.TS_API_TEST_KUBERNETES_COMMAND_LINE_TOOL;
 
     constructor(_workspaceName?: string, _namespace?: string) {
         super();
@@ -33,8 +35,8 @@ export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
             if (this.isUserLoggedIn()) {
                 Logger.debug(`${this.getLoggingName(this.loginToOcp.name)}: User already logged`);
             } else {
-                Logger.debug(`${this.getLoggingName(this.loginToOcp.name)}: Login ${url}, ${TestConstants.TS_SELENIUM_OCP_USERNAME}`);
-                exec(`oc login --server=${url} -u=${TestConstants.TS_SELENIUM_OCP_USERNAME} -p=${TestConstants.TS_SELENIUM_OCP_PASSWORD} --insecure-skip-tls-verify`);
+                Logger.debug(`${this.getLoggingName(this.loginToOcp.name)}: Login ${url}, ${APITestConstants.TS_SELENIUM_OCP_USERNAME}`);
+                exec(`oc login --server=${url} -u=${APITestConstants.TS_SELENIUM_OCP_USERNAME} -p=${APITestConstants.TS_SELENIUM_OCP_PASSWORD} --insecure-skip-tls-verify`);
             }
         } else {
             Logger.debug(`${this.getLoggingName(this.loginToOcp.name)}: doesn't support login command`);
@@ -58,7 +60,7 @@ export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
         Logger.debug(`${this.getLoggingName(this.deleteDevWorkspace.name)}: Delete '${this.workspaceName}' workspace`);
         ShellExecutor.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} patch dw ${this.workspaceName} -n ${this.namespace} -p '{ "metadata": { "finalizers": null }}' --type merge || true`);
         ShellExecutor.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} delete dw ${this.workspaceName} -n ${this.namespace} || true`);
-        ShellExecutor.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} delete dwt ${TestConstants.TS_SELENIUM_EDITOR}-${this.workspaceName} -n ${this.namespace} || true`);
+        ShellExecutor.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} delete dwt ${APITestConstants.TS_SELENIUM_EDITOR}-${this.workspaceName} -n ${this.namespace} || true`);
     }
 
     applyAndWaitDevWorkspace(yamlConfiguration: string): ShellString {
@@ -121,7 +123,7 @@ export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
     private isUserLoggedIn(): boolean {
         const whoamiCommandOutput: ShellString = ShellExecutor.execWithLog('oc whoami && oc whoami --show-server=true');
 
-        return whoamiCommandOutput.stdout.includes(TestConstants.TS_SELENIUM_OCP_USERNAME) && whoamiCommandOutput.stdout.includes(this.getServerUrl());
+        return whoamiCommandOutput.stdout.includes(OAuthConstants.TS_SELENIUM_OCP_USERNAME) && whoamiCommandOutput.stdout.includes(this.getServerUrl());
     }
 
     private getLoggingName(methodName: string): string {
@@ -130,15 +132,15 @@ export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
 
     private setNamespace(_namespace: string | undefined): string {
         _namespace = _namespace !== undefined ? _namespace
-            : TestConstants.TS_SELENIUM_BASE_URL.includes('devspaces') ? TestConstants.TS_SELENIUM_OCP_USERNAME + '-devspaces'
-                : TestConstants.TS_SELENIUM_BASE_URL.includes('che') ? TestConstants.TS_SELENIUM_OCP_USERNAME + '-che'
+            : BaseTestConstants.TS_SELENIUM_BASE_URL.includes('devspaces') ? OAuthConstants.TS_SELENIUM_OCP_USERNAME + '-devspaces'
+                : BaseTestConstants.TS_SELENIUM_BASE_URL.includes('che') ? OAuthConstants.TS_SELENIUM_OCP_USERNAME + '-che'
                     : 'default';
         return _namespace;
     }
 
     private getServerUrl(): string {
         Logger.debug(`${this.getLoggingName(this.getServerUrl.name)}: Get server api url.`);
-        return TestConstants.TS_SELENIUM_BASE_URL.replace('devspaces.apps', 'api') + ':6443';
+        return BaseTestConstants.TS_SELENIUM_BASE_URL.replace('devspaces.apps', 'api') + ':6443';
     }
 }
 

package/utils/Logger.ts

@@ -1,5 +1,3 @@
-import { TestConstants } from '../constants/TestConstants';
-
 /*********************************************************************
  * Copyright (c) 2019-2023 Red Hat, Inc.
  *
@@ -9,6 +7,7 @@ import { TestConstants } from '../constants/TestConstants';
  *
  * SPDX-License-Identifier: EPL-2.0
  **********************************************************************/
+import { ReporterConstants } from '../constants/ReporterConstants';
 
 export abstract class Logger {
 
@@ -27,7 +26,7 @@ export abstract class Logger {
      * @param indentLevel log level
      */
     static warn(text: string, indentLevel: number = 1): void {
-        if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR') {
+        if (ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR') {
             return;
         }
         this.logText(indentLevel, `[WARN] ${text}`);
@@ -39,8 +38,8 @@ export abstract class Logger {
      * @param indentLevel log level
      */
     static info(text: string, indentLevel: number = 3): void {
-        if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
-            TestConstants.TS_SELENIUM_LOG_LEVEL === 'WARN') {
+        if (ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
+            ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'WARN') {
             return;
         }
         this.logText(indentLevel, `• ${text}`);
@@ -52,9 +51,9 @@ export abstract class Logger {
      * @param indentLevel log level
      */
     static debug(text: string, indentLevel: number = 5): void {
-        if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
-            TestConstants.TS_SELENIUM_LOG_LEVEL === 'WARN' ||
-            TestConstants.TS_SELENIUM_LOG_LEVEL === 'INFO') {
+        if (ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
+            ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'WARN' ||
+            ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'INFO') {
             return;
         }
         this.logText(indentLevel, `▼ ${text}`);
@@ -67,10 +66,10 @@ export abstract class Logger {
      * @param indentLevel log level
      */
     static trace(text: string, indentLevel: number = 6): void {
-        if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
-            TestConstants.TS_SELENIUM_LOG_LEVEL === 'WARN' ||
-            TestConstants.TS_SELENIUM_LOG_LEVEL === 'INFO' ||
-            TestConstants.TS_SELENIUM_LOG_LEVEL === 'DEBUG') {
+        if (ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
+            ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'WARN' ||
+            ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'INFO' ||
+            ReporterConstants.TS_SELENIUM_LOG_LEVEL === 'DEBUG') {
             return;
         }
         this.logText(indentLevel, `‣ ${text}`);

package/utils/ScreenCatcher.ts

@@ -12,22 +12,22 @@ import { injectable, inject } from 'inversify';
 import { CLASSES } from '../configs/inversify.types';
 import { DriverHelper } from './DriverHelper';
 import { error } from 'selenium-webdriver';
-import { TestConstants } from '../constants/TestConstants';
 import { WriteStream } from 'fs';
 import { StringUtil } from './StringUtil';
+import { ReporterConstants } from '../constants/ReporterConstants';
 
 @injectable()
 export class ScreenCatcher {
     constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
 
     async catchMethodScreen(methodName: string, methodIndex: number, screenshotIndex: number): Promise<void> {
-        const executionScreenCastDir: string = `${TestConstants.TS_SELENIUM_REPORT_FOLDER}/executionScreencast`;
-        const executionScreenCastErrorsDir: string = `${TestConstants.TS_SELENIUM_REPORT_FOLDER}/executionScreencastErrors`;
+        const executionScreenCastDir: string = `${ReporterConstants.TS_SELENIUM_REPORT_FOLDER}/executionScreencast`;
+        const executionScreenCastErrorsDir: string = `${ReporterConstants.TS_SELENIUM_REPORT_FOLDER}/executionScreencastErrors`;
         const formattedMethodIndex: string = new Intl.NumberFormat('en-us', { minimumIntegerDigits: 3 }).format(methodIndex);
         const formattedScreenshotIndex: string = new Intl.NumberFormat('en-us', { minimumIntegerDigits: 5 }).format(screenshotIndex).replace(/,/g, '');
 
-        if (!fs.existsSync(TestConstants.TS_SELENIUM_REPORT_FOLDER)) {
-            fs.mkdirSync(TestConstants.TS_SELENIUM_REPORT_FOLDER);
+        if (!fs.existsSync(ReporterConstants.TS_SELENIUM_REPORT_FOLDER)) {
+            fs.mkdirSync(ReporterConstants.TS_SELENIUM_REPORT_FOLDER);
         }
 
         if (!fs.existsSync(executionScreenCastDir)) {

package/utils/request-handlers/CheApiRequestHandler.ts

@@ -9,11 +9,11 @@
  **********************************************************************/
 
 import axios, { AxiosResponse, AxiosRequestConfig } from 'axios';
-import { TestConstants } from '../../constants/TestConstants';
 import { TYPES } from '../../configs/inversify.types';
 import { inject, injectable } from 'inversify';
 import { IAuthorizationHeaderHandler } from './headers/IAuthorizationHeaderHandler';
 import { Logger } from '../Logger';
+import { BaseTestConstants } from '../../constants/BaseTestConstants';
 
 @injectable()
 export class CheApiRequestHandler {
@@ -104,7 +104,7 @@ export class CheApiRequestHandler {
     }
 
     private assembleUrl(relativeUrl: string): string {
-        return `${TestConstants.TS_SELENIUM_BASE_URL}/${relativeUrl}`;
+        return `${BaseTestConstants.TS_SELENIUM_BASE_URL}/${relativeUrl}`;
     }
 
 }

package/utils/request-handlers/headers/CheMultiuserAuthorizationHeaderHandler.ts

@@ -14,12 +14,12 @@ import { DriverHelper } from '../../DriverHelper';
 import { CLASSES } from '../../../configs/inversify.types';
 import { Logger } from '../../Logger';
 import { IWebDriverCookie } from 'selenium-webdriver';
-import { Platform, TestConstants } from '../../../constants/TestConstants';
+import { BaseTestConstants, Platform } from '../../../constants/BaseTestConstants';
 
 @injectable()
 export class CheMultiuserAuthorizationHeaderHandler implements IAuthorizationHeaderHandler {
     private authorizationToken: string = '';
-    private readonly cookiesType: string = TestConstants.TS_PLATFORM === Platform.OPENSHIFT ? '_oauth_proxy' : '_oauth2_proxy';
+    private readonly cookiesType: string = BaseTestConstants.TS_PLATFORM === Platform.OPENSHIFT ? '_oauth_proxy' : '_oauth2_proxy';
 
     constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
 

package/utils/workspace/TestWorkspaceUtil.ts

@@ -9,7 +9,6 @@
  **********************************************************************/
 
 import 'reflect-metadata';
-import { TestConstants } from '../../constants/TestConstants';
 import { injectable, inject } from 'inversify';
 import { DriverHelper } from '../DriverHelper';
 import { WorkspaceStatus } from './WorkspaceStatus';
@@ -20,11 +19,12 @@ import { Logger } from '../Logger';
 import axios, { AxiosResponse } from 'axios';
 import { ITestWorkspaceUtil } from './ITestWorkspaceUtil';
 import { ApiUrlResolver } from './ApiUrlResolver';
+import { TimeoutConstants } from '../../constants/TimeoutConstants';
 
 @injectable()
 export class TestWorkspaceUtil implements ITestWorkspaceUtil {
-    readonly attempts: number = TestConstants.TS_SELENIUM_WORKSPACE_STATUS_ATTEMPTS;
-    readonly polling: number = TestConstants.TS_SELENIUM_WORKSPACE_STATUS_POLLING;
+    readonly attempts: number = TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS;
+    readonly polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
 
     constructor(
         @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,