refactor(notification): extract pure functions for testability

Extract getExtensionState() and buildNotificationContent() as exported
pure functions that can be unit tested without VS Code API mocking.
Add unit tests for both functions.

Co-Authored-By: Claude Opus 4 <noreply@anthropic.com>

Author: FrankLiu4138

src/upgrade/display/notificationManager.ts

@@ -29,6 +29,62 @@ function getNowTs() {
     return Number(new Date()) / 1000;
 }
 
+export type ExtensionState = "up-to-date" | "outdated" | "not-installed";
+
+export interface NotificationContent {
+    message: string;
+    upgradeButtonText: string;
+    fixCVEButtonText: string;
+}
+
+export function getExtensionState(extensionVersion: string | undefined): ExtensionState {
+    if (!extensionVersion) {
+        return "not-installed";
+    }
+    if (semver.gte(extensionVersion, Upgrade.MIN_APPMOD_VERSION)) {
+        return "up-to-date";
+    }
+    return "outdated";
+}
+
+export function buildNotificationContent(
+    issues: UpgradeIssue[],
+    extensionState: ExtensionState,
+): NotificationContent {
+    const cveIssues = issues.filter(
+        (i): i is CveUpgradeIssue => i.reason === UpgradeReason.CVE
+    );
+    const nonCVEIssues = issues.filter(
+        (i) => i.reason !== UpgradeReason.CVE
+    );
+    const hasCVEIssue = cveIssues.length > 0;
+    const isReady = extensionState === "up-to-date";
+
+    const message = hasCVEIssue
+        ? buildCVENotificationMessage(cveIssues, isReady)
+        : buildNotificationMessage(nonCVEIssues[0], isReady);
+
+    let upgradeButtonText: string;
+    let fixCVEButtonText: string;
+
+    switch (extensionState) {
+        case "up-to-date":
+            upgradeButtonText = BUTTON_TEXT_UPGRADE;
+            fixCVEButtonText = BUTTON_TEXT_FIX_CVE;
+            break;
+        case "outdated":
+            upgradeButtonText = BUTTON_TEXT_UPDATE_AND_UPGRADE;
+            fixCVEButtonText = BUTTON_TEXT_UPDATE_AND_FIX_CVE;
+            break;
+        case "not-installed":
+            upgradeButtonText = BUTTON_TEXT_INSTALL_AND_UPGRADE;
+            fixCVEButtonText = BUTTON_TEXT_INSTALL_AND_FIX_CVE;
+            break;
+    }
+
+    return { message, upgradeButtonText, fixCVEButtonText };
+}
+
 class NotificationManager implements IUpgradeIssuesRenderer {
     private hasShown = false;
     private context?: ExtensionContext;
@@ -45,16 +101,6 @@ class NotificationManager implements IUpgradeIssuesRenderer {
                     return;
                 }
 
-                // Filter to only CVE issues and cast to CveUpgradeIssue[]
-                const cveIssues = issues.filter(
-                        (i): i is CveUpgradeIssue => i.reason === UpgradeReason.CVE
-                    );
-                const nonCVEIssues = issues.filter(
-                        (i) => i.reason !== UpgradeReason.CVE
-                    );
-                const hasCVEIssue = cveIssues.length > 0;
-                const issue = hasCVEIssue ? cveIssues[0] : nonCVEIssues[0];
-
                 if (!this.shouldShow()) {
                     return;
                 }
@@ -65,35 +111,26 @@ class NotificationManager implements IUpgradeIssuesRenderer {
                 this.hasShown = true;
 
                 const ext = extensions.getExtension(ExtensionName.APP_MODERNIZATION_UPGRADE_FOR_JAVA);
-                const hasExtension = !!ext;
-                const isExtensionUpToDate = hasExtension
-                    && !!ext.packageJSON?.version
-                    && semver.gte(ext.packageJSON.version, Upgrade.MIN_APPMOD_VERSION);
-                const prompt = buildFixPrompt(issue);
+                const extensionState = getExtensionState(ext?.packageJSON?.version);
+                const { message, upgradeButtonText, fixCVEButtonText } = buildNotificationContent(issues, extensionState);
 
-                let notificationMessage = "";
+                const hasCVEIssue = issues.some(i => i.reason === UpgradeReason.CVE);
+                const issue = hasCVEIssue
+                    ? issues.find((i): i is CveUpgradeIssue => i.reason === UpgradeReason.CVE)!
+                    : issues.find(i => i.reason !== UpgradeReason.CVE)!;
+                const prompt = buildFixPrompt(issue);
 
-                if (hasCVEIssue) {
-                    notificationMessage = buildCVENotificationMessage(cveIssues, isExtensionUpToDate);
-                } else {
-                    notificationMessage = buildNotificationMessage(issue, isExtensionUpToDate);
-                }
-                const upgradeButtonText = isExtensionUpToDate
-                    ? BUTTON_TEXT_UPGRADE
-                    : hasExtension ? BUTTON_TEXT_UPDATE_AND_UPGRADE : BUTTON_TEXT_INSTALL_AND_UPGRADE;
-                const fixCVEButtonText = isExtensionUpToDate
-                    ? BUTTON_TEXT_FIX_CVE
-                    : hasExtension ? BUTTON_TEXT_UPDATE_AND_FIX_CVE : BUTTON_TEXT_INSTALL_AND_FIX_CVE;
                 sendInfo(operationId, {
                     operationName: "java.dependency.upgradeNotification.show",
+                    extensionState,
                 });
 
                 const buttons = hasCVEIssue
                     ? [fixCVEButtonText, BUTTON_TEXT_NOT_NOW]
                     : [upgradeButtonText, BUTTON_TEXT_NOT_NOW];
 
                 const selection = await window.showInformationMessage(
-                        notificationMessage,
+                        message,
                         ...buttons
                     );
                 sendInfo(operationId, {

test/suite/notificationContent.test.ts

@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as assert from "assert";
+import { getExtensionState, buildNotificationContent } from "../../src/upgrade/display/notificationManager";
+import { UpgradeReason, type UpgradeIssue } from "../../src/upgrade/type";
+import { Upgrade } from "../../src/constants";
+
+suite("notificationManager pure functions", () => {
+
+    suite("getExtensionState", () => {
+        test("returns 'not-installed' when version is undefined", () => {
+            assert.strictEqual(getExtensionState(undefined), "not-installed");
+        });
+
+        test("returns 'outdated' when version is below minimum", () => {
+            assert.strictEqual(getExtensionState("1.0.0"), "outdated");
+        });
+
+        test("returns 'up-to-date' when version equals minimum", () => {
+            assert.strictEqual(getExtensionState(Upgrade.MIN_APPMOD_VERSION), "up-to-date");
+        });
+
+        test("returns 'up-to-date' when version is above minimum", () => {
+            assert.strictEqual(getExtensionState("99.0.0"), "up-to-date");
+        });
+    });
+
+    suite("buildNotificationContent", () => {
+        const upgradeIssue: UpgradeIssue = {
+            packageId: "org.springframework.boot:spring-boot-starter",
+            packageDisplayName: "Spring Boot",
+            currentVersion: "2.7.0",
+            name: "spring-boot-starter",
+            reason: UpgradeReason.DEPRECATED,
+            suggestedVersion: { name: "3.2.0", description: "latest stable" },
+        };
+
+        const cveIssue: UpgradeIssue = {
+            packageId: "org.apache.logging.log4j:log4j-core",
+            packageDisplayName: "Log4j",
+            currentVersion: "2.14.0",
+            name: "log4j-core",
+            reason: UpgradeReason.CVE,
+            suggestedVersion: { name: "2.17.1", description: "patched" },
+            severity: "critical",
+            description: "Remote code execution",
+            link: "https://nvd.nist.gov/vuln/detail/CVE-2021-44228",
+        };
+
+        test("shows 'Upgrade Now' when extension is up-to-date", () => {
+            const result = buildNotificationContent([upgradeIssue], "up-to-date");
+            assert.strictEqual(result.upgradeButtonText, "Upgrade Now");
+            assert.strictEqual(result.fixCVEButtonText, "Fix Now");
+        });
+
+        test("shows 'Install Extension and Upgrade' when extension is not installed", () => {
+            const result = buildNotificationContent([upgradeIssue], "not-installed");
+            assert.strictEqual(result.upgradeButtonText, "Install Extension and Upgrade");
+            assert.strictEqual(result.fixCVEButtonText, "Install Extension and Fix");
+        });
+
+        test("shows 'Update Extension and Upgrade' when extension is outdated", () => {
+            const result = buildNotificationContent([upgradeIssue], "outdated");
+            assert.strictEqual(result.upgradeButtonText, "Update Extension and Upgrade");
+            assert.strictEqual(result.fixCVEButtonText, "Update Extension and Fix");
+        });
+
+        test("builds CVE message when CVE issues present", () => {
+            const result = buildNotificationContent([cveIssue], "up-to-date");
+            assert.ok(result.message.includes("CVE"));
+            assert.strictEqual(result.fixCVEButtonText, "Fix Now");
+        });
+
+        test("builds upgrade message when no CVE issues", () => {
+            const result = buildNotificationContent([upgradeIssue], "up-to-date");
+            assert.ok(result.message.includes("Spring Boot"));
+        });
+    });
+});