@eclipse-che/che-e2e 7.105.0 → 7.106.0-next-2338445

package/pageobjects/ide/ExtensionsView.ts

@@ -0,0 +1,167 @@
+/** *******************************************************************
+ * copyright (c) 2025 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 { inject, injectable } from 'inversify';
+import { CLASSES } from '../../configs/inversify.types';
+import { By, Key, WebElement } from 'selenium-webdriver';
+import { ActivityBar, ExtensionsViewItem, ExtensionsViewSection, SideBarView, ViewControl } from 'monaco-page-objects';
+import { DriverHelper } from '../../utils/DriverHelper';
+import { Logger } from '../../utils/Logger';
+import { ViewsMoreActionsButton } from './ViewsMoreActionsButton';
+import { TIMEOUT_CONSTANTS } from '../../constants/TIMEOUT_CONSTANTS';
+
+@injectable()
+export class ExtensionsView {
+	private static readonly EXTENSIONS_VIEW: By = By.css('.extensions-viewlet');
+	private static readonly MENU_ITEM: By = By.css('.context-view .monaco-menu .action-item');
+	private static readonly SEARCH_BOX: By = By.css('input.monaco-inputbox-input');
+
+	constructor(
+		@inject(CLASSES.DriverHelper)
+		private readonly driverHelper: DriverHelper,
+		@inject(CLASSES.ViewsMoreActionsButton)
+		private readonly viewsMoreActionsButton: ViewsMoreActionsButton
+	) {}
+
+	async openExtensionsView(): Promise<void> {
+		Logger.debug();
+
+		const viewCtrl: ViewControl | undefined = await new ActivityBar().getViewControl('Extensions');
+		await viewCtrl?.openView();
+
+		const extensionsViewVisible: boolean = await this.driverHelper.waitVisibilityBoolean(ExtensionsView.EXTENSIONS_VIEW);
+
+		if (!extensionsViewVisible) {
+			throw new Error('Extensions view could not be opened');
+		}
+	}
+
+	async openMoreActionsMenu(): Promise<void> {
+		Logger.debug();
+
+		await this.viewsMoreActionsButton.clickViewsMoreActionsButton();
+		await this.viewsMoreActionsButton.waitForContextMenu();
+	}
+
+	/**
+	 * get all items in the More Actions menu
+	 *
+	 * @returns Array of menu item texts
+	 */
+	async getMoreActionsMenuItems(): Promise<string[]> {
+		Logger.debug();
+
+		const menuItems: WebElement[] = await this.driverHelper.getDriver().findElements(ExtensionsView.MENU_ITEM);
+		const menuTexts: string[] = [];
+
+		for (const item of menuItems) {
+			try {
+				const text: string = await item.getText();
+				menuTexts.push(text);
+			} catch (err) {
+				// skip items that cannot be read
+			}
+		}
+
+		return menuTexts;
+	}
+
+	/**
+	 * check if a specific item is visible in the More Actions menu
+	 *
+	 * @param menuItemText Text to check for
+	 * @returns True if item is visible
+	 */
+	async isMoreActionsMenuItemVisible(menuItemText: string): Promise<boolean> {
+		Logger.debug(`"${menuItemText}"`);
+
+		const menuItems: string[] = await this.getMoreActionsMenuItems();
+		return menuItems.some((item: string): boolean => item.includes(menuItemText));
+	}
+
+	async closeMoreActionsMenu(): Promise<void> {
+		Logger.debug();
+
+		await this.driverHelper.getDriver().actions().sendKeys(Key.ESCAPE).perform();
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+	}
+
+	/**
+	 * get names of all installed extensions
+	 */
+	async getInstalledExtensionNames(): Promise<string[]> {
+		Logger.debug();
+
+		await this.openExtensionsView();
+
+		const extensionsView: SideBarView | undefined = await (await new ActivityBar().getViewControl('Extensions'))?.openView();
+		if (!extensionsView) {
+			throw new Error('Could not open Extensions view');
+		}
+
+		const [extensionSection]: ExtensionsViewSection[] = (await extensionsView.getContent().getSections()) as ExtensionsViewSection[];
+		if (!extensionSection) {
+			throw new Error('Could not find Extensions section');
+		}
+
+		// search for installed extensions
+		await this.searchInExtensions(extensionSection, '@installed');
+
+		// wait for results to load
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+
+		const installedItems: ExtensionsViewItem[] = await extensionSection.getVisibleItems();
+		const extensionNames: string[] = [];
+
+		for (const item of installedItems) {
+			try {
+				const title: string = await item.getTitle();
+				extensionNames.push(title);
+			} catch (err) {
+				// skip items that cannot be read
+			}
+		}
+
+		Logger.debug(`Found ${extensionNames.length} installed extensions: ${extensionNames.join(', ')}`);
+		return extensionNames;
+	}
+
+	/**
+	 * search for extensions using a search term
+	 *
+	 * @param extensionSection The ExtensionsViewSection to search in
+	 * @param searchText Text to search for
+	 */
+	private async searchInExtensions(extensionSection: ExtensionsViewSection, searchText: string): Promise<void> {
+		Logger.debug(`Searching for: "${searchText}"`);
+
+		const enclosingItem: WebElement = extensionSection.getEnclosingElement();
+
+		try {
+			const searchField: WebElement = await enclosingItem.findElement(ExtensionsView.SEARCH_BOX);
+
+			// clear existing search
+			await this.driverHelper.getDriver().actions().click(searchField).perform();
+			await this.driverHelper
+				.getDriver()
+				.actions()
+				.keyDown(Key.CONTROL)
+				.sendKeys('a')
+				.keyUp(Key.CONTROL)
+				.sendKeys(Key.DELETE)
+				.perform();
+
+			// enter new search text
+			await this.driverHelper.getDriver().actions().sendKeys(searchText).perform();
+			await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+		} catch (err) {
+			Logger.debug(`Could not interact with search field: ${err}`);
+		}
+	}
+}

