@eclipse-che/che-e2e 7.68.0-dev-52d73d3 → 7.68.0-dev-8aa6599

package/specs/factory/Factory.spec.ts

@@ -62,7 +62,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
     const commitChangesButtonLabel: string = `Commit Changes on "${TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_BRANCH}"`;
     const refreshButtonLabel: string = 'Refresh';
     const pushItemLabel: string = 'Push';
-    const testRepoProjectName: string = GitUtil.getProjectNameFromGitUrl(TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_URL);
+    let testRepoProjectName: string;
 
     loginTests.loginIntoChe();
     test(`Navigate to the factory URL`, async function (): Promise<void> {
@@ -88,6 +88,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
     });
 
     test('Check if a project folder has been created', async function (): Promise<void> {
+        testRepoProjectName = GitUtil.getProjectNameFromGitUrl(TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_URL);
         Logger.debug(`new SideBarView().getContent().getSection: get ${testRepoProjectName}`);
         projectSection = await new SideBarView().getContent().getSection(testRepoProjectName);
     });
@@ -129,7 +130,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
         Logger.debug(`scmView.getProviders: "${scmProvider}, ${scmProvider}"`);
     });
 
-    test('Check if the changes is displayed in the source control manager', async function (): Promise<void> {
+    test('Check if the changes are displayed in the source control manager', async function (): Promise<void> {
         await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
         await driverHelper.wait(timeToRefresh);
         Logger.debug(`scmProvider.takeAction: "${refreshButtonLabel}"`);

package/specs/factory/NoSetupRepoFactory.spec.ts

@@ -68,7 +68,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
     const commitChangesButtonLabel: string = `Commit Changes on "${TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_BRANCH}"`;
     const refreshButtonLabel: string = 'Refresh';
     const label: string = TestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME;
-    const testRepoProjectName: string = GitUtil.getProjectNameFromGitUrl(TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_URL);
+    let testRepoProjectName: string;
     const isPrivateRepo: string = TestConstants.TS_SELENIUM_IS_PRIVATE_FACTORY_GIT_REPO ? 'private' : 'public';
 
     loginTests.loginIntoChe();
@@ -114,6 +114,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
         });
 
         test('Check if a project folder has been created', async function (): Promise<void> {
+            testRepoProjectName = GitUtil.getProjectNameFromGitUrl(TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_URL);
             Logger.debug(`new SideBarView().getContent().getSection: get ${testRepoProjectName}`);
             projectSection = await new SideBarView().getContent().getSection(testRepoProjectName);
         });
@@ -170,7 +171,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
             Logger.debug(`scmView.getProviders: "${scmProvider}, ${scmProvider}"`);
         });
 
