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

package/utils/workspace/TestWorkspaceUtil.ts

@@ -9,7 +9,7 @@
  **********************************************************************/
 
 import 'reflect-metadata';
-import { injectable, inject } from 'inversify';
+import { inject, injectable } from 'inversify';
 import { DriverHelper } from '../DriverHelper';
 import { WorkspaceStatus } from './WorkspaceStatus';
 import { error } from 'selenium-webdriver';
@@ -23,142 +23,146 @@ import { TimeoutConstants } from '../../constants/TimeoutConstants';
 
 @injectable()
 export class TestWorkspaceUtil implements ITestWorkspaceUtil {
-    readonly polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
-    readonly attempts: number = TimeoutConstants.TS_DASHBOARD_WORKSPACE_STOP_TIMEOUT / this.polling;
+  readonly polling: number = TimeoutConstants.TS_SELENIUM_DEFAULT_POLLING;
+  readonly attempts: number = TimeoutConstants.TS_DASHBOARD_WORKSPACE_STOP_TIMEOUT / this.polling;
 
-    constructor(
-        @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,
-        @inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler,
-        @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver
-    ) { }
+  constructor(
+    @inject(CLASSES.DriverHelper) private readonly driverHelper: DriverHelper,
+    @inject(CLASSES.CheApiRequestHandler) private readonly processRequestHandler: CheApiRequestHandler,
+    @inject(CLASSES.ApiUrlResolver) private readonly apiUrlResolver: ApiUrlResolver
+  ) { }
 
-    async waitWorkspaceStatus(workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.waitWorkspaceStatus');
+  async waitWorkspaceStatus(workspaceName: string, expectedWorkspaceStatus: WorkspaceStatus): Promise<void> {
+    Logger.debug();
 
-        let workspaceStatus: string = '';
-        let expectedStatus: boolean = false;
-        for (let i: number = 0; i < this.attempts; i++) {
-            const response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName));
+    let workspaceStatus: string = '';
+    let expectedStatus: boolean = false;
+    for (let i: number = 0; i < this.attempts; i++) {
+      const response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName));
 
-            if (response.status !== 200) {
-                throw new Error(`Can not get status of a workspace. Code: ${response.status} Data: ${response.data}`);
-            }
+      if (response.status !== 200) {
+        throw new Error(`Can not get status of a workspace. Code: ${response.status} Data: ${response.data}`);
+      }
 
-            workspaceStatus = await response.data.status.phase;
+      workspaceStatus = await response.data.status.phase;
 
-            if (workspaceStatus === expectedWorkspaceStatus) {
-                expectedStatus = true;
-                break;
-            }
+      if (workspaceStatus === expectedWorkspaceStatus) {
+        expectedStatus = true;
+        break;
+      }
 
-            await this.driverHelper.wait(this.polling);
-        }
-
-        if (!expectedStatus) {
-            let waitTime: number = this.attempts * this.polling;
-            throw new error.TimeoutError(`The workspace was not stopped in ${waitTime} ms. Current status is: ${workspaceStatus}`);
-        }
+      await this.driverHelper.wait(this.polling);
     }
 