package/pageobjects/ide/NotificationHandler.ts

@@ -0,0 +1,70 @@
+/** *******************************************************************
+ * copyright (c) 2025 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 { inject, injectable } from 'inversify';
+import { CLASSES } from '../../configs/inversify.types';
+import { By } from 'selenium-webdriver';
+import { DriverHelper } from '../../utils/DriverHelper';
+import { Logger } from '../../utils/Logger';
+import { TIMEOUT_CONSTANTS } from '../../constants/TIMEOUT_CONSTANTS';
+import { WebElement } from 'monaco-page-objects';
+
+@injectable()
+export class NotificationHandler {
+	private static readonly NOTIFICATION_MESSAGE: By = By.css('.notification-list-item-message');
+
+	constructor(
+		@inject(CLASSES.DriverHelper)
+		private readonly driverHelper: DriverHelper
+	) {}
+
+	/**
+	 * check for notifications containing specific text
+	 */
+	async checkForNotification(expectedText: string, timeoutMs: number = TIMEOUT_CONSTANTS.TS_NOTIFICATION_WAIT_TIMEOUT): Promise<boolean> {
+		Logger.debug(`Checking for notification containing: "${expectedText}"`);
+
+		const startTime: number = Date.now();
+
+		if (await this.findInExistingNotifications(expectedText)) {
+			return true;
+		}
+
+		while (Date.now() - startTime < timeoutMs) {
+			if (await this.findInExistingNotifications(expectedText)) {
+				return true;
+			}
+			await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+		}
+
+		Logger.debug(`Notification containing "${expectedText}" not found after ${timeoutMs}ms`);
+		return false;
+	}
+
+	private async findInExistingNotifications(expectedText: string): Promise<boolean> {
+		try {
+			const elements: WebElement[] = await this.driverHelper.getDriver().findElements(NotificationHandler.NOTIFICATION_MESSAGE);
+
+			for (const element of elements) {
+				try {
+					const text: string = await element.getText();
+					if (text && text.toLowerCase().includes(expectedText.toLowerCase())) {
+						Logger.debug(`Found matching notification: "${text}"`);
+						return true;
+					}
+				} catch (err) {
+					// continue to next element
+				}
+			}
+		} catch (err) {
+			// no notifications found
+		}
+		return false;
+	}
+}

package/pageobjects/ide/ViewsMoreActionsButton.ts