-        test('Check if the changes is displayed in the source control manager', async function (): Promise<void> {
+        test('Check if the changes are displayed in the source control manager', async function (): Promise<void> {
             await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
             await driverHelper.wait(timeToRefresh);
             Logger.debug(`scmProvider.takeAction: "${refreshButtonLabel}"`);

package/specs/factory/RefusedOAuthFactory.spec.ts

@@ -65,7 +65,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
     const refreshButtonLabel: string = 'Refresh';
     const pushItemLabel: string = 'Push';
     const label: string = TestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME;
-    const testRepoProjectName: string = GitUtil.getProjectNameFromGitUrl(TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_URL);
+    let testRepoProjectName: string;
     const isPrivateRepo: string = TestConstants.TS_SELENIUM_IS_PRIVATE_FACTORY_GIT_REPO ? 'private' : 'public';
 
     loginTests.loginIntoChe();
@@ -97,6 +97,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
     });
 
     test('Check if a project folder has been created', async function (): Promise<void> {
+        testRepoProjectName = GitUtil.getProjectNameFromGitUrl(TestConstants.TS_SELENIUM_FACTORY_GIT_REPO_URL);
         Logger.debug(`new SideBarView().getContent().getSection: get ${testRepoProjectName}`);
         projectSection = await new SideBarView().getContent().getSection(testRepoProjectName);
     });
@@ -167,7 +168,7 @@ suite(`Create a workspace via launching a factory from the ${TestConstants.TS_SE
             Logger.debug(`scmView.getProviders: "${scmProvider}, ${scmProvider}"`);
         });
 
-        test('Check if the changes is displayed in the source control manager', async function (): Promise<void> {
+        test('Check if the changes are displayed in the source control manager', async function (): Promise<void> {
             await driverHelper.waitVisibility(webCheCodeLocators.ScmView.more);
             await driverHelper.wait(timeToRefresh);
             Logger.debug(`scmProvider.takeAction: "${refreshButtonLabel}"`);

package/tests-library/LoginTests.ts

@@ -25,7 +25,7 @@ export class LoginTests {
         @inject(CLASSES.Dashboard) private readonly dashboard: Dashboard) {
     }
 
-    public loginIntoChe(): void {
+    loginIntoChe(): void {
         test('Login', async () => {
             if (!(await this.browserTabsUtil.getCurrentUrl()).includes(TestConstants.TS_SELENIUM_BASE_URL)) {
                 await this.browserTabsUtil.navigateTo(TestConstants.TS_SELENIUM_BASE_URL);
@@ -36,7 +36,7 @@ export class LoginTests {
         });
     }
 
-    public loginIntoOcpConsole(): void {
+    loginIntoOcpConsole(): void {
         test('Login into ocp console', async () => {
             const openshiftConsoleUrl: string =  TestConstants.TS_SELENIUM_BASE_URL.replace('devspaces', 'console-openshift-console');
             await this.browserTabsUtil.navigateTo(openshiftConsoleUrl);
@@ -45,7 +45,7 @@ export class LoginTests {
         });
     }
 
-    public logoutFromChe(): void {
+    logoutFromChe(): void {
         test('Logout', async () => {
             await this.dashboard.logout();
         });

package/tests-library/ProjectAndFileTests.ts

@@ -22,7 +22,7 @@ export class ProjectAndFileTests {
     constructor(
         @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) {}
 
-    public async waitWorkspaceReadinessForCheCodeEditor(): Promise<void> {
+    async waitWorkspaceReadinessForCheCodeEditor(): Promise<void> {
         Logger.debug(`${this.constructor.name}.${this.waitWorkspaceReadinessForCheCodeEditor.name} - Waiting for editor.`);
         try {
             const start: number = new Date().getTime();

package/tests-library/WorkspaceHandlingTests.ts

@@ -25,7 +25,7 @@ import { TestConstants } from '../constants/TestConstants';
 @injectable()
 export class WorkspaceHandlingTests {
 
-    public static getWorkspaceName(): string {
+    static getWorkspaceName(): string {
         return WorkspaceHandlingTests.workspaceName;
     }
 
@@ -41,15 +41,15 @@ export class WorkspaceHandlingTests {
         @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver,
         @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) {}
 
-    public setWindowHandle(guid: string): void {
+    setWindowHandle(guid: string): void {
         WorkspaceHandlingTests.parentGUID = guid;
     }
 
-    public getWindowHandle(): string {
+    getWindowHandle(): string {
         return WorkspaceHandlingTests.parentGUID;
     }
 
-    public createAndOpenWorkspace(stack: string): void {
+    createAndOpenWorkspace(stack: string): void {
         test(`Create and open new workspace, stack:${stack}`, async () => {
             await this.dashboard.clickWorkspacesButton();
             await this.dashboard.waitPage();
@@ -63,7 +63,7 @@ export class WorkspaceHandlingTests {
         });
     }
 
-    public createAndOpenWorkspaceFromGitRepository(factoryUrl: string): void {
+    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.`);
@@ -76,7 +76,7 @@ export class WorkspaceHandlingTests {
         });
     }
 
-    public openExistingWorkspace(workspaceName: string): void {
+    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.`);
@@ -87,7 +87,7 @@ export class WorkspaceHandlingTests {
         });
     }
 
-    public obtainWorkspaceNameFromStartingPage(): void {
+    obtainWorkspaceNameFromStartingPage(): void {
         test('Obtain workspace name from workspace loader page', async() => {
             const timeout: number = TimeoutConstants.TS_IDE_LOAD_TIMEOUT;
             const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
@@ -125,17 +125,17 @@ export class WorkspaceHandlingTests {
         });
     }
 
-    public async stopWorkspace(workspaceName: string): Promise<void> {
+    async stopWorkspace(workspaceName: string): Promise<void> {
         await this.dashboard.openDashboard();
         await this.dashboard.stopWorkspaceByUI(workspaceName);
     }
 
-    public async removeWorkspace(workspaceName: string): Promise<void> {
+    async removeWorkspace(workspaceName: string): Promise<void> {
         await this.dashboard.openDashboard();
         await this.dashboard.deleteStoppedWorkspaceByUI(workspaceName);
     }
 
-    public async stopAndRemoveWorkspace(workspaceName: string): Promise<void> {
+    async stopAndRemoveWorkspace(workspaceName: string): Promise<void> {
         await this.dashboard.openDashboard();
         await this.dashboard.stopAndRemoveWorkspaceByUI(workspaceName);
     }

package/utils/DevWorkspaceConfigurationHelper.ts

@@ -0,0 +1,57 @@
+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';
+
+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';
+        }
+        this.params = params;
+    }
+
+    async generateDevfileContext(): Promise<DevfileContext> {
+        Logger.debug(`${this.constructor.name}.${this.generateDevfileContext.name}`);
+        return await this.generator.generateDevfileContext(
+            {
+                ...this.params
+            },
+            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/DriverHelper.ts

@@ -25,13 +25,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,19 +42,19 @@ 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,
+    async waitVisibilityBoolean(locator: By,
         attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
         polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
 
@@ -73,7 +73,7 @@ export class DriverHelper {
         return false;
     }
 
-    public async waitDisappearanceBoolean(locator: By,
+    async waitDisappearanceBoolean(locator: By,
         attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
         polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<boolean> {
 
@@ -92,7 +92,7 @@ export class DriverHelper {
         return false;
     }
 
-    public async waitVisibility(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<WebElement> {
+    async waitVisibility(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<WebElement> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -150,7 +150,7 @@ 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> {
+    async waitPresence(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<WebElement> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -178,7 +178,7 @@ 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>> {
+    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 attempts: number = Math.ceil(timeout / polling);
 
@@ -206,7 +206,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,7 +214,7 @@ export class DriverHelper {
         }
     }
 
-    public async waitDisappearance(elementLocator: By,
+    async waitDisappearance(elementLocator: By,
         attempts: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
         polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
 
@@ -227,7 +227,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,7 +239,7 @@ export class DriverHelper {
         }, timeout);
     }
 
-    public async waitAllDisappearance(locators: Array<By>,
+    async waitAllDisappearance(locators: Array<By>,
         attemptsPerLocator: number = TestConstants.TS_SELENIUM_DEFAULT_ATTEMPTS,
         pollingPerLocator: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING): Promise<void> {
 
@@ -250,7 +250,7 @@ export class DriverHelper {
         }
     }
 
-    public async waitAndClick(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+    async waitAndClick(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -308,7 +308,7 @@ 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 attempts: number = Math.ceil(timeout / polling);
@@ -350,7 +350,7 @@ 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 attempts: number = Math.ceil(timeout / polling);
@@ -392,7 +392,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,7 +408,7 @@ export class DriverHelper {
             `The '${attribute}' attribute value doesn't match with expected value '${expectedValue}'`);
     }
 
