@eclipse-che/che-e2e 7.106.0-next-5d2b584 → 7.106.0-next-45f4fb4

package/pageobjects/ide/CommandPalette.ts

@@ -0,0 +1,114 @@
+/** *******************************************************************
+ * 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 { DriverHelper } from '../../utils/DriverHelper';
+import { Logger } from '../../utils/Logger';
+import { TIMEOUT_CONSTANTS } from '../../constants/TIMEOUT_CONSTANTS';
+
+@injectable()
+export class CommandPalette {
+	private static readonly COMMAND_PALETTE_CONTAINER: By = By.css('.quick-input-widget');
+	private static readonly COMMAND_PALETTE_LIST: By = By.css('#quickInput_list');
+	private static readonly COMMAND_PALETTE_ITEMS: By = By.css('#quickInput_list [role="option"]');
+
+	constructor(
+		@inject(CLASSES.DriverHelper)
+		private readonly driverHelper: DriverHelper
+	) {}
+
+	/**
+	 * open the Command Palette using keyboard shortcut
+	 * tries F1 first, then Ctrl+Shift+P if needed
+	 */
+	async openCommandPalette(): Promise<void> {
+		Logger.debug();
+
+		await this.driverHelper.getDriver().actions().keyDown(Key.F1).keyUp(Key.F1).perform();
+
+		const paletteVisible: boolean = await this.driverHelper.waitVisibilityBoolean(CommandPalette.COMMAND_PALETTE_CONTAINER);
+
+		if (!paletteVisible) {
+			await this.driverHelper
+				.getDriver()
+				.actions()
+				.keyDown(Key.CONTROL)
+				.keyDown(Key.SHIFT)
+				.sendKeys('p')
+				.keyUp(Key.SHIFT)
+				.keyUp(Key.CONTROL)
+				.perform();
+		}
+
+		await this.driverHelper.waitVisibility(CommandPalette.COMMAND_PALETTE_LIST);
+	}
+
+	/**
+	 * search for a command in the Command Palette
+	 *
+	 * @param commandText Text to search for
+	 */
+	async searchCommand(commandText: string): Promise<void> {
+		Logger.debug(`"${commandText}"`);
+
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+		await this.driverHelper.getDriver().actions().sendKeys(commandText).perform();
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+	}
+
+	/**
+	 * get all visible commands in the Command Palette
+	 *
+	 * @returns Array of command texts
+	 */
+	async getVisibleCommands(): Promise<string[]> {
+		Logger.debug();
+
+		const listVisible: boolean = await this.driverHelper.waitVisibilityBoolean(CommandPalette.COMMAND_PALETTE_LIST);
+
+		if (!listVisible) {
+			return [];
+		}
+
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+		const items: WebElement[] = await this.driverHelper.getDriver().findElements(CommandPalette.COMMAND_PALETTE_ITEMS);
+		const itemTexts: string[] = [];
+
+		for (const item of items) {
+			try {
+				const ariaLabel: string = await item.getAttribute('aria-label');
+				if (ariaLabel) {
+					itemTexts.push(ariaLabel);
+				}
+			} catch (err) {
+				// skip items that cannot be read
+			}
+		}
+
+		return itemTexts;
+	}
+
+	async isCommandVisible(commandText: string): Promise<boolean> {
+		Logger.debug(`"${commandText}"`);
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+
+		const availableCommands: string[] = await this.getVisibleCommands();
+		Logger.debug(`Available commands: ${availableCommands.join(', ')}`);
+		return availableCommands.some((command: string): boolean => command.toLowerCase().includes(commandText.toLowerCase()));
+	}
+
+	async closeCommandPalette(): Promise<void> {
+		Logger.debug();
+
+		await this.driverHelper.getDriver().actions().sendKeys(Key.ESCAPE).perform();
+		await this.driverHelper.waitDisappearance(CommandPalette.COMMAND_PALETTE_CONTAINER);
+	}
+}

package/pageobjects/ide/ExplorerView.ts

