@eclipse-che/che-e2e 7.73.0-dev-11985ec → 7.73.0-dev-62c0c9d

package/specs/api/EmptyWorkspaceAPI.spec.ts

@@ -7,68 +7,68 @@ import { DevfileContext } from '@eclipse-che/che-devworkspace-generator/lib/api/
 import { APITestConstants } from '../../constants/APITestConstants';
 import { BaseTestConstants } from '../../constants/BaseTestConstants';
 
-suite(`Empty workspace API test`, async function (): Promise<void> {
-    // works only for root user
-    const namespace: string = APITestConstants.TS_API_TEST_NAMESPACE;
-    let clonedProjectName: string;
-    let containerWorkDir: string;
-    let devWorkspaceConfigurationHelper: DevWorkspaceConfigurationHelper;
-    let kubernetesCommandLineToolsExecutor: KubernetesCommandLineToolsExecutor;
-    let devfileContext: DevfileContext;
-    let devWorkspaceName: string | undefined;
-    let containerTerminal: KubernetesCommandLineToolsExecutor.ContainerTerminal;
+suite(`Empty workspace API test`, async function(): Promise<void> {
+  // works only for root user
+  const namespace: string = APITestConstants.TS_API_TEST_NAMESPACE;
+  let clonedProjectName: string;
+  let containerWorkDir: string;
+  let devWorkspaceConfigurationHelper: DevWorkspaceConfigurationHelper;
+  let kubernetesCommandLineToolsExecutor: KubernetesCommandLineToolsExecutor;
+  let devfileContext: DevfileContext;
+  let devWorkspaceName: string | undefined;
+  let containerTerminal: KubernetesCommandLineToolsExecutor.ContainerTerminal;
 
-    const gitRepository: string = 'https://github.com/crw-qe/web-nodejs-sample';
+  const gitRepository: string = 'https://github.com/crw-qe/web-nodejs-sample';
 
-    suiteSetup('Create empty workspace with OC client', async function (): Promise<void> {
-        const workspaceName: string = 'empty-' + Math.floor(Math.random() * 1000);
-        const devfileContent: string =
-            'schemaVersion: 2.2.0\n' +
-            'metadata:\n' +
-            `  name: ${workspaceName}\n`;
+  suiteSetup('Create empty workspace with OC client', async function(): Promise<void> {
+    const workspaceName: string = 'empty-' + Math.floor(Math.random() * 1000);
+    const devfileContent: string =
+      'schemaVersion: 2.2.0\n' +
+      'metadata:\n' +
+      `  name: ${workspaceName}\n`;
 
-        devWorkspaceConfigurationHelper = new DevWorkspaceConfigurationHelper({
-            devfileContent,
-        });
-        devfileContext = await devWorkspaceConfigurationHelper.generateDevfileContext();
-        devWorkspaceName = devfileContext?.devWorkspace?.metadata?.name;
-        kubernetesCommandLineToolsExecutor = new KubernetesCommandLineToolsExecutor(devWorkspaceName, namespace);
-        containerTerminal = new KubernetesCommandLineToolsExecutor.ContainerTerminal(kubernetesCommandLineToolsExecutor);
+    devWorkspaceConfigurationHelper = new DevWorkspaceConfigurationHelper({
+      devfileContent
     });
+    devfileContext = await devWorkspaceConfigurationHelper.generateDevfileContext();
+    devWorkspaceName = devfileContext?.devWorkspace?.metadata?.name;
+    kubernetesCommandLineToolsExecutor = new KubernetesCommandLineToolsExecutor(devWorkspaceName, namespace);
+    containerTerminal = new KubernetesCommandLineToolsExecutor.ContainerTerminal(kubernetesCommandLineToolsExecutor);
+  });
 
-    test('Create empty workspace', async function (): Promise<void> {
-        kubernetesCommandLineToolsExecutor.loginToOcp();
-        const devWorkspaceConfigurationYamlString: string = await devWorkspaceConfigurationHelper.getDevWorkspaceConfigurationYamlAsString(devfileContext);
-        const output: ShellString = kubernetesCommandLineToolsExecutor.applyAndWaitDevWorkspace(devWorkspaceConfigurationYamlString);
-        expect(output.stdout).contains('condition met');
-    });
-
-    suite('Clone public repo without previous setup', function (): void {
+  test('Create empty workspace', async function(): Promise<void> {
+    kubernetesCommandLineToolsExecutor.loginToOcp();
+    const devWorkspaceConfigurationYamlString: string = await devWorkspaceConfigurationHelper.getDevWorkspaceConfigurationYamlAsString(devfileContext);
+    const output: ShellString = kubernetesCommandLineToolsExecutor.applyAndWaitDevWorkspace(devWorkspaceConfigurationYamlString);
+    expect(output.stdout).contains('condition met');
+  });
 
-        test('Check if public repo can be cloned', function (): void {
-            containerWorkDir = containerTerminal.pwd().stdout.replace('\n', '');
-            const cloneOutput: ShellString = containerTerminal.gitClone(gitRepository);
-            expect(cloneOutput.stdout + cloneOutput.stderr).includes('Cloning');
-        });
+  suite('Clone public repo without previous setup', function(): void {
 
-        test('Check if project was created', function (): void {
-            clonedProjectName = StringUtil.getProjectNameFromGitUrl(gitRepository);
-            expect(containerTerminal.ls().stdout).includes(clonedProjectName);
-        });
+    test('Check if public repo can be cloned', function(): void {
+      containerWorkDir = containerTerminal.pwd().stdout.replace('\n', '');
+      const cloneOutput: ShellString = containerTerminal.gitClone(gitRepository);
+      expect(cloneOutput.stdout + cloneOutput.stderr).includes('Cloning');
+    });
 
-        test('Check if project files are imported', function (): void {
-            expect(containerTerminal.ls(`${containerWorkDir}/${clonedProjectName}`).stdout)
-                .includes(BaseTestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME);
-        });
+    test('Check if project was created', function(): void {
+      clonedProjectName = StringUtil.getProjectNameFromGitUrl(gitRepository);
+      expect(containerTerminal.ls().stdout).includes(clonedProjectName);
+    });
 
-        suiteTeardown('Delete cloned project', function (): void {
-            containerTerminal.removeFolder(`${clonedProjectName}`);
-        });
+    test('Check if project files are imported', function(): void {
+      expect(containerTerminal.ls(`${containerWorkDir}/${clonedProjectName}`).stdout)
+        .includes(BaseTestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME);
     });
 
-    suiteTeardown('Delete workspace', function (): void {
-        kubernetesCommandLineToolsExecutor.deleteDevWorkspace();
+    suiteTeardown('Delete cloned project', function(): void {
+      containerTerminal.removeFolder(`${clonedProjectName}`);
     });
+  });
+
+  suiteTeardown('Delete workspace', function(): void {
+    kubernetesCommandLineToolsExecutor.deleteDevWorkspace();
+  });
 });
 
 

package/specs/api/PodOverridesAPI.spec.ts

@@ -5,40 +5,40 @@ import YAML from 'yaml';
 import { expect } from 'chai';
 import { ShellExecutor } from '../../utils/ShellExecutor';
 
-suite(`Test defining pod overrides via attribute.`, async function (): Promise<void> {
-    const pathToSampleFile: string = path.resolve('resources/pod-overrides.yaml');
-    const workspaceName: string = YAML.parse(fs.readFileSync(pathToSampleFile, 'utf8')).metadata.name;
-    const kubernetesCommandLineToolsExecutor: KubernetesCommandLineToolsExecutor = new KubernetesCommandLineToolsExecutor(workspaceName);
+suite(`Test defining pod overrides via attribute.`, async function(): Promise<void> {
+  const pathToSampleFile: string = path.resolve('resources/pod-overrides.yaml');
+  const workspaceName: string = YAML.parse(fs.readFileSync(pathToSampleFile, 'utf8')).metadata.name;
+  const kubernetesCommandLineToolsExecutor: KubernetesCommandLineToolsExecutor = new KubernetesCommandLineToolsExecutor(workspaceName);
 
-    suiteSetup('Login into OC client', function (): void {
-        kubernetesCommandLineToolsExecutor.loginToOcp();
-    });
+  suiteSetup('Login into OC client', function(): void {
+    kubernetesCommandLineToolsExecutor.loginToOcp();
+  });
 
-    suiteTeardown('Delete DevWorkspace', function (): void {
-        kubernetesCommandLineToolsExecutor.deleteDevWorkspace();
-    });
+  suiteTeardown('Delete DevWorkspace', function(): void {
+    kubernetesCommandLineToolsExecutor.deleteDevWorkspace();
+  });
 
-    test('Apply pod-overrides sample as DevWorkspace with OC client', function (): void {
-        kubernetesCommandLineToolsExecutor.applyYamlConfigurationAsFile(pathToSampleFile);
-        ShellExecutor.wait(5);
-    });
+  test('Apply pod-overrides sample as DevWorkspace with OC client', function(): void {
+    kubernetesCommandLineToolsExecutor.applyYamlConfigurationAsFile(pathToSampleFile);
+    ShellExecutor.wait(5);
+  });
 
-    test('Check that fields are overridden in the Deployment for DevWorkspace', function (): void {
-       const devWorkspaceFullYamlOutput: any = YAML.parse(kubernetesCommandLineToolsExecutor.getDevWorkspaceYamlConfiguration());
-       expect(devWorkspaceFullYamlOutput.spec.template.attributes['pod-overrides']).eqls({
-           metadata: {
-               annotations: {
-                   'io.kubernetes.cri-o.userns-mode': 'auto:size=65536;map-to-root=true',
-                   'io.openshift.userns': 'true',
-                   'openshift.io/scc': 'container-build'
-               }
-           },
-           spec: {
-               runtimeClassName: 'kata',
-               schedulerName: 'stork'
-           }
-       });
+  test('Check that fields are overridden in the Deployment for DevWorkspace', function(): void {
+    const devWorkspaceFullYamlOutput: any = YAML.parse(kubernetesCommandLineToolsExecutor.getDevWorkspaceYamlConfiguration());
+    expect(devWorkspaceFullYamlOutput.spec.template.attributes['pod-overrides']).eqls({
+      metadata: {
+        annotations: {
+          'io.kubernetes.cri-o.userns-mode': 'auto:size=65536;map-to-root=true',
+          'io.openshift.userns': 'true',
+          'openshift.io/scc': 'container-build'
+        }
+      },
+      spec: {
+        runtimeClassName: 'kata',
+        schedulerName: 'stork'
+      }
     });
+  });
 });
 
 

package/specs/dashboard-samples/EmptyWorkspace.spec.ts

@@ -24,38 +24,42 @@ const browserTabsUtil: BrowserTabsUtil = e2eContainer.get(CLASSES.BrowserTabsUti
 
 const stackName: string = 'Empty Workspace';
 
-suite(`${stackName} test`, async () => {
-    loginTests.loginIntoChe();
+suite(`${stackName} test`, async function(): Promise<void> {
+  loginTests.loginIntoChe();
 
-    workspaceHandlingTests.createAndOpenWorkspace(stackName);
+  test(`Create and open new workspace, stack:${stackName}`, async function(): Promise<void> {
+    await workspaceHandlingTests.createAndOpenWorkspace(stackName);
+  });
 
-    workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
+  test('Obtain workspace name from workspace loader page', async function(): Promise<void> {
+    await workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
+  });
 
-    test('Register running workspace', async () => {
-        registerRunningWorkspace(WorkspaceHandlingTests.getWorkspaceName());
-    });
+  test('Register running workspace', async function(): Promise<void> {
+    registerRunningWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+  });
 
-    test('Wait workspace readiness', async () => {
-        await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
+  test('Wait workspace readiness', async function(): Promise<void> {
+    await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
 
-        const workbench: Workbench = new Workbench();
-        const activityBar: ActivityBar = workbench.getActivityBar();
-        const activityBarControls: ViewControl[] = await activityBar.getViewControls();
+    const workbench: Workbench = new Workbench();
+    const activityBar: ActivityBar = workbench.getActivityBar();
+    const activityBarControls: ViewControl[] = await activityBar.getViewControls();
 
-        Logger.debug(`Editor sections:`);
-        for (const control of activityBarControls) {
-            Logger.debug(`${await control.getTitle()}`);
-        }
-    });
+    Logger.debug(`Editor sections:`);
+    for (const control of activityBarControls) {
+      Logger.debug(`${await control.getTitle()}`);
+    }
+  });
 
-    test('Stop the workspace', async function (): Promise<void> {
-        await workspaceHandlingTests.stopWorkspace(WorkspaceHandlingTests.getWorkspaceName());
-        await browserTabsUtil.closeAllTabsExceptCurrent();
-    });
+  test('Stop the workspace', async function(): Promise<void> {
+    await workspaceHandlingTests.stopWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+    await browserTabsUtil.closeAllTabsExceptCurrent();
+  });
 
-    test('Delete the workspace', async function (): Promise<void> {
-        await workspaceHandlingTests.removeWorkspace(WorkspaceHandlingTests.getWorkspaceName());
-    });
+  test('Delete the workspace', async function(): Promise<void> {
+    await workspaceHandlingTests.removeWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+  });
 
-    loginTests.logoutFromChe();
+  loginTests.logoutFromChe();
 });

package/specs/dashboard-samples/Quarkus.spec.ts

@@ -27,40 +27,44 @@ const browserTabsUtil: BrowserTabsUtil = e2eContainer.get(CLASSES.BrowserTabsUti
 const stackName: string = 'Java 11 with Quarkus';
 const projectName: string = 'quarkus-quickstarts';
 
-suite(`The ${stackName} userstory`, async function (): Promise<void> {
-    let projectSection: ViewSection;
+suite(`The ${stackName} userstory`, async function(): Promise<void> {
+  let projectSection: ViewSection;
 
-    loginTests.loginIntoChe();
+  loginTests.loginIntoChe();
 
-    workspaceHandlingTests.createAndOpenWorkspace(stackName);
+  test(`Create and open new workspace, stack:${stackName}`, async function(): Promise<void> {
+    await workspaceHandlingTests.createAndOpenWorkspace(stackName);
+  });
 
-    workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
+  test('Obtain workspace name from workspace loader page', async function(): Promise<void> {
+    await workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
+  });
 
-    test('Register running workspace', async () => {
-        registerRunningWorkspace(WorkspaceHandlingTests.getWorkspaceName());
-    });
+  test('Register running workspace', async function(): Promise<void> {
+    registerRunningWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+  });
 
-    test('Wait workspace readiness', async function (): Promise<void> {
-        await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
-    });
+  test('Wait workspace readiness', async function(): Promise<void> {
+    await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
+  });
 
-    test('Check a project folder has been created', async function (): Promise<void> {
-        projectSection = await new SideBarView().getContent().getSection(projectName);
-        Logger.debug(`new SideBarView().getContent().getSection: get ${projectName}`);
-    });
+  test('Check a project folder has been created', async function(): Promise<void> {
+    projectSection = await new SideBarView().getContent().getSection(projectName);
+    Logger.debug(`new SideBarView().getContent().getSection: get ${projectName}`);
+  });
 
-    test('Check the project files was imported', async function (): Promise<void> {
-        await projectSection.findItem(BaseTestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME);
-        Logger.debug(`projectSection.findItem: find ${BaseTestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME}`);
-    });
+  test('Check the project files was imported', async function(): Promise<void> {
+    await projectSection.findItem(BaseTestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME);
+    Logger.debug(`projectSection.findItem: find ${BaseTestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME}`);
+  });
 
-    test('Stop the workspace', async function (): Promise<void> {
-        await workspaceHandlingTests.stopWorkspace(WorkspaceHandlingTests.getWorkspaceName());
-        await browserTabsUtil.closeAllTabsExceptCurrent();
-    });
+  test('Stop the workspace', async function(): Promise<void> {
+    await workspaceHandlingTests.stopWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+    await browserTabsUtil.closeAllTabsExceptCurrent();
+  });
 
-    test('Delete the workspace', async function (): Promise<void> {
-        await workspaceHandlingTests.removeWorkspace(WorkspaceHandlingTests.getWorkspaceName());
-    });
-    loginTests.logoutFromChe();
+  test('Delete the workspace', async function(): Promise<void> {
+    await workspaceHandlingTests.removeWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+  });
+  loginTests.logoutFromChe();
 });

package/specs/dashboard-samples/RecommendedExtensions.spec.ts

@@ -0,0 +1,205 @@
+/*********************************************************************
+ * Copyright (c) 2019-2023 Red Hat, Inc.
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ **********************************************************************/
+
+import {
+    ActivityBar,
+    ContextMenu,
+    ContextMenuItem,
+    EditorView,
+    ExtensionsViewItem,
+    ExtensionsViewSection,
+    Locators,
+    ModalDialog,
+    SideBarView,
+    TextEditor,
+    ViewItem,
+    ViewSection
+} from 'monaco-page-objects';
+import { registerRunningWorkspace } from '../MochaHooks';
+import { LoginTests } from '../../tests-library/LoginTests';
+import { e2eContainer } from '../../configs/inversify.config';
+import { CLASSES } from '../../configs/inversify.types';
+import { WorkspaceHandlingTests } from '../../tests-library/WorkspaceHandlingTests';
+import { ProjectAndFileTests } from '../../tests-library/ProjectAndFileTests';
+import { Logger } from '../../utils/Logger';
+import { DriverHelper } from '../../utils/DriverHelper';
+import { CheCodeLocatorLoader } from '../../pageobjects/ide/CheCodeLocatorLoader';
+import { expect } from 'chai';
+import { TimeoutConstants } from '../../constants/TimeoutConstants';
+import { BrowserTabsUtil } from '../../utils/BrowserTabsUtil';
+import { PluginsTestConstants } from '../../constants/PluginsTestConstants';
+import { BaseTestConstants } from '../../constants/BaseTestConstants';
+
+const projectAndFileTests: ProjectAndFileTests = e2eContainer.get(CLASSES.ProjectAndFileTests);
+const workspaceHandlingTests: WorkspaceHandlingTests = e2eContainer.get(CLASSES.WorkspaceHandlingTests);
+const loginTests: LoginTests = e2eContainer.get(CLASSES.LoginTests);
+const driverHelper: DriverHelper = e2eContainer.get(CLASSES.DriverHelper);
+
+const webCheCodeLocators: Locators = new CheCodeLocatorLoader().webCheCodeLocators;
+const samples: string[] = PluginsTestConstants.TS_SAMPLE_LIST.split(',');
+const browserTabsUtil: BrowserTabsUtil = e2eContainer.get(CLASSES.BrowserTabsUtil);
+
+suite(`Check if recommended extensions installed for ${samples}`, async function(): Promise<void> {
+  let projectSection: ViewSection;
+  let extensionsView: SideBarView | undefined;
+  let extensionSection: ExtensionsViewSection;
+
+  const extensionsListFileName: string = 'extensions.json';
+  let recommendedExtensions: any = {
+    recommendations: []
+  };
+
+  loginTests.loginIntoChe();
+
+  for (const sample of samples) {
+    test(`Create and open new workspace, stack:${sample}`, async function(): Promise<void> {
+      await workspaceHandlingTests.createAndOpenWorkspace(sample);
+    });
+    test('Obtain workspace name from workspace loader page', async function(): Promise<void> {
+      await workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
+    });
+
+    test('Registering the running workspace', async function(): Promise<void> {
+      registerRunningWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+    });
+
+    test('Wait workspace readiness', async function(): Promise<void> {
+      await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
+    });
+
+    test('Wait until the project will be imported and accept it as trusted one', async function(): Promise<void> {
+      [projectSection] = await new SideBarView().getContent().getSections();
+      const label: string = BaseTestConstants.TS_SELENIUM_PROJECT_ROOT_FILE_NAME;
+      Logger.debug(`projectSection.findItem: find ${label}`);
+      const isFileImported: ViewItem | undefined = await projectSection.findItem(label);
+      expect(isFileImported).not.eqls(undefined);
+      try {
+        const buttonYesITrustTheAuthors: string = `Yes, I trust the authors`;
+        await driverHelper.waitVisibility(webCheCodeLocators.WelcomeContent.button, TimeoutConstants.TS_DIALOG_WINDOW_DEFAULT_TIMEOUT);
+        const trustedProjectDialog: ModalDialog = new ModalDialog();
+        Logger.debug(`trustedProjectDialog.pushButton: "${buttonYesITrustTheAuthors}"`);
+        await trustedProjectDialog.pushButton(buttonYesITrustTheAuthors);
+      } catch (e) {
+        Logger.debug(`Welcome modal dialog was not shown: ${e}`);
+      }
+    });
+
+    test(`Get recommended extensions list from ${extensionsListFileName}`, async function(): Promise<void> {
+      Logger.debug(`projectSection.findItem(item))?.select(): expand .vscode folder and open extensions.json.`);
+      await (await projectSection.findItem('.vscode'))?.select();
+      // time to expand project tree
+      await driverHelper.wait(TimeoutConstants.TS_EXPAND_PROJECT_TREE_ITEM_TIMEOUT);
+      await (await projectSection.findItem(extensionsListFileName))?.select();
+      Logger.debug(`EditorView().openEditor(${extensionsListFileName})`);
+      const editor: TextEditor = await new EditorView().openEditor(extensionsListFileName) as TextEditor;
+      await driverHelper.waitVisibility(webCheCodeLocators.Editor.inputArea);
+      Logger.debug(`editor.getText(): get recommended extensions as text from editor, delete comments and parse to object.`);
+      recommendedExtensions = JSON.parse((await editor.getText()).replace(/\/\*[\s\S]*?\*\/|(?<=[^:])\/\/.*|^\/\/.*/g, '').trim());
+      Logger.debug(`recommendedExtensions.recommendations: Get recommendations clear names using map().`);
+      recommendedExtensions.recommendations = recommendedExtensions.recommendations.map((r: { split: (arg: string) => [any, any]; }) => {
+        const [publisher, name] = r.split('.');
+        return { publisher, name };
+      });
+      Logger.info(`Recommended extension for this workspace:\n${JSON.stringify(recommendedExtensions.recommendations)}.`);
+    });
+
+    test(`Open "Extensions" view section`, async function(): Promise<void> {
+      Logger.debug(`ActivityBar().getViewControl('Extensions'))?.openView(): open Extensions view.`);
+      extensionsView = await (await new ActivityBar().getViewControl('Extensions'))?.openView();
+    });
+
+    test(`Let extensions complete installation`, async function(): Promise<void> {
+      Logger.info(`Time for extensions installation TimeoutConstants.TS_COMMON_PLUGIN_TEST_TIMEOUT=${TimeoutConstants.TS_COMMON_PLUGIN_TEST_TIMEOUT}`);
+      await driverHelper.wait(TimeoutConstants.TS_COMMON_PLUGIN_TEST_TIMEOUT);
+    });
+
+    test(`Check if extensions are installed and enabled`, async function(): Promise<void> {
+      this.retries(10);
+      Logger.debug(`ActivityBar().getViewControl('Extensions'))?.openView(): open Extensions view.`);
+      extensionsView = await (await new ActivityBar().getViewControl('Extensions'))?.openView();
+
+      Logger.debug(`extensionsView?.getContent().getSections(): get current section.`);
+      [extensionSection] = await extensionsView?.getContent().getSections() as ExtensionsViewSection[];
+      await driverHelper.waitAllPresence(webCheCodeLocators.ExtensionsViewSection.itemTitle, TimeoutConstants.TS_EDITOR_TAB_INTERACTION_TIMEOUT);
+
+      for (const extension of recommendedExtensions.recommendations) {
+        Logger.info(`Check if ${JSON.stringify(extension)} are installed.`);
+
+        Logger.debug(`extensionSection.findItem(${extension.name}).`);
+        await extensionSection.findItem(extension.name);
+
+        // check if extension require reload the page
+        if (await driverHelper.isVisible((webCheCodeLocators.ExtensionsViewSection as any).requireReloadButton)) {
+          Logger.debug(`Extension require reload the editor. Refreshing the page..`);
+          await browserTabsUtil.refreshPage();
+          await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
+          Logger.debug(`ActivityBar().getViewControl('Extensions'))?.openView(): open Extensions view.`);
+          extensionsView = await (await new ActivityBar().getViewControl('Extensions'))?.openView();
+          Logger.debug(`extensionsView?.getContent().getSections(): get current section.`);
+          [extensionSection] = await extensionsView?.getContent().getSections() as ExtensionsViewSection[];
+          await driverHelper.waitAllPresence(webCheCodeLocators.ExtensionsViewSection.itemTitle, TimeoutConstants.TS_EDITOR_TAB_INTERACTION_TIMEOUT);
+          Logger.debug(`extensionSection.findItem(${extension.name}).`);
+          await extensionSection.findItem(extension.name);
+        }
+
+        Logger.debug(`extensionsView?.getContent().getSections(): switch to marketplace section.`);
+        const [marketplaceSection]: ExtensionsViewSection[] = await extensionsView?.getContent().getSections() as ExtensionsViewSection[];
+        await driverHelper.waitVisibility(webCheCodeLocators.ExtensionsViewSection.items, TimeoutConstants.TS_EDITOR_TAB_INTERACTION_TIMEOUT);
+
+        Logger.debug(`marketplaceSection.getVisibleItems(): get all found items.`);
+        const allFinedItems: ExtensionsViewItem[] = await marketplaceSection.getVisibleItems();
+
+        let itemWithRightNameAndPublisher: ExtensionsViewItem | undefined;
+        for (const item of allFinedItems) {
+          Logger.debug(`Try to find extension published by ${extension.publisher}.`);
+          if (await item.getAuthor() === extension.publisher) {
+            itemWithRightNameAndPublisher = item;
+            Logger.debug(`Extension was found: ${await itemWithRightNameAndPublisher?.getTitle()}`);
+            break;
+          }
+          if (itemWithRightNameAndPublisher === undefined) {
+            Logger.error(`Extension with publisher as ${extension.publisher} was not found.`);
+          }
+        }
+
+        Logger.debug(`itemWithRightNameAndPublisher?.isInstalled()`);
+        const isInstalled: boolean = await itemWithRightNameAndPublisher?.isInstalled() as boolean;
+
+        Logger.debug(`itemWithRightNameAndPublisher?.isInstalled(): ${isInstalled}.`);
+        expect(isInstalled).eqls(true);
+
+        Logger.debug(`itemWithRightNameAndPublisher.manage(): get context menu.`);
+        const extensionManageMenu: ContextMenu = await (itemWithRightNameAndPublisher as ExtensionsViewItem).manage();
+
+        Logger.debug(`extensionManageMenu.getItems(): get menu items.`);
+        const extensionMenuItems: ContextMenuItem[] = await extensionManageMenu.getItems();
+        let extensionMenuItemLabels: string = '';
+        for (const item of extensionMenuItems) {
+          Logger.trace(`extensionMenuItems -> item.getLabel(): get menu items names.`);
+          extensionMenuItemLabels += (await item.getLabel()) + ' ';
+        }
+
+        Logger.debug(`extensionMenuItemLabels: ${extensionMenuItemLabels}.`);
+        expect(extensionMenuItemLabels).contains('Disable').and.not.contains('Enable');
+      }
+    });
+
+    test('Stop the workspace', async function(): Promise<void> {
+      await workspaceHandlingTests.stopWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+      await browserTabsUtil.closeAllTabsExceptCurrent();
+    });
+
+    test('Delete the workspace', async function(): Promise<void> {
+      await workspaceHandlingTests.removeWorkspace(WorkspaceHandlingTests.getWorkspaceName());
+    });
+  }
+
+  loginTests.logoutFromChe();
+});