-    public async type(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
+    async type(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -454,7 +454,7 @@ 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> {
+    async typeToInvisible(elementLocator: By, text: string, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -496,7 +496,7 @@ 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> {
+    async clear(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -538,7 +538,7 @@ 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> {
+    async clearInvisible(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -580,7 +580,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,13 +594,13 @@ 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> {
+    async waitAndGetText(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<string> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -641,19 +641,19 @@ 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> {
+    async scrollTo(elementLocator: By, timeout: number = TimeoutConstants.TS_SELENIUM_CLICK_ON_VISIBLE_ITEM): Promise<void> {
         const polling: number = TestConstants.TS_SELENIUM_DEFAULT_POLLING;
         const attempts: number = Math.ceil(timeout / polling);
 
@@ -696,16 +696,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

@@ -43,22 +43,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 ${TestConstants.TS_SELENIUM_EDITOR}-${this.workspaceName} -n ${this.namespace} || true`);
     }
 
     applyAndWaitDevWorkspace(yamlConfiguration: string): ShellString {
@@ -74,48 +74,48 @@ export class KubernetesCommandLineToolsExecutor extends ShellExecutor {
 
     executeCommand(commandToExecute: string): 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 ${KubernetesCommandLineToolsExecutor.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`);
+        return ShellExecutor.execWithLog(`${(this.KUBERNETES_COMMAND_LINE_TOOL)} wait -n ${this.namespace} --for=condition=Ready dw ${this.workspaceName} --timeout=${timeout}s`);
     }
 
     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 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());
     }

package/utils/Logger.ts

@@ -17,7 +17,7 @@ export abstract class Logger {
      * @param text log text
      * @param indentLevel log level
      */
-    public static error(text: string, indentLevel: number = 1): void {
+    static error(text: string, indentLevel: number = 1): void {
         this.logText(indentLevel, `[ERROR] ${text}`);
     }
 
@@ -26,7 +26,7 @@ export abstract class Logger {
      * @param text log text
      * @param indentLevel log level
      */
-    public static warn(text: string, indentLevel: number = 1): void {
+    static warn(text: string, indentLevel: number = 1): void {
         if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR') {
             return;
         }
@@ -38,7 +38,7 @@ export abstract class Logger {
      * @param text log text
      * @param indentLevel log level
      */
-    public static info(text: string, indentLevel: number = 3): void {
+    static info(text: string, indentLevel: number = 3): void {
         if (TestConstants.TS_SELENIUM_LOG_LEVEL === 'ERROR' ||
             TestConstants.TS_SELENIUM_LOG_LEVEL === 'WARN') {
             return;
@@ -51,7 +51,7 @@ export abstract class Logger {
      * @param text log text
      * @param indentLevel log level
      */
-    public static debug(text: string, indentLevel: number = 5): void {
+    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') {
@@ -66,7 +66,7 @@ export abstract class Logger {
      * @param text log text
      * @param indentLevel log level
      */
-    public static trace(text: string, indentLevel: number = 6): void {
+    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' ||

package/utils/Sanitizer.ts

@@ -13,7 +13,7 @@ import { injectable } from 'inversify';
 @injectable()
 export class Sanitizer {
 
-    public sanitize(arg: string): string {
+    sanitize(arg: string): string {
         return arg.replace(/[\/]/g, '+').replace(/[\,]/g, '.').replace(/[\:]/g, '-').replace(/[\'\"]/g, '').replace(/[^a-z0-9\+\-\.\(\)\[\]\_]/gi, '_');
     }
 }