Add extension activation test case (#2407)

EzioLi01 · web-flow · commit df11864526dc · 2025-09-09T16:21:04.000+08:00
diff --git a/test/smoke/suites/activation.test.ts b/test/smoke/suites/activation.test.ts
@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+
+import { Page } from "playwright";
+import { SmokeTestLogger } from "./helper/smokeTestLogger";
+import { app, screenshots } from "./main";
+import assert = require("assert");
+
+export function startExtensionActivationTests(): void {
+    describe("ExtensionActivationTest", () => {
+        async function initApp(): Promise<Page> {
+            await app.launch();
+            return app.getMainPage();
+        }
+
+        async function dispose() {
+            try {
+                if (this.currentTest?.state === "failed") {
+                    SmokeTestLogger.info("Test failed, taking screenshot ...");
+                    await screenshots.takeScreenshots(
+                        this.currentTest.parent?.title || "Others",
+                        this.currentTest.title.replace(/\s+/g, "_"),
+                    );
+                }
+            } catch (error) {
+                // Log error when screenshot get error, but not throw exception
+                SmokeTestLogger.log(`Error with taking screenshot: ${error}`);
+            }
+
+            try {
+                SmokeTestLogger.info(`Dispose test: "${this.currentTest.title}" ...`);
+                if (app) {
+                    await app.close();
+                }
+            } catch (error) {
+                SmokeTestLogger.error(`Error while dispose: ${error}`);
+            }
+        }
+
+        afterEach(dispose);
+
+        it("Verify extension is activated", async () => {
+            const page = await initApp();
+            const isActivited = await app.getExtension().checkExtensionActivated(page);
+            assert.ok(isActivited, "Extension is not activated. Skip other test cases...");
+        });
+    });
+}
diff --git a/test/smoke/suites/commands.test.ts b/test/smoke/suites/commands.test.ts
@@ -1,52 +1,58 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for details.
 
+import { Page } from "playwright";
 import { SmokeTestLogger } from "./helper/smokeTestLogger";
 import { app, screenshots } from "./main";
 import * as assert from "assert";
 
 export function startCommandPaletteTests(): void {
-    describe("Command palette test", () => {
-        async function initApp(): Promise<void> {
+    describe("CommandPaletteTest", () => {
+        async function initApp(): Promise<Page> {
             await app.launch();
+            return app.getMainPage();
         }
 
-        async function disposeAll() {
+        async function dispose() {
             try {
-                SmokeTestLogger.info("Dispose all ...");
+                if (this.currentTest?.state === "failed") {
+                    SmokeTestLogger.info("Test failed, taking screenshot ...");
+                    await screenshots.takeScreenshots(
+                        this.currentTest.parent?.title || "Others",
+                        this.currentTest.title.replace(/\s+/g, "_"),
+                    );
+                }
+            } catch (error) {
+                // Log error when screenshot get error, but not throw exception
+                SmokeTestLogger.log(`Error with taking screenshot: ${error}`);
+            }
+
+            try {
+                SmokeTestLogger.info(`Dispose test: "${this.currentTest.title}" ...`);
                 if (app) {
-                    SmokeTestLogger.info("Stopping application ...");
                     await app.close();
                 }
             } catch (error) {
-                SmokeTestLogger.error("Error while disposeAll:");
-                SmokeTestLogger.error(error);
+                SmokeTestLogger.error(`Error while dispose: ${error}`);
             }
         }
 
-        afterEach(disposeAll);
+        afterEach(dispose);
 
         it("Verify react native command is visible in command palette", async () => {
-            await initApp();
-            const page = app.getMainPage();
+            const page = await initApp();
 
             const cmdKey = process.platform === "darwin" ? "Meta" : "Control";
-
             await page.keyboard.press(`${cmdKey}+Shift+P`);
             await page.waitForSelector(".quick-input-widget", { timeout: 10000 });
 
             await page.keyboard.type("React Native: Start Packager");
-
             const option = await page.waitForSelector("#quickInput_list .monaco-list-row.focused", {
                 timeout: 30000,
             });
-            const value = await option.getAttribute("aria-label");
 
-            try {
-                assert.ok(value?.includes("React Native: Start Packager"));
-            } catch {
-                await screenshots.takeScreenshots("CommandPaletteTest", "VerifyCommandVisible");
-            }
+            const value = await option.getAttribute("aria-label");
+            assert.ok(value?.includes("React Native: Start Packager"));
         });
     });
 }
diff --git a/test/smoke/suites/helper/application.ts b/test/smoke/suites/helper/application.ts
@@ -14,6 +14,8 @@ export class Application {
     private app: ElectronApplication | null = null;
     private mainPage: Page | null = null;
     private extension: Extension | null = null;
+    private vscodeExecutablePath: string | null = null;
+    private isExtensionActivited: boolean = false;
     private extensionDirectory = path.join(__dirname, "..", "..", ".vscode-test", "extensions");
     private userDataDirectory = path.join(__dirname, "..", "..", ".vscode-test", "temp-user-data");
     private vsixDirectory = path.join(__dirname, "..", "..", "resources", "extension");
@@ -27,8 +29,11 @@ export class Application {
     async launch(): Promise<Page> {
         if (this.mainPage) return this.mainPage;
 
-        const vscodeExecutablePath = await this.downloadVSCodeExecutable();
+        if (!this.vscodeExecutablePath) {
+            throw new Error("VSCode has not been downloaded yet.");
+        }
 
+        const vscodeExecutablePath = this.vscodeExecutablePath;
         const [...args] = resolveCliArgsFromVSCodeExecutablePath(vscodeExecutablePath);
         args.push("--disable-workspace-trust");
         args.push("--no-sandbox");
@@ -59,14 +64,6 @@ export class Application {
             SmokeTestLogger.info("Cannot clean up user data, will try it again in test setup.");
         }
 
-        try {
-            await this.cleanExtensionData();
-        } catch {
-            SmokeTestLogger.info(
-                "Cannot clean up extension data, will try it again in test setup.",
-            );
-        }
-
         if (this.app) {
             await this.app.close();
             this.app = null;
@@ -91,8 +88,9 @@ export class Application {
             utilities.spawnSync(cliPath, args, { stdio: "inherit" });
         }
 
-        this.extension = new Extension();
-        return this.extension;
+        const extension = new Extension();
+        this.extension = extension;
+        return extension;
     }
 
     getMainPage(): Page {
@@ -102,6 +100,28 @@ export class Application {
         return this.mainPage;
     }
 
+    getExtension(): Extension {
+        if (!this.extension) {
+            throw new Error("VSCode has not been launched yet.");
+        }
+        return this.extension;
+    }
+
+    setVSCodeExecutablePath(vscodeExecutablePath: string) {
+        this.vscodeExecutablePath = vscodeExecutablePath;
+    }
+
+    setExtensionStatus(isActivited: boolean) {
+        this.isExtensionActivited = isActivited;
+    }
+
+    getExtensionStatus(): boolean {
+        if (!this.isExtensionActivited) {
+            throw new Error("Cannot get extension status.");
+        }
+        return this.isExtensionActivited;
+    }
+
     async cleanUserData(): Promise<void> {
         if (fs.existsSync(this.userDataDirectory)) {
             SmokeTestLogger.info(
diff --git a/test/smoke/suites/helper/extension.ts b/test/smoke/suites/helper/extension.ts
@@ -1,21 +1,23 @@
-import { app } from "../main";
-import { waitConditionUntil } from "./utilities";
+import { Page } from "playwright";
+import { SmokeTestLogger } from "./smokeTestLogger";
 
 export class Extension {
-    private application = app;
-    private extensionId = "msjsdiag.vscode-react-native";
+    async checkExtensionActivated(page: Page): Promise<boolean> {
+        const prodExtensionId = "msjsdiag.vscode-react-native.togglePackagerItem";
+        const previewExtensionId = "msjsdiag.vscode-react-native-preview.togglePackagerItem";
 
-    async waitForExtensionActive(): Promise<void> {
-        const mainPage = this.application.getMainPage();
-        if (!mainPage) {
-            throw new Error("VSCode must be launched before waiting for extension activation.");
+        try {
+            await page.waitForSelector(`[id="${previewExtensionId}"]`, { timeout: 2000 });
+            SmokeTestLogger.info("React-native-preview extension is activated");
+            return true;
+        } catch {
+            try {
+                await page.waitForSelector(`[id="${prodExtensionId}"]`, { timeout: 2000 });
+                SmokeTestLogger.info("React-native-prod extension is activated");
+                return true;
+            } catch {
+                return false;
+            }
         }
-        await waitConditionUntil(
-            () =>
-                (window as any).vscode?.extensions?.getExtension(this.extensionId)?.isActive ==
-                true,
-            1000,
-            10000,
-        );
     }
 }
diff --git a/test/smoke/suites/main.ts b/test/smoke/suites/main.ts
@@ -12,8 +12,8 @@ startSmokeTests(setUp, cleanUp);
 
 async function setUp(): Promise<void> {
     const vscodeExecutablePath = await app.downloadVSCodeExecutable();
+    await app.setVSCodeExecutablePath(vscodeExecutablePath);
     await app.cleanUserData();
-    await app.cleanExtensionData();
     await app.installExtensionFromVSIX(vscodeExecutablePath);
     await screenshots.prepareScreenshotFolderForPlatform();
 }
diff --git a/test/smoke/suites/smoke.test.ts b/test/smoke/suites/smoke.test.ts
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for details.
 
+import { startExtensionActivationTests } from "./activation.test";
 import { startCommandPaletteTests } from "./commands.test";
 import { SmokeTestLogger } from "./helper/smokeTestLogger";
 import { smokeTestFail } from "./helper/utilities";
@@ -19,7 +20,11 @@ export function startSmokeTests(setup: () => Promise<void>, cleanUp: () => Promi
         SmokeTestLogger.info("Test execution completed.");
     });
 
-    describe("Extension smoke tests", () => {
+    describe("Extension smoke tests", function () {
+        // Using bail, when startExtensionActivationTests() failed, skip other test cases.
+        this.bail(true);
+        startExtensionActivationTests();
+
         startCommandPaletteTests();
     });
 }

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ startSmokeTests(setUp, cleanUp);`
`12`	`12`
`13`	`13`	`async function setUp(): Promise<void> {`
`14`	`14`	`const vscodeExecutablePath = await app.downloadVSCodeExecutable();`
	`15`	`+ await app.setVSCodeExecutablePath(vscodeExecutablePath);`
`15`	`16`	`await app.cleanUserData();`
`16`		`- await app.cleanExtensionData();`
`17`	`17`	`await app.installExtensionFromVSIX(vscodeExecutablePath);`
`18`	`18`	`await screenshots.prepareScreenshotFolderForPlatform();`
`19`	`19`	`}`