@@ -53,4 +53,15 @@ export class ViewsMoreActionsButton {
 
 		return viewsActionsButton;
 	}
+
+	async clickViewsMoreActionsButton(): Promise<void> {
+		Logger.debug();
+		await this.driverHelper.waitAndClick(ViewsMoreActionsButton.VIEWS_AND_MORE_ACTIONS_BUTTON);
+	}
+
+	async waitForContextMenu(): Promise<void> {
+		const cheCodeLocatorLoader: CheCodeLocatorLoader = e2eContainer.get(CLASSES.CheCodeLocatorLoader);
+		const webCheCodeLocators: Locators = cheCodeLocatorLoader.webCheCodeLocators;
+		await this.driverHelper.waitVisibility(webCheCodeLocators.ContextMenu.contextView);
+	}
 }

package/resources/configmap-disable-vsix-installation.yaml

@@ -0,0 +1,22 @@
+kind: ConfigMap
+apiVersion: v1
+metadata:
+  name: vscode-editor-configurations
+  namespace: openshift-devspaces
+  labels:
+    app.kubernetes.io/part-of: che.eclipse.org
+    app.kubernetes.io/component: workspaces-config
+data:
+  configurations.json: |
+    {
+      "extensions.install-from-vsix-enabled": false
+    }
+  settings.json: |
+    {
+      "window.header": "VSIX INSTALL = DISABLED",
+      "window.commandCenter": false,
+      "workbench.colorCustomizations": {
+        "titleBar.activeBackground": "#CCA700",
+        "titleBar.activeForeground": "#ffffff"
+      }
+    }

package/resources/configmap-enable-vsix-installation.yaml

@@ -0,0 +1,22 @@
+kind: ConfigMap
+apiVersion: v1
+metadata:
+  name: vscode-editor-configurations
+  namespace: openshift-devspaces
+  labels:
+    app.kubernetes.io/part-of: che.eclipse.org
+    app.kubernetes.io/component: workspaces-config
+data:
+  configurations.json: |
+    {
+      "extensions.install-from-vsix-enabled": true
+    }
+  settings.json: |
+    {
+      "window.header": "VSIX INSTALL = ENABLED",
+      "window.commandCenter": false,
+      "workbench.colorCustomizations": {
+        "titleBar.activeBackground": "#CCA700",
+        "titleBar.activeForeground": "#ffffff"
+      }
+    }

package/resources/default-extensions-configmap.yaml

@@ -0,0 +1,12 @@
+kind: ConfigMap
+apiVersion: v1
+metadata:
+  name: default-extensions
+  namespace: admin-devspaces
+  labels:
+    controller.devfile.io/mount-to-devworkspace: 'true'
+    controller.devfile.io/watch-configmap: 'true'
+  annotations:
+    controller.devfile.io/mount-as: env
+data:
+  DEFAULT_EXTENSIONS: '/projects/web-nodejs-sample-with-disabled-vsix/redhat.vscode-yaml-1.17.0.vsix'

package/specs/miscellaneous/VsixInstallationDisableTest.spec.ts

