@eclipse-che/che-e2e 7.67.0 → 7.67.1-dev-e49f025

package/utils/DevWorkspaceConfigurationHelper.ts

@@ -0,0 +1,83 @@
+import { Main as Generator } from '@eclipse-che/che-devworkspace-generator/lib/main';
+import { DevfileContext } from '@eclipse-che/che-devworkspace-generator/lib/api/devfile-context';
+import { V1alpha2DevWorkspaceTemplate } from '@devfile/api';
+import YAML from 'yaml';
+import * as axios from 'axios';
+import { Logger } from './Logger';
+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;
+ * tests/e2e/node_modules/@eclipse-che/che-devworkspace-generator/README.md
+ */
+
+interface IContextParams {
+    devfilePath?: string | undefined;
+    devfileUrl?: string | undefined;
+    devfileContent?: string | undefined;
+    outputFile?: string | undefined;
+    editorPath?: string | undefined;
+    editorContent?: string | undefined;
+    editorEntry?: string | undefined;
+    pluginRegistryUrl?: string | undefined;
+    projects?: {
+        name: string;
+        location: string;
+    }[];
+    injectDefaultComponent?: string | undefined;
+    defaultComponentImage?: string | undefined;
+}
+
+export class DevWorkspaceConfigurationHelper {
+    private generator: Generator = new Generator();
+    private readonly params: IContextParams;
+
+    constructor(params: IContextParams) {
+        // check if all undefined
+        if (!(params.editorPath || params.editorEntry || params.editorContent)) {
+            params.editorEntry = 'che-incubator/che-code/latest';
+        }
+        // check if one or both has value
+        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 = APITestConstants.TS_API_TEST_UDI_IMAGE;
+            }
+        }
+        // assign value from the constants if not explicitly passed
+        if (APITestConstants.TS_API_TEST_PLUGIN_REGISTRY_URL && !params.pluginRegistryUrl) {
+            params.pluginRegistryUrl = APITestConstants.TS_API_TEST_PLUGIN_REGISTRY_URL;
+        }
+        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;
+    }
+
+    async generateDevfileContext(): Promise<DevfileContext> {
+        Logger.debug(`${this.constructor.name}.${this.generateDevfileContext.name}`);
+        if (!this.params.projects) {
+            this.params.projects = [];
+        }
+        return await this.generator.generateDevfileContext(
+            {
+                ...this.params,
+                projects: this.params.projects
+            },
+            axios.default as any
+        );
+    }
+
+    // write templates and then DevWorkspace in a single file
+    async getDevWorkspaceConfigurationYamlAsString(context: DevfileContext): Promise<string> {
+        Logger.debug(`${this.constructor.name}.${this.getDevWorkspaceConfigurationYamlAsString.name}`);
+        const allContentArray: any[] = context.devWorkspaceTemplates.map(
+            (template: V1alpha2DevWorkspaceTemplate) => YAML.stringify(template)
+        );
+        allContentArray.push(YAML.stringify(context.devWorkspace));
+
+        return allContentArray.join('---\n');
+    }
+}

package/utils/DevfilesRegistryHelper.ts