@@ -0,0 +1,106 @@
+/** *******************************************************************
+ * 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 } from 'selenium-webdriver';
+import { ActivityBar, ViewControl, ViewItem, ViewSection } from 'monaco-page-objects';
+import { DriverHelper } from '../../utils/DriverHelper';
+import { Logger } from '../../utils/Logger';
+import { ProjectAndFileTests } from '../../tests-library/ProjectAndFileTests';
+import { TIMEOUT_CONSTANTS } from '../../constants/TIMEOUT_CONSTANTS';
+
+@injectable()
+export class ExplorerView {
+	private static readonly CONTEXT_MENU_CONTAINER: By = By.css('.monaco-menu-container');
+	private static readonly CONTEXT_MENU_ITEMS: By = By.css('.monaco-menu-container .action-item');
+
+	constructor(
+		@inject(CLASSES.DriverHelper)
+		private readonly driverHelper: DriverHelper,
+		@inject(CLASSES.ProjectAndFileTests)
+		private readonly projectAndFileTests: ProjectAndFileTests
+	) {}
+
+	async openExplorerView(): Promise<void> {
+		Logger.debug();
+
+		const explorerCtrl: ViewControl | undefined = await new ActivityBar().getViewControl('Explorer');
+		await explorerCtrl?.openView();
+	}
+
+	/**
+	 * open the context menu for a file in the Explorer view
+	 *
+	 * @param fileName Name of the file to open context menu for
+	 */
+	async openFileContextMenu(fileName: string): Promise<void> {
+		Logger.debug(`"${fileName}"`);
+
+		await this.openExplorerView();
+
+		const projectSection: ViewSection = await this.projectAndFileTests.getProjectViewSession();
+		const fileItem: ViewItem | undefined = await this.projectAndFileTests.getProjectTreeItem(projectSection, fileName);
+
+		if (!fileItem) {
+			throw new Error(`Could not find ${fileName} file in explorer`);
+		}
+
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+
+		try {
+			await fileItem.openContextMenu();
+			await this.waitContextMenuVisible();
+		} catch (error) {
+			Logger.error(`Context menu failed for "${fileName}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+			throw new Error(`Context menu failed to open for "${fileName}"`);
+		}
+	}
+
+	/**
+	 * check if a specific item is visible in the context menu
+	 *
+	 * @param menuItemAriaLabel Aria label of the menu item to check for
+	 * @returns True if the item is visible
+	 */
+	async isContextMenuItemVisible(menuItemAriaLabel: string): Promise<boolean> {
+		Logger.debug(`"${menuItemAriaLabel}"`);
+
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+
+		const contextMenuItemLocator: By = By.css(`.monaco-menu-container [aria-label="${menuItemAriaLabel}"]`);
+		return await this.driverHelper.waitVisibilityBoolean(contextMenuItemLocator);
+	}
+
+	async closeContextMenu(): Promise<void> {
+		Logger.debug();
+
+		await this.driverHelper.getDriver().actions().sendKeys(Key.ESCAPE).perform();
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+		await this.driverHelper.waitDisappearance(ExplorerView.CONTEXT_MENU_CONTAINER);
+	}
+
+	private async waitContextMenuVisible(): Promise<void> {
+		Logger.debug();
+
+		const containerVisible: boolean = await this.driverHelper.waitVisibilityBoolean(ExplorerView.CONTEXT_MENU_CONTAINER);
+
+		if (!containerVisible) {
+			throw new Error('Context menu container did not appear');
+		}
+
+		await this.driverHelper.wait(TIMEOUT_CONSTANTS.TS_SELENIUM_DEFAULT_POLLING);
+
+		const menuItemsVisible: boolean = await this.driverHelper.waitVisibilityBoolean(ExplorerView.CONTEXT_MENU_ITEMS);
+
+		if (!menuItemsVisible) {
+			throw new Error('Context menu items did not load properly');
+		}
+	}
+}

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/dashboard-samples/RecommendedExtensions.spec.ts

@@ -160,6 +160,7 @@ async function findItem(extSection: ExtensionsViewSection, title: string): Promi
 	Logger.debug(`Extension with title "${searchTitle}" not found in section "${sectionTitle}"`);
 	return undefined;
 }
+
 // get visible items from Extension view, transform this from array to sorted string and compares it with existed recommended extensions
 async function getVisibleFilteredItemsAndCompareWithRecommended(recommendations: string[]): Promise<boolean> {
 	const extensionsView: SideBarView | undefined = await (await new ActivityBar().getViewControl('Extensions'))?.openView();
@@ -180,20 +181,23 @@ async function getVisibleFilteredItemsAndCompareWithRecommended(recommendations:
 	}
 	Logger.debug('marketplaceSection.getVisibleItems()');
 	const allFoundRecommendedItems: ExtensionsViewItem[] = await marketplaceSection.getVisibleItems();
+
 	const allFoundRecommendedAuthors: string[] = await Promise.all(
 		allFoundRecommendedItems.map(async (item: ExtensionsViewItem): Promise<string> => await item.getAuthor())
 	);
 
 	const allFoundAuthorsAsSortedString: string = allFoundRecommendedAuthors.sort().toString();
-	const allPublisherNamesAsSorString: string = recommendations.sort().toString();
-	return allFoundAuthorsAsSortedString === allPublisherNamesAsSorString;
+	const allPublisherNamesAsSortedString: string = recommendations.sort().toString();
+	return allFoundAuthorsAsSortedString === allPublisherNamesAsSortedString;
 }
+
 // get visible items from Extension view, transform this from array to sorted string and compares it with existed installed extensions
 async function getVisibleFilteredItemsAndCompareWithInstalled(recommendations: string[]): Promise<boolean> {
 	const extensionsView: SideBarView | undefined = await (await new ActivityBar().getViewControl('Extensions'))?.openView();
 	const [marketplaceSection]: ExtensionsViewSection[] = (await extensionsView?.getContent().getSections()) as ExtensionsViewSection[];
 	Logger.debug('marketplaceSection.getVisibleItems()');
 	const allFoundRecommendedItems: ExtensionsViewItem[] = await marketplaceSection.getVisibleItems();
+
 	const allFoundRecommendedAuthors: string[] = await Promise.all(
 		allFoundRecommendedItems.map(async (item: ExtensionsViewItem): Promise<string> => await item.getAuthor())
 	);
@@ -203,6 +207,7 @@ async function getVisibleFilteredItemsAndCompareWithInstalled(recommendations: s
 	// in some cases we can have installed not only recommended extensions with some samples (for example .Net)
 	return allFoundAuthorsAsSortedString.includes(allPublisherNamesAsSortString);
 }
+
 for (const sample of samples) {
 	suite(`Check if recommended extensions installed for ${sample} ${BASE_TEST_CONSTANTS.TEST_ENVIRONMENT}`, function (): void {
 		const projectAndFileTests: ProjectAndFileTests = e2eContainer.get(CLASSES.ProjectAndFileTests);
@@ -292,10 +297,29 @@ for (const sample of samples) {
 			recommendedExtensions = JSON.parse(text.replace(/\/\*[\s\S]*?\*\/|(?<=[^:])\/\/.*|^\/\/.*/g, '').trim());
 
 			Logger.debug('recommendedExtensions.recommendations: Get recommendations clear names using map().');
+
+			// skip the test if only redhat.fabric8-analytics extension is found in Dev Spaces 3.22.0 (issue CRW-9186)
+			if (BASE_TEST_CONSTANTS.OCP_VERSION === '3.22.0' && BASE_TEST_CONSTANTS.TESTING_APPLICATION_NAME() === 'devspaces') {
+				const dependencyAnalyticsExtensionName: string = 'redhat.fabric8-analytics';
+				if (
+					recommendedExtensions.recommendations.includes(dependencyAnalyticsExtensionName) &&
+					recommendedExtensions.recommendations.length === 1
+				) {
+					throw new Error(
+						`Only '${dependencyAnalyticsExtensionName}' extension found. This extension will not be installed because of known issue https://issues.redhat.com/browse/CRW-9186`
+					);
+				} else {
+					recommendedExtensions.recommendations = recommendedExtensions.recommendations.filter(
+						(rec: string): boolean => !rec.includes(dependencyAnalyticsExtensionName)
+					);
+				}
+			}
+
 			parsedRecommendations = recommendedExtensions.recommendations.map((rec: string): { name: string; publisher: string } => {
 				const [publisher, name] = rec.split('.');
 				return { publisher, name };
 			});
+
 			Logger.debug(`Recommended extension for this workspace:\n${JSON.stringify(parsedRecommendations)}.`);
 			publisherNames = parsedRecommendations.map((rec: { name: string; publisher: string }): string => rec.publisher);
 			expect(parsedRecommendations, 'Recommendations not found').not.empty;