@@ -0,0 +1,243 @@
+/** *******************************************************************
+ * copyright (c) 2025 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 'reflect-metadata';
+import { e2eContainer } from '../../configs/inversify.config';
+import { CLASSES, TYPES } from '../../configs/inversify.types';
+import { expect } from 'chai';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { WorkspaceHandlingTests } from '../../tests-library/WorkspaceHandlingTests';
+import { ProjectAndFileTests } from '../../tests-library/ProjectAndFileTests';
+import { LoginTests } from '../../tests-library/LoginTests';
+import { registerRunningWorkspace } from '../MochaHooks';
+
+import { KubernetesCommandLineToolsExecutor } from '../../utils/KubernetesCommandLineToolsExecutor';
+import { ShellExecutor } from '../../utils/ShellExecutor';
+import { ITestWorkspaceUtil } from '../../utils/workspace/ITestWorkspaceUtil';
+
+import { Dashboard } from '../../pageobjects/dashboard/Dashboard';
+import { NotificationHandler } from '../../pageobjects/ide/NotificationHandler';
+import { CommandPalette } from '../../pageobjects/ide/CommandPalette';
+import { ExtensionsView } from '../../pageobjects/ide/ExtensionsView';
+import { ExplorerView } from '../../pageobjects/ide/ExplorerView';
+
+import { DriverHelper } from '../../utils/DriverHelper';
+import { BrowserTabsUtil } from '../../utils/BrowserTabsUtil';
+import { BASE_TEST_CONSTANTS } from '../../constants/BASE_TEST_CONSTANTS';
+import { Logger } from '../../utils/Logger';
+
+suite(`Verify VSIX installation can be disabled via configuration ${BASE_TEST_CONSTANTS.TEST_ENVIRONMENT}`, function (): void {
+	const workspaceHandlingTests: WorkspaceHandlingTests = e2eContainer.get(CLASSES.WorkspaceHandlingTests);
+	const projectAndFileTests: ProjectAndFileTests = e2eContainer.get(CLASSES.ProjectAndFileTests);
+	const loginTests: LoginTests = e2eContainer.get(CLASSES.LoginTests);
+	const kubernetesCommandLineToolsExecutor: KubernetesCommandLineToolsExecutor = e2eContainer.get(
+		CLASSES.KubernetesCommandLineToolsExecutor
+	);
+	const shellExecutor: ShellExecutor = e2eContainer.get(CLASSES.ShellExecutor);
+	const testWorkspaceUtil: ITestWorkspaceUtil = e2eContainer.get(TYPES.WorkspaceUtil);
+	const dashboard: Dashboard = e2eContainer.get(CLASSES.Dashboard);
+	const driverHelper: DriverHelper = e2eContainer.get(CLASSES.DriverHelper);
+	const browserTabsUtil: BrowserTabsUtil = e2eContainer.get(CLASSES.BrowserTabsUtil);
+	const notificationHandler: NotificationHandler = e2eContainer.get(CLASSES.NotificationHandler);
+	const commandPalette: CommandPalette = e2eContainer.get(CLASSES.CommandPalette);
+	const extensionsView: ExtensionsView = e2eContainer.get(CLASSES.ExtensionsView);
+	const explorerView: ExplorerView = e2eContainer.get(CLASSES.ExplorerView);
+
+	const TEST_REPO_URL: string = 'https://github.com/crw-qe/web-nodejs-sample-with-disabled-vsix/tree/install-from-vsix-disabled-7-100';
+	const RESOURCES_PATH: string = path.join(__dirname, '../../../resources');
+	const DEFAULT_EXTENSIONS: string[] = ['YAML'];
+	const VSIX_FILE_NAME: string = 'redhat.vscode-yaml-1.17.0.vsix';
+
+	const CONFIG_MAP_NAMES: { VSIX_CONFIG: string; DEFAULT_EXTENSIONS: string } = {
+		VSIX_CONFIG: 'vscode-editor-configurations',
+		DEFAULT_EXTENSIONS: 'default-extensions'
+	};
+	const CONFIG_MAP_NAMESPACES: { VSIX_CONFIG: string; DEFAULT_EXTENSIONS: string } = {
+		VSIX_CONFIG: 'openshift-devspaces',
+		DEFAULT_EXTENSIONS: 'admin-devspaces'
+	};
+	const CONFIG_FILES: { ENABLE_VSIX: string; DEFAULT_EXTENSIONS: string; DISABLE_VSIX: string } = {
+		DISABLE_VSIX: 'configmap-disable-vsix-installation.yaml',
+		ENABLE_VSIX: 'configmap-enable-vsix-installation.yaml',
+		DEFAULT_EXTENSIONS: 'default-extensions-configmap.yaml'
+	};
+
+	let workspaceName: string = '';
+
+	function applyConfigMap(configFileName: string): void {
+		const configPath: string = path.join(RESOURCES_PATH, configFileName);
+		const configContent: string = fs.readFileSync(configPath, 'utf8');
+		shellExecutor.executeCommand(`oc apply -f - <<EOF\n${configContent}\nEOF`);
+	}
+
+	function cleanupConfigMaps(): void {
+		Logger.debug(`Deleting ConfigMap ${CONFIG_MAP_NAMES.VSIX_CONFIG} from namespace ${CONFIG_MAP_NAMESPACES.VSIX_CONFIG}`);
+		shellExecutor.executeCommand(
+			`oc delete configmap ${CONFIG_MAP_NAMES.VSIX_CONFIG} -n ${CONFIG_MAP_NAMESPACES.VSIX_CONFIG} --ignore-not-found=true`
+		);
+
+		Logger.debug(
+			`Deleting ConfigMap ${CONFIG_MAP_NAMES.DEFAULT_EXTENSIONS} from namespace ${CONFIG_MAP_NAMESPACES.DEFAULT_EXTENSIONS}`
+		);
+		shellExecutor.executeCommand(
+			`oc delete configmap ${CONFIG_MAP_NAMES.DEFAULT_EXTENSIONS} -n ${CONFIG_MAP_NAMESPACES.DEFAULT_EXTENSIONS} --ignore-not-found=true`
+		);
+	}
+
+	// ========== Test Execution ==========
+
+	suiteSetup('Login to cluster and setup initial state', function (): void {
+		kubernetesCommandLineToolsExecutor.loginToOcp();
+		cleanupConfigMaps();
+	});
+
+	suiteSetup('Login to application', async function (): Promise<void> {
+		await loginTests.loginIntoChe();
+	});
+
+	test('Apply ConfigMaps that disable VSIX and set default extensions', function (): void {
+		applyConfigMap(CONFIG_FILES.DISABLE_VSIX);
+		applyConfigMap(CONFIG_FILES.DEFAULT_EXTENSIONS);
+	});
+
+	test('Create and open workspace from Git repository', async function (): Promise<void> {
+		await workspaceHandlingTests.createAndOpenWorkspaceFromGitRepository(TEST_REPO_URL);
+		await workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
+		workspaceName = WorkspaceHandlingTests.getWorkspaceName();
+		registerRunningWorkspace(workspaceName);
+	});
+
+	test('Wait workspace readiness', async function (): Promise<void> {
+		await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
+	});
+
+	test('Verify VSIX disabled notifications', async function (): Promise<void> {
+		const hasDisableNotification: boolean = await notificationHandler.checkForNotification('install from vsix command is disabled');
+		expect(hasDisableNotification).to.be.true;
+	});
+
+	test('Perform trust author dialog', async function (): Promise<void> {
+		await projectAndFileTests.performTrustAuthorDialog();
+	});
+
+	test('Verify VSIX installation is disabled in UI and extensions are not installed', async function (): Promise<void> {
+		// check Command Palette
+		await commandPalette.openCommandPalette();
+		await commandPalette.searchCommand('Install from VSIX');
+		const commandAvailable: boolean = await commandPalette.isCommandVisible('Extensions: Install from VSIX...');
+		await commandPalette.closeCommandPalette();
+		expect(commandAvailable).to.equal(false, 'Command Palette should not contain Install from VSIX command');
+
+		// check Extensions view menu
+		await extensionsView.openExtensionsView();
+		await extensionsView.openMoreActionsMenu();
+		const extensionMenuAvailable: boolean = await extensionsView.isMoreActionsMenuItemVisible('Install from VSIX');
+		await extensionsView.closeMoreActionsMenu();
+		expect(extensionMenuAvailable).to.equal(false, 'Extensions view should not contain Install from VSIX action');
+
+		// check Explorer context menu
+		await explorerView.openFileContextMenu(VSIX_FILE_NAME);
+		const contextMenuAvailable: boolean = await explorerView.isContextMenuItemVisible('Install Extension VSIX');
+		await explorerView.closeContextMenu();
+		expect(contextMenuAvailable).to.equal(false, 'Explorer context menu should not contain Install Extension VSIX action');
+
+		// verify default extensions are not auto-installed
+		await extensionsView.openExtensionsView();
+		const installedExtensions: string[] = await extensionsView.getInstalledExtensionNames();
+
+		Logger.debug(`Found installed extensions: ${installedExtensions.join(', ')}`);
+
+		for (const extensionName of DEFAULT_EXTENSIONS) {
+			const isInstalled: boolean = installedExtensions.some((installed: string): boolean =>
+				installed.toLowerCase().includes(extensionName.toLowerCase())
+			);
+			expect(isInstalled).to.equal(false, `Default VSIX extension "${extensionName}" should not be auto-installed`);
+		}
+	});
+
+	test('Enable VSIX installation and create new workspace', async function (): Promise<void> {
+		// clean up current workspace
+		await dashboard.openDashboard();
+		await testWorkspaceUtil.deleteWorkspaceByName(workspaceName);
+		registerRunningWorkspace('');
+
+		// apply ConfigMaps that enable VSIX and set default extensions
+		applyConfigMap(CONFIG_FILES.ENABLE_VSIX);
+		applyConfigMap(CONFIG_FILES.DEFAULT_EXTENSIONS);
+
+		Logger.info('Waiting for new ConfigMap settings to take effect...');
+		await driverHelper.wait(30000);
+
+		// create new workspace
+		await workspaceHandlingTests.createAndOpenWorkspaceFromGitRepository(TEST_REPO_URL);
+		await workspaceHandlingTests.obtainWorkspaceNameFromStartingPage();
+		workspaceName = WorkspaceHandlingTests.getWorkspaceName();
+		registerRunningWorkspace(workspaceName);
+	});
+
+	test('Wait workspace readiness', async function (): Promise<void> {
+		await projectAndFileTests.waitWorkspaceReadinessForCheCodeEditor();
+	});
+
+	test('Verify default extension installation success notifications', async function (): Promise<void> {
+		const hasSuccessNotification: boolean = await notificationHandler.checkForNotification('Completed installing extension');
+		expect(hasSuccessNotification).to.be.true;
+	});
+
+	test('Perform trust author dialog', async function (): Promise<void> {
+		await projectAndFileTests.performTrustAuthorDialog();
+	});
+
+	test('Verify VSIX installation is enabled in UI and extensions are installed', async function (): Promise<void> {
+		// check Command Palette
+		await commandPalette.openCommandPalette();
+		await commandPalette.searchCommand('Install from VSIX');
+		const commandAvailable: boolean = await commandPalette.isCommandVisible('Extensions: Install from VSIX...');
+		await commandPalette.closeCommandPalette();
+		expect(commandAvailable).to.equal(true, 'Command Palette should contain Install from VSIX command');
+
+		// check Extensions view menu
+		await extensionsView.openExtensionsView();
+		await extensionsView.openMoreActionsMenu();
+		const extensionMenuAvailable: boolean = await extensionsView.isMoreActionsMenuItemVisible('Install from VSIX');
+		await extensionsView.closeMoreActionsMenu();
+		expect(extensionMenuAvailable).to.equal(true, 'Extensions view should contain Install from VSIX action');
+
+		// check Explorer context menu
+		await explorerView.openFileContextMenu(VSIX_FILE_NAME);
+		const contextMenuAvailable: boolean = await explorerView.isContextMenuItemVisible('Install Extension VSIX');
+		await explorerView.closeContextMenu();
+		expect(contextMenuAvailable).to.equal(true, 'Explorer context menu should contain Install Extension VSIX action');
+
+		// verify default extensions are auto-installed when VSIX enabled
+		await extensionsView.openExtensionsView();
+		const installedExtensions: string[] = await extensionsView.getInstalledExtensionNames();
+
+		Logger.debug(`Found installed extensions: ${installedExtensions.join(', ')}`);
+
+		for (const extensionName of DEFAULT_EXTENSIONS) {
+			const isInstalled: boolean = installedExtensions.some((installed: string): boolean =>
+				installed.toLowerCase().includes(extensionName.toLowerCase())
+			);
+			expect(isInstalled).to.equal(true, `Default VSIX extension "${extensionName}" should be auto-installed`);
+		}
+	});
+
+	suiteTeardown('Clean up ConfigMaps and workspace', async function (): Promise<void> {
+		cleanupConfigMaps();
+		await dashboard.openDashboard();
+		await browserTabsUtil.closeAllTabsExceptCurrent();
+		await testWorkspaceUtil.stopAndDeleteWorkspaceByName(workspaceName);
+		registerRunningWorkspace('');
+		Logger.info('Cleanup completed');
+	});
+});