@@ -0,0 +1,77 @@
+/*********************************************************************
+ * Copyright (c) 2023 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+import axios, { AxiosResponse } from 'axios';
+import { Logger } from './Logger';
+import YAML from 'yaml';
+import { APITestConstants, SupportedDevfilesRegistries } from '../constants/APITestConstants';
+
+export class DevfilesRegistryHelper {
+
+    async getInbuiltDevfilesRegistryContent(): Promise<AxiosResponse> {
+        Logger.debug(`${this.constructor.name}.${this.getInbuiltDevfilesRegistryContent.name}`);
+        return await this.getContent(SupportedDevfilesRegistries.INBUILT_APPLICATION_DEVFILE_REGISTRY_URL());
+    }
+
+    async getGitHubCheDevfileRegistryContent(): Promise<AxiosResponse> {
+        Logger.debug(`${this.constructor.name}.${this.getGitHubCheDevfileRegistryContent.name}`);
+        return await this.getContent(SupportedDevfilesRegistries.GIT_HUB_CHE_DEVFILE_REGISTRY_URL);
+    }
+
+    async collectPathsToDevfilesFromRegistry(): Promise<object[]> {
+        Logger.debug(`${this.constructor.name}.${this.collectPathsToDevfilesFromRegistry.name}`);
+        const devfileSamples: object[] = [];
+        const sampleNames: string[] = [];
+        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) => {
+                    if (e.name[0] !== '.') { sampleNames.push(e.name); }
+                });
+
+                for (const sample of sampleNames) {
+                    const sampleEndpoint: string = `${SupportedDevfilesRegistries.GIT_HUB_CHE_DEVFILE_REGISTRY_URL}${sample}/meta.yaml`;
+                    const sampleEndpointContent: AxiosResponse = await this.getContent(sampleEndpoint);
+                    const decodedFileContent: string = Buffer.from((sampleEndpointContent as any).content, 'base64').toString();
+                    const metaYamlContent: any = YAML.parse(decodedFileContent);
+                    devfileSamples.push({name: sample, link: metaYamlContent.links.v2});
+                }
+                Logger.debug(`${this.constructor.name}.${this.collectPathsToDevfilesFromRegistry.name}: samples list: ${JSON.stringify(devfileSamples)}`);
+            }
+                break;
+            case (SupportedDevfilesRegistries.INBUILT_APPLICATION_DEVFILE_REGISTRY_URL()): {
+                const content: any[any] = await this.getInbuiltDevfilesRegistryContent();
+
+                for (const sample of content) {
+                    devfileSamples.push({name: sample.displayName, link: sample.links.v2});
+                }
+                Logger.debug(`${this.constructor.name}.${this.collectPathsToDevfilesFromRegistry.name}: samples list: ${JSON.stringify(devfileSamples)}`);
+            }
+                break;
+            default: {
+                Logger.error(`${this.constructor.name}.${this.collectPathsToDevfilesFromRegistry.name}: unsupported registry url - ${APITestConstants.TS_API_ACCEPTANCE_TEST_REGISTRY_URL()}\n
+                supported registries: ${JSON.stringify(SupportedDevfilesRegistries)}`);
+            }
+        }
+        return devfileSamples;
+    }
+
+    private async getContent(url: string, headers?: object): Promise<AxiosResponse> {
+        Logger.debug(`${this.constructor.name}.${this.getContent.name}: ${url}`);
+
+        let response: AxiosResponse | undefined;
+        try {
+            response = await axios.get(url, headers);
+        } catch (error) {
+            Logger.error(`${error} + ${url}`);
+            throw error;
+        }
+        return response?.data;
+    }
+}

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';
 
@@ -25,13 +24,13 @@ export class DriverHelper {
         this.driver = driver.get() as ThenableWebDriver;
     }
 
-    public getAction(): Actions {
+    getAction(): Actions {
         Logger.trace('DriverHelper.getAction');
 
         return this.driver.actions();
     }
 
-    public async isVisible(locator: By): Promise<boolean> {
+    async isVisible(locator: By): Promise<boolean> {
         Logger.trace(`DriverHelper.isVisible ${locator}`);
 
         try {
@@ -42,21 +41,21 @@ export class DriverHelper {
         }
     }
 
-    public async wait(milliseconds: number): Promise<void> {
+    async wait(milliseconds: number): Promise<void> {
         Logger.trace(`DriverHelper.wait (${milliseconds} milliseconds)`);
 
         await this.driver.sleep(milliseconds);
     }
 
-    public async refreshPage(): Promise<void> {
+    async refreshPage(): Promise<void> {
         Logger.trace(`DriverHelper.refreshPage`);
 
         await this.driver.navigate().refresh();
     }
 
-    public async waitVisibilityBoolean(locator: By,
-        attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
+    async waitVisibilityBoolean(locator: By,
+        attempts: number = TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
+        polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
 
         Logger.trace(`DriverHelper.waitVisibilityBoolean ${locator}`);
 
@@ -73,9 +72,9 @@ export class DriverHelper {
         return false;
     }
 
-    public async waitDisappearanceBoolean(locator: By,
-        attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
+    async waitDisappearanceBoolean(locator: By,
+        attempts: number = TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
+        polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
 
         Logger.trace(`DriverHelper.waitDisappearanceBoolean ${locator}`);
 
@@ -92,8 +91,8 @@ export class DriverHelper {
         return false;
     }
 
-    public async waitVisibility(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<WebElement> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitVisibility(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<WebElement> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitVisibility ${elementLocator}`);
@@ -150,8 +149,8 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum visibility checkings attempts for '${elementLocator}' element, timeouted after ${timeout}`);
     }
 
-    public async waitPresence(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<WebElement> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitPresence(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<WebElement> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitPresence ${elementLocator}`);
@@ -178,8 +177,8 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum presence checking attempts, problems with 'StaleElementReferenceError' of '${elementLocator}' element`);
     }
 
-    public async waitAllPresence(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<Array<WebElement>> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitAllPresence(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<Array<WebElement>> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitAllPresence ${elementLocator}`);
@@ -206,7 +205,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): Promise<void> {
+    async waitAllVisibility(locators: Array<By>, timeout: number): Promise<void> {
         Logger.trace(`DriverHelper.waitAllVisibility ${locators}`);
 
         for (const elementLocator of locators) {
@@ -214,9 +213,9 @@ export class DriverHelper {
         }
     }
 
-    public async waitDisappearance(elementLocator: By,
-        attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
+    async waitDisappearance(elementLocator: By,
+        attempts: number = TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
+        polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
 
         Logger.trace(`DriverHelper.waitDisappearance ${elementLocator}`);
 
@@ -227,7 +226,7 @@ export class DriverHelper {
         }
     }
 
-    public async waitDisappearanceWithTimeout(elementLocator: By, timeout: number): Promise<void> {
+    async waitDisappearanceWithTimeout(elementLocator: By, timeout: number): Promise<void> {
         Logger.trace(`DriverHelper.waitDisappearanceWithTimeout ${elementLocator}`);
 
         await this.getDriver().wait(async () => {
@@ -239,9 +238,9 @@ export class DriverHelper {
         }, timeout);
     }
 
-    public async waitAllDisappearance(locators: Array<By>,
-        attemptsPerLocator: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
-        pollingPerLocator: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
+    async waitAllDisappearance(locators: Array<By>,
+        attemptsPerLocator: number = TimeoutConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
+        pollingPerLocator: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
 
         Logger.trace(`DriverHelper.waitAllDisappearance ${locators}`);
 
@@ -250,8 +249,8 @@ export class DriverHelper {
         }
     }
 
-    public async waitAndClick(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitAndClick(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitAndClick ${elementLocator}`);
@@ -308,9 +307,9 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum clicking attempts, the '${elementLocator}' element is not clickable`);
     }
 
-    public async waitAndGetElementAttribute(elementLocator: By, attribute: string,
+    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}'`);
@@ -350,9 +349,9 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum gettin of the '${attribute}' attribute attempts, from the '${elementLocator}' element`);
     }
 
-    public async waitAndGetCssValue(elementLocator: By, cssAttribute: string,
+    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}`);
@@ -392,7 +391,7 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum gettin of the '${cssAttribute}' css attribute attempts, from the '${elementLocator}' element`);
     }
 
-    public async waitAttributeValue(elementLocator: By,
+    async waitAttributeValue(elementLocator: By,
         attribute: string,
         expectedValue: string,
         timeout: number): Promise<void> {
@@ -408,8 +407,8 @@ 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): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async type(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         if (elementLocator.toString().toLocaleLowerCase().includes('password')) {
@@ -454,8 +453,8 @@ 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): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async typeToInvisible(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.typeToInvisible ${elementLocator} text: ${text}`);
@@ -496,8 +495,8 @@ 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): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async clear(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.clear ${elementLocator}`);
@@ -538,8 +537,8 @@ 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): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async clearInvisible(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.clearInvisible ${elementLocator}`);
@@ -580,7 +579,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): Promise<void> {
+    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 {
@@ -594,14 +593,14 @@ export class DriverHelper {
         await this.waitAttributeValue(elementLocator, 'value', text, timeout);
     }
 
-    public async waitAndSwitchToFrame(iframeLocator: By, timeout: number): Promise<void> {
+    async waitAndSwitchToFrame(iframeLocator: By, timeout: number): Promise<void> {
         Logger.trace(`DriverHelper.waitAndSwitchToFrame ${iframeLocator}`);
 
         await this.driver.wait(until.ableToSwitchToFrame(iframeLocator), timeout);
     }
 
-    public async waitAndGetText(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<string> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async waitAndGetText(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<string> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.waitAndGetText ${elementLocator}`);
@@ -641,20 +640,20 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum text obtaining attempts, from the '${elementLocator}' element`);
     }
 
-    public async waitAndGetValue(elementLocator: By, timeout: number): Promise<string> {
+    async waitAndGetValue(elementLocator: By, timeout: number): Promise<string> {
         Logger.trace(`DriverHelper.waitAndGetValue ${elementLocator}`);
 
         return await this.waitAndGetElementAttribute(elementLocator, 'value', timeout);
     }
 
-    public async waitUntilTrue(callback: any, timeout: number): Promise<void> {
+    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): Promise<void> {
-        const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
+    async scrollTo(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+        const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
         Logger.trace(`DriverHelper.scrollTo ${elementLocator}`);
@@ -696,16 +695,21 @@ export class DriverHelper {
         throw new error.TimeoutError(`Exceeded maximum mouse move attempts, for the '${elementLocator}' element`);
     }
 
-    public async scrollToAndClick(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+    async scrollToAndClick(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         await this.scrollTo(elementLocator, timeout);
         await this.waitAndClick(elementLocator, timeout);
     }
 
-    public async scrollToAndEnterValue(elementLocator: By, value: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+    async scrollToAndEnterValue(elementLocator: By, value: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         await this.scrollTo(elementLocator, timeout);
         await this.enterValue(elementLocator, value, timeout);
     }
 
+    // method is useful to debug page object elements
+    async highLightElement(element: WebElement): Promise<void> {
+        await this.getDriver().executeScript('arguments[0].style.border=\'2px solid red\'', element);
+    }
+
         getDriver(): ThenableWebDriver {
         Logger.trace('DriverHelper.getDriver');
 

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`);
@@ -43,22 +45,22 @@ export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
 
     getContainerName(): string {
         Logger.debug(`${this.getLoggingName(this.getContainerName.name)}: Get container name.`);
-        const output: ShellString = this.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} get ${(KubernetesCommandLineToolsExecutor.pod)} -o jsonpath='{.spec.containers[*].name}' -n ${this.namespace}`);
+        const output: ShellString = ShellExecutor.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} get ${(KubernetesCommandLineToolsExecutor.pod)} -o jsonpath='{.spec.containers[*].name}' -n ${this.namespace}`);
         echo('\n');
         return output.stderr ? output.stderr : output.stdout;
     }
 
     getWorkspacePodName(): string {
         Logger.debug(`${this.getLoggingName(this.getWorkspacePodName.name)}: Get workspace pod name.`);
-        const output: ShellString = this.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} get pod -l controller.devfile.io/devworkspace_name=${this.workspaceName} -n ${this.namespace} -o name`);
+        const output: ShellString = ShellExecutor.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} get pod -l controller.devfile.io/devworkspace_name=${this.workspaceName} -n ${this.namespace} -o name`);
         return output.stderr ? output.stderr : output.stdout.replace('\n', '');
     }
 
     deleteDevWorkspace(): void {
         Logger.debug(`${this.getLoggingName(this.deleteDevWorkspace.name)}: Delete '${this.workspaceName}' workspace`);
-        this.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} patch dw ${this.workspaceName} -n ${this.namespace} -p '{ "metadata": { "finalizers": null }}' --type merge || true`);
-        this.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} delete dw ${this.workspaceName} -n ${this.namespace} || true`);
-        this.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)} 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 ${APITestConstants.TS_SELENIUM_EDITOR}-${this.workspaceName} -n ${this.namespace} || true`);
     }
 
     applyAndWaitDevWorkspace(yamlConfiguration: string): ShellString {
@@ -66,58 +68,62 @@ export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
             this.createNamespace();
         }
         this.applyYamlConfigurationAsStringOutput(yamlConfiguration);
-        const output: ShellString = this.waitDevWorkspace();
-        KubernetesCommandLineToolsExecutor.pod = this.getWorkspacePodName();
-        KubernetesCommandLineToolsExecutor.container = this.getContainerName();
-        return output;
+        return this.waitDevWorkspace();
     }
 
-    executeCommand(commandToExecute: string): ShellString {
+    executeCommand(commandToExecute: string, container: string = KubernetesCommandLineToolsExecutor.container): ShellString {
         Logger.debug(`${this.getLoggingName(this.executeCommand.name)}:`);
-        return this.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} exec -i ${KubernetesCommandLineToolsExecutor.pod} -n ${this.namespace} -c ${KubernetesCommandLineToolsExecutor.container} -- sh -c "${commandToExecute}"`);
+        return ShellExecutor.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} exec -i ${KubernetesCommandLineToolsExecutor.pod} -n ${this.namespace} -c ${container} -- sh -c '${commandToExecute}'`);
     }
 
-    applyYamlConfigurationAsStringOutput(yamlConfiguration: string): void {
+    applyYamlConfigurationAsStringOutput(yamlConfiguration: string): ShellString {
         Logger.debug(`${this.getLoggingName(this.applyYamlConfigurationAsStringOutput.name)}:`);
-        this.execWithLog(`cat <<EOF | ${this.KUBERNETES_COMMAND_LINE_TOOL} apply -n ${this.namespace} -f - \n` +
+        return ShellExecutor.execWithLog(`cat <<EOF | ${this.KUBERNETES_COMMAND_LINE_TOOL} apply -n ${this.namespace} -f - \n` +
             yamlConfiguration + '\n' +
             'EOF');
     }
 
     applyYamlConfigurationAsFile(pathToFile: string): void {
         Logger.debug(`${this.getLoggingName(this.applyYamlConfigurationAsFile.name)}:`);
-        this.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} apply -n ${this.namespace} -f "${path.resolve(pathToFile)}"`);
+        ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} apply -n ${this.namespace} -f "${path.resolve(pathToFile)}"`);
     }
 
     getDevWorkspaceYamlConfiguration(): ShellString {
         Logger.debug(`${this.getLoggingName(this.getDevWorkspaceYamlConfiguration.name)}:`);
-        return this.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} get dw ${this.workspaceName} -n ${this.namespace} -o yaml`);
+        return ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} get dw ${this.workspaceName} -n ${this.namespace} -o yaml`);
     }
 
     waitDevWorkspace(timeout: number = 360): ShellString {
         Logger.debug(`${this.getLoggingName(this.waitDevWorkspace.name)}: Wait till workspace ready.`);
-        return this.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} wait -n ${this.namespace} --for=condition=Ready dw ${this.workspaceName} --timeout=${timeout}s`);
+        const output: ShellString = ShellExecutor.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} wait -n ${this.namespace} --for=condition=Ready dw ${this.workspaceName} --timeout=${timeout}s`);
+        this.getPodAndContainerNames();
+        return output;
     }
 
     createNamespace(): void {
         Logger.debug(`${this.getLoggingName(this.createNamespace.name)}: Create namespace "${this.namespace}".`);
-        this.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} create namespace ${this.namespace}`);
+        ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} create namespace ${this.namespace}`);
     }
 
     createProject(projectName: string): void {
         Logger.debug(`${this.getLoggingName(this.createProject.name)}: Create new project "${projectName}".`);
-        this.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} new-project ${projectName} -n ${this.namespace}`);
+        ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} new-project ${projectName} -n ${this.namespace}`);
     }
 
     deleteProject(projectName: string): void {
         Logger.debug(`${this.getLoggingName(this.deleteProject.name)}: Delete "${projectName}".`);
-        this.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} delete project ${projectName} -n ${this.namespace}`);
+        ShellExecutor.execWithLog(`${this.KUBERNETES_COMMAND_LINE_TOOL} delete project ${projectName} -n ${this.namespace}`);
+    }
+
+    private getPodAndContainerNames(): void {
+        KubernetesCommandLineToolsExecutor.pod = this.getWorkspacePodName();
+        KubernetesCommandLineToolsExecutor.container = this.getContainerName();
     }
 
     private isUserLoggedIn(): boolean {
-        const whoamiCommandOutput: ShellString = this.execWithLog('oc whoami && oc whoami --show-server=true');
+        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 {
@@ -126,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';
     }
 }
 
@@ -163,5 +169,14 @@ export namespace KubernetesCommandLineToolsExecutor {
         removeFolder(path: string): ShellString {
             return this.executeCommand('rm -rf ' + path);
         }
+
+        getEnvValue(envName: string): string {
+            envName = envName.replace(/[${}]/g, '');
+            const output: ShellString = this.executeCommand(`env | grep ${envName}`);
+            return output.stderr ? output.stderr :
+                output.stdout
+                    .substring(output.stdout.lastIndexOf('=') + 1)
+                    .replace('\n', '');
+        }
     }
 }