-    async stopWorkspaceByName(workspaceName: string): Promise<void> {
-        Logger.debug(`TestWorkspaceUtil.stopWorkspaceByName: ${workspaceName}`);
-
-        const stopWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
-        let stopWorkspaceResponse: AxiosResponse;
-
-        try {
-            stopWorkspaceResponse = await this.processRequestHandler.patch(stopWorkspaceApiUrl, [{'op': 'replace', 'path': '/spec/started', 'value': false}]);
-        } catch (err) {
-            Logger.error(`Stop workspace call failed. URL used: ${stopWorkspaceApiUrl}`);
-            throw err;
-        }
-
-        if (stopWorkspaceResponse.status !== 200) {
-            throw new Error(`Cannot stop workspace. Code: ${stopWorkspaceResponse.status} Data: ${stopWorkspaceResponse.data}`);
-        }
-
-        await this.waitWorkspaceStatus(workspaceName, WorkspaceStatus.STOPPED);
-        Logger.debug(`TestWorkspaceUtil.stopWorkspaceByName: ${workspaceName} stopped successfully`);
+    if (!expectedStatus) {
+      let waitTime: number = this.attempts * this.polling;
+      throw new error.TimeoutError(`The workspace was not stopped in ${waitTime} ms. Current status is: ${workspaceStatus}`);
+    }
+  }
+
+  async stopWorkspaceByName(workspaceName: string): Promise<void> {
+    Logger.debug(`${workspaceName}`);
+
+    const stopWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
+    let stopWorkspaceResponse: AxiosResponse;
+
+    try {
+      stopWorkspaceResponse = await this.processRequestHandler.patch(stopWorkspaceApiUrl, [{
+        'op': 'replace',
+        'path': '/spec/started',
+        'value': false
+      }]);
+    } catch (err) {
+      Logger.error(`stop workspace call failed. URL used: ${stopWorkspaceApiUrl}`);
+      throw err;
     }
 
-    // delete a workspace without stopping phase (similar with force deleting)
-    async deleteWorkspaceByName(workspaceName: string): Promise<void> {
-        Logger.debug(`TestWorkspaceUtil.deleteWorkspaceByName: ${workspaceName}` );
-
-        const deleteWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
-        let deleteWorkspaceResponse: AxiosResponse;
-        let deleteWorkspaceStatus: boolean = false;
-        try {
-            deleteWorkspaceResponse = await this.processRequestHandler.delete(deleteWorkspaceApiUrl);
-        } catch (error) {
-            if (axios.isAxiosError(error) && error.response?.status === 404) {
-                Logger.error(`The workspace :${workspaceName} not found`);
-                throw error;
-            }
-            Logger.error(`Delete workspace call failed. URL used: ${deleteWorkspaceStatus}`);
-            throw error;
-        }
-
-        if (deleteWorkspaceResponse.status !== 204) {
-            throw new Error(`Can not delete workspace. Code: ${deleteWorkspaceResponse.status} Data: ${deleteWorkspaceResponse.data}`);
-        }
-
-        for (let i: number = 0; i < this.attempts; i++) {
-            try {
-                deleteWorkspaceResponse = await this.processRequestHandler.get(deleteWorkspaceApiUrl);
-            } catch (error) {
-                if (axios.isAxiosError(error) && error.response?.status === 404) {
-                    deleteWorkspaceStatus = true;
-                    Logger.debug(`TestWorkspaceUtil.stopWorkspaceByName: ${workspaceName} deleted successfully`);
-                    break;
-                }
-            }
-        }
-
-        if (!deleteWorkspaceStatus) {
-            let waitTime: number = this.attempts * this.polling;
-            throw new error.TimeoutError(`The workspace was not deleted in ${waitTime} ms.`);
-        }
+    if (stopWorkspaceResponse.status !== 200) {
+      throw new Error(`Cannot stop workspace. Code: ${stopWorkspaceResponse.status} Data: ${stopWorkspaceResponse.data}`);
     }
 
-    // stop workspace before deleting with checking stopping phase
-    async stopAndDeleteWorkspaceByName(workspaceName: string): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.stopAndDeleteWorkspaceByName');
+    await this.waitWorkspaceStatus(workspaceName, WorkspaceStatus.STOPPED);
+    Logger.debug(`${workspaceName} stopped successfully`);
+  }
+
+  // delete a workspace without stopping phase (similar with force deleting)
+  async deleteWorkspaceByName(workspaceName: string): Promise<void> {
+    Logger.debug(`${workspaceName}`);
+
+    const deleteWorkspaceApiUrl: string = await this.apiUrlResolver.getWorkspaceApiUrl(workspaceName);
+    let deleteWorkspaceResponse: AxiosResponse;
+    let deleteWorkspaceStatus: boolean = false;
+    try {
+      deleteWorkspaceResponse = await this.processRequestHandler.delete(deleteWorkspaceApiUrl);
+    } catch (error) {
+      if (axios.isAxiosError(error) && error.response?.status === 404) {
+        Logger.error(`the workspace :${workspaceName} not found`);
+        throw error;
+      }
+      Logger.error(`delete workspace call failed. URL used: ${deleteWorkspaceStatus}`);
+      throw error;
+    }
 
-        await this.stopWorkspaceByName(workspaceName);
-        await this.deleteWorkspaceByName(workspaceName);
+    if (deleteWorkspaceResponse.status !== 204) {
+      throw new Error(`Can not delete workspace. Code: ${deleteWorkspaceResponse.status} Data: ${deleteWorkspaceResponse.data}`);
     }
 
-    // stop all run workspaces in the namespace
-    async stopAllRunningWorkspaces(namespace: string): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.stopAllRunProjects');
-        let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
-        for (let i: number = 0; i < response.data.items.length; i++) {
-            Logger.info('The project is being stopped: ' +  response.data.items[i].metadata.name);
-            await this.stopWorkspaceByName(response.data.items[i].metadata.name);
+    for (let i: number = 0; i < this.attempts; i++) {
+      try {
+        deleteWorkspaceResponse = await this.processRequestHandler.get(deleteWorkspaceApiUrl);
+      } catch (error) {
+        if (axios.isAxiosError(error) && error.response?.status === 404) {
+          deleteWorkspaceStatus = true;
+          Logger.debug(`${workspaceName} deleted successfully`);
+          break;
         }
+      }
     }
 
-    // stop all run workspaces, check statuses and remove the workspaces
-    async stopAndDeleteAllRunningWorkspaces(namespace: string): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.stopAndDeleteAllRunProjects');
-        let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
-        await this.stopAllRunningWorkspaces(namespace);
-        for (let i: number = 0; i < response.data.items.length; i++) {
-            Logger.info('The project is being deleted: ' +  response.data.items[i].metadata.name);
-            await this.deleteWorkspaceByName(response.data.items[i].metadata.name);
-        }
+    if (!deleteWorkspaceStatus) {
+      let waitTime: number = this.attempts * this.polling;
+      throw new error.TimeoutError(`The workspace was not deleted in ${waitTime} ms.`);
+    }
+  }
+
+  // stop workspace before deleting with checking stopping phase
+  async stopAndDeleteWorkspaceByName(workspaceName: string): Promise<void> {
+    Logger.debug();
+
+    await this.stopWorkspaceByName(workspaceName);
+    await this.deleteWorkspaceByName(workspaceName);
+  }
+
+  // stop all run workspaces in the namespace
+  async stopAllRunningWorkspaces(namespace: string): Promise<void> {
+    Logger.debug();
+    let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
+    for (let i: number = 0; i < response.data.items.length; i++) {
+      Logger.info('the project is being stopped: ' + response.data.items[i].metadata.name);
+      await this.stopWorkspaceByName(response.data.items[i].metadata.name);
     }
+  }
+
+  // stop all run workspaces, check statuses and remove the workspaces
+  async stopAndDeleteAllRunningWorkspaces(namespace: string): Promise<void> {
+    Logger.debug();
+    let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
+    await this.stopAllRunningWorkspaces(namespace);
+    for (let i: number = 0; i < response.data.items.length; i++) {
+      Logger.info('the project is being deleted: ' + response.data.items[i].metadata.name);
+      await this.deleteWorkspaceByName(response.data.items[i].metadata.name);
+    }
+  }
 
-    // stop all run workspaces without stopping and waiting for of 'Stopped' phase
-    // similar with 'force' deleting
-    async deleteAllWorkspaces(namespace: string): Promise<void> {
-        Logger.debug('TestWorkspaceUtil.deleteAllRunProjects');
-        let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
+  // stop all run workspaces without stopping and waiting for of 'Stopped' phase
+  // similar with 'force' deleting
+  async deleteAllWorkspaces(namespace: string): Promise<void> {
+    Logger.debug();
+    let response: AxiosResponse = await this.processRequestHandler.get(await this.apiUrlResolver.getWorkspacesApiUrl());
 
-        for (let i: number = 0; i < response.data.items.length; i++) {
-            Logger.info('The project is being deleted .......: ' +  response.data.items[i].metadata.name);
-            await this.deleteWorkspaceByName(response.data.items[i].metadata.name);
-        }
+    for (let i: number = 0; i < response.data.items.length; i++) {
+      Logger.info('the project is being deleted .......: ' + response.data.items[i].metadata.name);
+      await this.deleteWorkspaceByName(response.data.items[i].metadata.name);
     }
+  }
 }

package/utils/workspace/WorkspaceStatus.ts

@@ -9,7 +9,7 @@
  **********************************************************************/
 
 export enum WorkspaceStatus {
-    RUNNING = 'Running',
-    STOPPED = 'Stopped',
-    STARTING = 'Starting'
+  RUNNING = 'Running',
+  STOPPED = 'Stopped',
+  STARTING = 'Starting'
 }

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

@@ -1,201 +0,0 @@
-/*********************************************************************
- * 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) {
-        workspaceHandlingTests.createAndOpenWorkspace(sample);
-        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();
-});