@eclipse-che/che-e2e 7.73.0-dev-1397a5e → 7.73.0-dev-ed57855

package/tests-library/WorkspaceHandlingTests.ts

@@ -13,7 +13,6 @@ import { inject, injectable } from 'inversify';
 import { CLASSES } from '../configs/inversify.types';
 import { Dashboard } from '../pageobjects/dashboard/Dashboard';
 import { CreateWorkspace } from '../pageobjects/dashboard/CreateWorkspace';
-import { Workspaces } from '../pageobjects/dashboard/Workspaces';
 import { BrowserTabsUtil } from '../utils/BrowserTabsUtil';
 import { Logger } from '../utils/Logger';
 import { ApiUrlResolver } from '../utils/workspace/ApiUrlResolver';
@@ -24,118 +23,100 @@ import { By, error } from 'selenium-webdriver';
 @injectable()
 export class WorkspaceHandlingTests {
 
-    static getWorkspaceName(): string {
-        return WorkspaceHandlingTests.workspaceName;
-    }
+  static getWorkspaceName(): string {
+    return WorkspaceHandlingTests.workspaceName;
+  }
 
-    private static WORKSPACE_NAME_LOCATOR: By = By.xpath(`//h1[contains(.,'Starting workspace ')]`);
-    private static workspaceName: string = 'undefined';
-    private static parentGUID: string;
+  private static WORKSPACE_NAME_LOCATOR: By = By.xpath(`//h1[contains(.,'Starting workspace ')]`);
+  private static workspaceName: string = 'undefined';
+  private static parentGUID: string;
 
-    constructor(
-        @inject(CLASSES.Dashboard) private readonly dashboard: Dashboard,
-        @inject(CLASSES.CreateWorkspace) private readonly createWorkspace: CreateWorkspace,
-        @inject(CLASSES.Workspaces) private readonly workspaces: Workspaces,
-        @inject(CLASSES.BrowserTabsUtil) private readonly browserTabsUtil: BrowserTabsUtil,
-        @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver,
-        @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) {}
+  constructor(
+    @inject(CLASSES.Dashboard) private readonly dashboard: Dashboard,
+    @inject(CLASSES.CreateWorkspace) private readonly createWorkspace: CreateWorkspace,
+    @inject(CLASSES.BrowserTabsUtil) private readonly browserTabsUtil: BrowserTabsUtil,
+    @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver,
+    @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) {}
 
-    setWindowHandle(guid: string): void {
-        WorkspaceHandlingTests.parentGUID = guid;
-    }
+  setWindowHandle(guid: string): void {
+    WorkspaceHandlingTests.parentGUID = guid;
+  }
 
-    getWindowHandle(): string {
-        return WorkspaceHandlingTests.parentGUID;
-    }
+  getWindowHandle(): string {
+    return WorkspaceHandlingTests.parentGUID;
+  }
 
-    createAndOpenWorkspace(stack: string): void {
-        test(`Create and open new workspace, stack:${stack}`, async () => {
-            await this.dashboard.clickWorkspacesButton();
-            await this.dashboard.waitPage();
-            Logger.debug(`Fetching user kubernetes namespace, storing auth token by getting workspaces API URL.`);
-            await this.apiUrlResolver.getWorkspacesApiUrl();
-            await this.dashboard.clickCreateWorkspaceButton();
-            await this.createWorkspace.waitPage();
-            WorkspaceHandlingTests.parentGUID = await this.browserTabsUtil.getCurrentWindowHandle();
-            await this.createWorkspace.clickOnSampleNoEditorSelection(stack);
-            await this.browserTabsUtil.waitAndSwitchToAnotherWindow(WorkspaceHandlingTests.parentGUID, TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
-        });
-    }
+  async createAndOpenWorkspace(stack: string): Promise<void> {
+    await this.dashboard.clickWorkspacesButton();
+    await this.dashboard.waitPage();
+    Logger.debug(`fetching user kubernetes namespace, storing auth token by getting workspaces API URL.`);
+    await this.apiUrlResolver.getWorkspacesApiUrl();
+    await this.dashboard.clickCreateWorkspaceButton();
+    await this.createWorkspace.waitPage();
+    WorkspaceHandlingTests.parentGUID = await this.browserTabsUtil.getCurrentWindowHandle();
+    await this.createWorkspace.clickOnSampleNoEditorSelection(stack);
+    await this.browserTabsUtil.waitAndSwitchToAnotherWindow(WorkspaceHandlingTests.parentGUID, TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
+  }
 
-    createAndOpenWorkspaceFromGitRepository(factoryUrl: string): void {
-        test(`Create and open new workspace from factory:${factoryUrl}`, async () => {
-            await this.dashboard.waitPage();
-            Logger.debug(`Fetching user kubernetes namespace, storing auth token by getting workspaces API URL.`);
-            await this.apiUrlResolver.getWorkspacesApiUrl();
-            await this.dashboard.clickCreateWorkspaceButton();
-            await this.createWorkspace.waitPage();
-            WorkspaceHandlingTests.parentGUID = await this.browserTabsUtil.getCurrentWindowHandle();
-            await this.createWorkspace.importFromGitUsingUI(factoryUrl);
-            await this.browserTabsUtil.waitAndSwitchToAnotherWindow(WorkspaceHandlingTests.parentGUID, TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
-        });
-    }
+  async createAndOpenWorkspaceFromGitRepository(factoryUrl: string): Promise<void> {
+    await this.dashboard.waitPage();
+    Logger.debug(`fetching user kubernetes namespace, storing auth token by getting workspaces API URL.`);
+    await this.apiUrlResolver.getWorkspacesApiUrl();
+    await this.dashboard.clickCreateWorkspaceButton();
+    await this.createWorkspace.waitPage();
+    WorkspaceHandlingTests.parentGUID = await this.browserTabsUtil.getCurrentWindowHandle();
+    await this.createWorkspace.importFromGitUsingUI(factoryUrl);
+    await this.browserTabsUtil.waitAndSwitchToAnotherWindow(WorkspaceHandlingTests.parentGUID, TimeoutConstants.TS_IDE_LOAD_TIMEOUT);
+  }
 
-    openExistingWorkspace(workspaceName: string): void {
-        test('Open and start existing workspace', async () => {
-            await this.dashboard.waitPage();
-            Logger.debug(`Fetching user kubernetes namespace, storing auth token by getting workspaces API URL.`);
-            await this.apiUrlResolver.getWorkspacesApiUrl();
-            await this.dashboard.clickWorkspacesButton();
-            await this.workspaces.waitPage();
-            await this.workspaces.clickOpenButton(workspaceName);
-        });
-    }
+  async obtainWorkspaceNameFromStartingPage(): Promise<void> {
+    const timeout: number = TimeoutConstants.TS_IDE_LOAD_TIMEOUT;
+    const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+    const attempts: number = Math.ceil(timeout / polling);
 
-    obtainWorkspaceNameFromStartingPage(): void {
-        test('Obtain workspace name from workspace loader page', async() => {
-            const timeout: number = TimeoutConstants.TS_IDE_LOAD_TIMEOUT;
-            const polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
-            const attempts: number = Math.ceil(timeout / polling);
-
-            for (let i: number = 0; i < attempts; i++) {
-                try {
-                    let startingWorkspaceLineContent: string = await this.driverHelper.getDriver().findElement(WorkspaceHandlingTests.WORKSPACE_NAME_LOCATOR).getText();
-                    Logger.trace(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage obtained starting workspace getText():${startingWorkspaceLineContent}`);
-                    // cutting away leading text
-                    WorkspaceHandlingTests.workspaceName = startingWorkspaceLineContent.substring('Starting workspace '.length).trim();
-                    Logger.trace(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage trimmed workspace name from getText():${WorkspaceHandlingTests.workspaceName}`);
-                    break;
-                } catch (err) {
-                    if (err instanceof error.StaleElementReferenceError) {
-                        Logger.trace(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage Failed to obtain name from workspace start page, element possibly detached from DOM. Retrying.`);
-                        await this.driverHelper.wait(polling);
-                        continue;
-                    }
-                    if (err instanceof error.NoSuchElementError) {
-                        Logger.trace(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage Failed to obtain name from workspace start page, element not visible yet. Retrying.`);
-                        await this.driverHelper.wait(polling);
-                        continue;
-                    }
-                    Logger.error(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage Obtaining workspace name failed with an unexpected error:${err}`);
-                    throw err;
-                }
-            }
-            if (WorkspaceHandlingTests.workspaceName !== '' && WorkspaceHandlingTests.workspaceName !== 'undefined') {
-                Logger.info(`Obtained workspace name from workspace loader page: ${WorkspaceHandlingTests.workspaceName}`);
-                return;
-            }
-            Logger.error(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
-            throw new error.InvalidArgumentError(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
-        });
+    for (let i: number = 0; i < attempts; i++) {
+      try {
+        let startingWorkspaceLineContent: string = await this.driverHelper.getDriver().findElement(WorkspaceHandlingTests.WORKSPACE_NAME_LOCATOR).getText();
+        Logger.trace(`obtained starting workspace getText():${startingWorkspaceLineContent}`);
+        // cutting away leading text
+        WorkspaceHandlingTests.workspaceName = startingWorkspaceLineContent.substring('Starting workspace '.length).trim();
+        Logger.trace(`trimmed workspace name from getText():${WorkspaceHandlingTests.workspaceName}`);
+        break;
+      } catch (err) {
+        if (err instanceof error.StaleElementReferenceError) {
+          Logger.trace(`failed to obtain name from workspace start page, element possibly detached from DOM. Retrying.`);
+          await this.driverHelper.wait(polling);
+          continue;
+        }
+        if (err instanceof error.NoSuchElementError) {
+          Logger.trace(`failed to obtain name from workspace start page, element not visible yet. Retrying.`);
+          await this.driverHelper.wait(polling);
+          continue;
+        }
+        Logger.error(`obtaining workspace name failed with an unexpected error:${err}`);
+        throw err;
+      }
     }
-
-    async stopWorkspace(workspaceName: string): Promise<void> {
-        await this.dashboard.openDashboard();
-        await this.dashboard.stopWorkspaceByUI(workspaceName);
+    if (WorkspaceHandlingTests.workspaceName !== '' && WorkspaceHandlingTests.workspaceName !== 'undefined') {
+      Logger.info(`obtained workspace name from workspace loader page: ${WorkspaceHandlingTests.workspaceName}`);
+      return;
     }
+    Logger.error(`failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
+    throw new error.InvalidArgumentError(`WorkspaceHandlingTests.obtainWorkspaceNameFromStartingPage failed to obtain workspace name:${WorkspaceHandlingTests.workspaceName}`);
+  }
 
-    async removeWorkspace(workspaceName: string): Promise<void> {
-        await this.dashboard.openDashboard();
-        await this.dashboard.deleteStoppedWorkspaceByUI(workspaceName);
-    }
+  async stopWorkspace(workspaceName: string): Promise<void> {
+    await this.dashboard.openDashboard();
+    await this.dashboard.stopWorkspaceByUI(workspaceName);
+  }
 
-    async stopAndRemoveWorkspace(workspaceName: string): Promise<void> {
-        await this.dashboard.openDashboard();
-        await this.dashboard.stopAndRemoveWorkspaceByUI(workspaceName);
-    }
+  async removeWorkspace(workspaceName: string): Promise<void> {
+    await this.dashboard.openDashboard();
+    await this.dashboard.deleteStoppedWorkspaceByUI(workspaceName);
+  }
+
+  async stopAndRemoveWorkspace(workspaceName: string): Promise<void> {
+    await this.dashboard.openDashboard();
+    await this.dashboard.stopAndRemoveWorkspaceByUI(workspaceName);
+  }
 }

package/utils/BrowserTabsUtil.ts

@@ -8,7 +8,7 @@
  * SPDX-License-Identifier: EPL-2.0
  **********************************************************************/
 
-import { injectable, inject } from 'inversify';
+import { inject, injectable } from 'inversify';
 import { CLASSES } from '../configs/inversify.types';
 import { DriverHelper } from './DriverHelper';
 import { Logger } from './Logger';
@@ -17,97 +17,97 @@ import { ChromeDriverConstants } from '../constants/ChromeDriverConstants';
 
 @injectable()
 export class BrowserTabsUtil {
-    constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
+  constructor(@inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper) { }
 
-    async switchToWindow(windowHandle: string): Promise<void> {
-        Logger.debug('BrowserTabsUtil.switchToWindow');
-        await this.driverHelper.getDriver().switchTo().window(windowHandle);
-    }
+  async switchToWindow(windowHandle: string): Promise<void> {
+    Logger.debug();
+    await this.driverHelper.getDriver().switchTo().window(windowHandle);
+  }
 
-    async getAllWindowHandles(): Promise<string[]> {
-        Logger.debug('BrowserTabsUtil.getAllWindowHandles');
+  async getAllWindowHandles(): Promise<string[]> {
+    Logger.debug();
 
-        return (await this.driverHelper.getDriver()).getAllWindowHandles();
-    }
+    return (await this.driverHelper.getDriver()).getAllWindowHandles();
+  }
 
-    async getCurrentWindowHandle(): Promise<string> {
-        Logger.debug('BrowserTabsUtil.getCurrentWindowHandle');
+  async getCurrentWindowHandle(): Promise<string> {
+    Logger.debug();
 
-        return await this.driverHelper.getDriver().getWindowHandle();
-    }
+    return await this.driverHelper.getDriver().getWindowHandle();
+  }
 
-    async navigateTo(url: string): Promise<void> {
-        Logger.debug(`BrowserTabsUtil.navigateTo ${url}`);
+  async navigateTo(url: string): Promise<void> {
+    Logger.debug(`${url}`);
 
-        await this.driverHelper.getDriver().navigate().to(url);
-    }
+    await this.driverHelper.getDriver().navigate().to(url);
+  }
 
-    async navigateAndWaitToUrl(url: string, timeout: number = TimeoutConstants.TS_SELENIUM_WAIT_FOR_URL): Promise<void> {
-        Logger.trace(`BrowserTabsUtil.navigateAndWaitToUrl ${url}`);
+  async navigateAndWaitToUrl(url: string, timeout: number = TimeoutConstants.TS_SELENIUM_WAIT_FOR_URL): Promise<void> {
+    Logger.trace(`${url}`);
 
-        await this.navigateTo(url);
-        await this.waitURL(url, timeout);
-    }
+    await this.navigateTo(url);
+    await this.waitURL(url, timeout);
+  }
 
-    async waitAndSwitchToAnotherWindow(currentWindowHandle: string, timeout: number): Promise<void> {
-        Logger.debug('BrowserTabsUtil.waitAndSwitchToAnotherWindow');
+  async waitAndSwitchToAnotherWindow(currentWindowHandle: string, timeout: number): Promise<void> {
+    Logger.debug();
 
-        await this.driverHelper.waitUntilTrue(async () => {
-            const windowHandles: string[] = await this.getAllWindowHandles();
+    await this.driverHelper.waitUntilTrue(async () => {
+      const windowHandles: string[] = await this.getAllWindowHandles();
 
-            return windowHandles.length > 1;
-        }, timeout);
+      return windowHandles.length > 1;
+    }, timeout);
 
-        const windowHandles: string[] = await this.getAllWindowHandles();
+    const windowHandles: string[] = await this.getAllWindowHandles();
 
-        for (const windowHandle of windowHandles) {
-            if (windowHandle !== currentWindowHandle) {
-                await this.switchToWindow(windowHandle);
-            }
-        }
+    for (const windowHandle of windowHandles) {
+      if (windowHandle !== currentWindowHandle) {
+        await this.switchToWindow(windowHandle);
+      }
     }
+  }
 
-    async refreshPage(): Promise<void> {
-        Logger.debug('BrowserTabsUtil.refreshPage');
+  async refreshPage(): Promise<void> {
+    Logger.debug();
 
-        await (await this.driverHelper.getDriver()).navigate().refresh();
-    }
+    await (await this.driverHelper.getDriver()).navigate().refresh();
+  }
 
-    async getCurrentUrl(): Promise<string> {
-        return await this.driverHelper.getDriver().getCurrentUrl();
-    }
+  async getCurrentUrl(): Promise<string> {
+    return await this.driverHelper.getDriver().getCurrentUrl();
+  }
 
-    async waitURL(expectedUrl: string, timeout: number): Promise<void> {
-        Logger.trace(`BrowserTabsUtil.waitURL ${expectedUrl}`);
+  async waitURL(expectedUrl: string, timeout: number): Promise<void> {
+    Logger.trace(`${expectedUrl}`);
 
-        await this.driverHelper.getDriver().wait(async () => {
-            const currentUrl: string = await this.driverHelper.getDriver().getCurrentUrl();
-            const urlEquals: boolean = currentUrl === expectedUrl;
+    await this.driverHelper.getDriver().wait(async () => {
+      const currentUrl: string = await this.driverHelper.getDriver().getCurrentUrl();
+      const urlEquals: boolean = currentUrl === expectedUrl;
 
-            if (urlEquals) {
-                return true;
-            }
-        }, timeout);
-    }
+      if (urlEquals) {
+        return true;
+      }
+    }, timeout);
+  }
 
-    async maximize(): Promise<void> {
-        Logger.trace(`BrowserTabsUtil.maximize`);
-        if (ChromeDriverConstants.TS_SELENIUM_LAUNCH_FULLSCREEN) {
-            Logger.debug(`TS_SELENIUM_LAUNCH_FULLSCREEN is set to true, maximizing window.`);
-            await this.driverHelper.getDriver().manage().window().maximize();
-        }
+  async maximize(): Promise<void> {
+    Logger.trace();
+    if (ChromeDriverConstants.TS_SELENIUM_LAUNCH_FULLSCREEN) {
+      Logger.debug(`TS_SELENIUM_LAUNCH_FULLSCREEN is set to true, maximizing window.`);
+      await this.driverHelper.getDriver().manage().window().maximize();
     }
+  }
+
+  async closeAllTabsExceptCurrent(): Promise<void> {
+    Logger.trace();
+    const allTabsHandles: string[] = await this.getAllWindowHandles();
+    const currentTabHandle: string = await this.getCurrentWindowHandle();
+    allTabsHandles.splice(allTabsHandles.indexOf(currentTabHandle), 1);
 
-    async closeAllTabsExceptCurrent(): Promise<void> {
-        Logger.trace(`${this.constructor.name}.${this.closeAllTabsExceptCurrent.name}`);
-        const allTabsHandles: string[] = await this.getAllWindowHandles();
-        const currentTabHandle: string = await this.getCurrentWindowHandle();
-        allTabsHandles.splice(allTabsHandles.indexOf(currentTabHandle), 1);
-
-        for (const tabHandle of allTabsHandles) {
-            await this.switchToWindow(tabHandle);
-            await this.driverHelper.getDriver().close();
-        }
-        await this.switchToWindow(currentTabHandle);
+    for (const tabHandle of allTabsHandles) {
+      await this.switchToWindow(tabHandle);
+      await this.driverHelper.getDriver().close();
     }
+    await this.switchToWindow(currentTabHandle);
+  }
 }

package/utils/CheReporter.ts

@@ -10,6 +10,7 @@
 import * as mocha from 'mocha';
 import { CLASSES } from '../configs/inversify.types';
 import * as fs from 'fs';
+import { WriteStream } from 'fs';
 import * as rm from 'rimraf';
 import { logging } from 'selenium-webdriver';
 import { DriverHelper } from './DriverHelper';
@@ -17,7 +18,6 @@ import { ScreenCatcher } from './ScreenCatcher';
 import { TimeoutConstants } from '../constants/TimeoutConstants';
 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';
@@ -79,7 +79,7 @@ class CheReporter extends mocha.reporters.Spec {
       rm.sync(ReporterConstants.TS_SELENIUM_REPORT_FOLDER);
     });
 
-    runner.on('test', async function (test: mocha.Test): Promise<void> {
+    runner.on('test', async function(test: mocha.Test): Promise<void> {
       if (!ReporterConstants.TS_SELENIUM_EXECUTION_SCREENCAST) {
         return;
       }
@@ -108,8 +108,7 @@ class CheReporter extends mocha.reporters.Spec {
       }
     });
 
-
-    runner.on('end', async function (): Promise<void> {
+    runner.on('end', async function(): Promise<void> {
       // ensure that fired events done
       await driverHelper.wait(5000);
 
@@ -122,7 +121,7 @@ class CheReporter extends mocha.reporters.Spec {
       }
     });
 
-    runner.on('fail', async function (test: mocha.Test): Promise<void> {
+    runner.on('fail', async function(test: mocha.Test): Promise<void> {
       Logger.error(`CheReporter runner.on.fail: ${test.fullTitle()} failed after ${test.duration}ms`);
       // raise flag for keeping the screencast
       deleteScreencast = false;
@@ -139,7 +138,6 @@ class CheReporter extends mocha.reporters.Spec {
       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(ReporterConstants.TS_SELENIUM_REPORT_FOLDER);
 

package/utils/DevWorkspaceConfigurationHelper.ts

@@ -13,71 +13,71 @@ import { APITestConstants } from '../constants/APITestConstants';
  */
 
 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;
+  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;
+  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;
+  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
-        );
+  async generateDevfileContext(): Promise<DevfileContext> {
+    Logger.debug();
+    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));
+  // write templates and then DevWorkspace in a single file
+  async getDevWorkspaceConfigurationYamlAsString(context: DevfileContext): Promise<string> {
+    Logger.debug();
+    const allContentArray: any[] = context.devWorkspaceTemplates.map(
+      (template: V1alpha2DevWorkspaceTemplate) => YAML.stringify(template)
+    );
+    allContentArray.push(YAML.stringify(context.devWorkspace));
 
-        return allContentArray.join('---\n');
-    }
+    return allContentArray.join('---\n');
+  }
 }