Add a messege to inform user Merge view can be closed after merge

mguzmanm · mguzmanm · commit 67b0c9f773cf · 2026-04-23T16:26:25.000+02:00
diff --git a/src/desktop/extension.ts b/src/desktop/extension.ts
@@ -222,7 +222,7 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
     const treeViewProviderImpl = new TreeViewProviderImpl(SolutionOutlineView.treeViewId);
     const treeViewFileDecorationProvider = new TreeViewFileDecorationProvider(fileDecorationProviderManager, themeProvider);
     const mergeSessionCoordinator = new MergeSessionCoordinatorImpl(commandsProvider);
-    const mergeCommand = new MergeCommand(commandsProvider, mergeSessionCoordinator);
+    const mergeCommand = new MergeCommand(commandsProvider, mergeSessionCoordinator, messageProvider);
     const buildCommand = new BuildCommand(buildTaskProvider, commandsProvider, buildTaskDefinitionBuilder);
     const runGeneratorCommand = new GeneratorCommand(commandsProvider, solutionManager, outputChannelProvider, cmsisToolboxManager);
     const armclangDefineGetter = new ArmclangDefineGetter(processManager, workspaceFsProvider);
diff --git a/src/views/solution-outline/commands/merge-command.test.ts b/src/views/solution-outline/commands/merge-command.test.ts
@@ -17,6 +17,7 @@
 jest.mock('vscode', () => ({
     window: {
         showErrorMessage: jest.fn(),
+        showInformationMessage: jest.fn(),
         showWarningMessage: jest.fn(),
     }
 }));
@@ -32,7 +33,6 @@ jest.mock('path', () => {
 });
 
 import { TestDataHandler } from '../../../__test__/test-data';
-import * as vscode from 'vscode';
 import { extensionContextFactory } from '../../../vscode-api/extension-context.factories';
 import { commandsProviderFactory, MockCommandsProvider } from '../../../vscode-api/commands-provider.factories';
 import { MergeCommand } from './merge-command';
@@ -42,6 +42,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as fsUtils from '../../../utils/fs-utils';
 import { MergeSessionCoordinator } from './merge-session-coordinator';
+import { messageProviderFactory, MockMessageProvider } from '../../../vscode-api/message-provider.factories';
 
 jest.mock('child_process');
 jest.mock('os');
@@ -50,6 +51,7 @@ describe('MergeCommand', () => {
     let commandsProvider: MockCommandsProvider;
     let command: MergeCommand;
     let mergeSessionCoordinator: jest.Mocked<MergeSessionCoordinator>;
+    let messageProvider: MockMessageProvider;
     const testDataHandler = new TestDataHandler();
     let tmpDir: string;
 
@@ -82,11 +84,13 @@ describe('MergeCommand', () => {
         commandsProvider = commandsProviderFactory();
         mergeSessionCoordinator = {
             activate: jest.fn().mockResolvedValue(),
+            onMergeApplied: jest.fn().mockReturnValue({ dispose: jest.fn() }),
             startSession: jest.fn(),
             cancelSession: jest.fn(),
-            onMergeProcessExit: jest.fn().mockResolvedValue(),
+            onMergeProcessExit: jest.fn().mockResolvedValue({ applied: false }),
         };
-        command = new MergeCommand(commandsProvider, mergeSessionCoordinator);
+        messageProvider = messageProviderFactory();
+        command = new MergeCommand(commandsProvider, mergeSessionCoordinator, messageProvider);
 
         componentNode = new COutlineItem('component');
         componentNode.setTag('component');
@@ -106,10 +110,23 @@ describe('MergeCommand', () => {
             await command.activate(extensionContextFactory());
 
             expect(mergeSessionCoordinator.activate).toHaveBeenCalledTimes(1);
+            expect(mergeSessionCoordinator.onMergeApplied).toHaveBeenCalledTimes(1);
             expect(commandsProvider.registerCommand).toHaveBeenCalledTimes(1);
             expect(commandsProvider.registerCommand).toHaveBeenCalledWith(MergeCommand.mergeFile, expect.any(Function), expect.anything());
         });
 
+        it('shows success info when coordinator emits merge-applied event', async () => {
+            await command.activate(extensionContextFactory());
+
+            const listener = mergeSessionCoordinator.onMergeApplied.mock.calls[0]?.[0] as (() => void) | undefined;
+            expect(listener).toBeDefined();
+            listener?.();
+
+            expect(messageProvider.showInformationMessage).toHaveBeenCalledWith(
+                'Merge applied successfully. Merge View can be closed.',
+            );
+        });
+
         it('forwards string command argument to the merge handler', async () => {
             const runVSCodeMergeFromPathSpy = jest.spyOn(
                 command as unknown as { runVSCodeMergeFromPath: (localPath: string) => Promise<void> },
@@ -136,22 +153,18 @@ describe('MergeCommand', () => {
         });
 
         it('shows error for unsupported command argument type', async () => {
-            const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
-
             await command.activate(extensionContextFactory());
             await commandsProvider.mockRunRegistered(MergeCommand.mergeFile, undefined);
 
-            expect(showErrorMessageSpy).toHaveBeenCalledWith('Cannot open merge view: unsupported command argument.');
+            expect(messageProvider.showErrorMessage).toHaveBeenCalledWith('Cannot open merge view: unsupported command argument.');
         });
     });
 
     describe('merge file discovery', () => {
         it('shows error if merge path is missing when invoked from path', async () => {
-            const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
-
             await command['runVSCodeMergeFromPath']('');
 
-            expect(showErrorMessageSpy).toHaveBeenCalledWith('Cannot open merge view: merge file path is missing.');
+            expect(messageProvider.showErrorMessage).toHaveBeenCalledWith('Cannot open merge view: merge file path is missing.');
         });
 
         it('normalizes the merge path before opening merge view from path', async () => {
@@ -167,17 +180,15 @@ describe('MergeCommand', () => {
         });
 
         it('shows error if node is not passed', async () => {
-            const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
             // @ts-expect-error - testing behavior when `runVSCodeMerge` receives null
             await command['runVSCodeMerge'](null);
-            expect(showErrorMessageSpy).toHaveBeenCalledWith('File data is not available for merge operation.');
+            expect(messageProvider.showErrorMessage).toHaveBeenCalledWith('File data is not available for merge operation.');
         });
 
         it('shows error if required local file is missing', async () => {
-            const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
             const node = new COutlineItem('file');
             await command['runVSCodeMerge'](node);
-            expect(showErrorMessageSpy).toHaveBeenCalledWith('Required local file is missing to perform merge.');
+            expect(messageProvider.showErrorMessage).toHaveBeenCalledWith('Required local file is missing to perform merge.');
         });
 
         it('finds update and base files using the highest matching semver sibling', () => {
@@ -338,9 +349,8 @@ describe('MergeCommand', () => {
                 throw new Error('not found');
             });
 
-            const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
             await command['runVSCodeMerge'](fileNode);
-            expect(showErrorMessageSpy).toHaveBeenCalledWith('Visual Studio Code executable not found. Please ensure it is installed and available in your PATH.');
+            expect(messageProvider.showErrorMessage).toHaveBeenCalledWith('Visual Studio Code executable not found. Please ensure it is installed and available in your PATH.');
         });
     });
 
@@ -375,10 +385,9 @@ describe('MergeCommand', () => {
             mockedExec.mockImplementation((_cmd, _cb) => { throw new Error('unexpected'); });
 
             const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-            const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
             await command['runVSCodeMerge'](fileNode);
             expect(errorSpy).toHaveBeenCalledWith('Merge operations failed:', expect.any(Error));
-            expect(showErrorMessageSpy).toHaveBeenCalledWith('Merge operation failed: unexpected');
+            expect(messageProvider.showErrorMessage).toHaveBeenCalledWith('Merge operation failed: unexpected');
             expect(mergeSessionCoordinator.cancelSession).toHaveBeenCalledTimes(1);
         });
 
@@ -400,11 +409,9 @@ describe('MergeCommand', () => {
             jest.spyOn(fsUtils, 'copyFile').mockImplementation(() => { });
             jest.spyOn(fsUtils, 'getFileModificationTime').mockReturnValue(1000);
 
-            const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
-
             await command['runVSCodeMerge'](node);
 
-            expect(showErrorMessageSpy).toHaveBeenCalledWith('Merge operation failed: Invalid update file: contains unsupported shell-sensitive characters.');
+            expect(messageProvider.showErrorMessage).toHaveBeenCalledWith('Merge operation failed: Invalid update file: contains unsupported shell-sensitive characters.');
             expect(mergeSessionCoordinator.cancelSession).toHaveBeenCalledTimes(1);
         });
 
@@ -441,5 +448,6 @@ describe('MergeCommand', () => {
             expect(mergeSessionCoordinator.onMergeProcessExit).toHaveBeenCalledWith(0);
             expect(mergeSessionCoordinator.cancelSession).not.toHaveBeenCalled();
         });
+
     });
 });
diff --git a/src/views/solution-outline/commands/merge-command.ts b/src/views/solution-outline/commands/merge-command.ts
@@ -25,19 +25,25 @@ import semver from 'semver';
 import { extractVersion } from '../../../utils/string-utils';
 import * as fsUtils from '../../../utils/fs-utils';
 import { MergeSessionCoordinator } from './merge-session-coordinator';
+import type { MessageProvider } from '../../../vscode-api/message-provider';
 
 export class MergeCommand {
     public static readonly mergeFile = `${PACKAGE_NAME}.mergeFile`;
+    private static readonly mergeAppliedSuccessMessage = 'Merge applied successfully. Merge View can be closed.';
     private static readonly disallowedCmdChars = /[\r\n&|<>^%"']/;
 
     constructor(
         private readonly commandsProvider: CommandsProvider,
         private readonly mergeSessionCoordinator: MergeSessionCoordinator,
+        private readonly messageProvider: Pick<MessageProvider, 'showErrorMessage' | 'showInformationMessage' | 'showWarningMessage'>,
     ) { }
 
     public async activate(context: Pick<vscode.ExtensionContext, 'subscriptions'>) {
         await this.mergeSessionCoordinator.activate(context);
         context.subscriptions.push(
+            this.mergeSessionCoordinator.onMergeApplied(() => {
+                this.messageProvider.showInformationMessage(MergeCommand.mergeAppliedSuccessMessage);
+            }),
             this.commandsProvider.registerCommand(MergeCommand.mergeFile, this.handleMergeCommand, this),
         );
     }
@@ -53,12 +59,12 @@ export class MergeCommand {
             return;
         }
 
-        vscode.window.showErrorMessage('Cannot open merge view: unsupported command argument.');
+        this.messageProvider.showErrorMessage('Cannot open merge view: unsupported command argument.');
     }
 
     private async runVSCodeMergeFromPath(localPath: string): Promise<void> {
         if (!localPath) {
-            vscode.window.showErrorMessage('Cannot open merge view: merge file path is missing.');
+            this.messageProvider.showErrorMessage('Cannot open merge view: merge file path is missing.');
             return;
         }
 
@@ -67,13 +73,13 @@ export class MergeCommand {
 
     private async runVSCodeMerge(node: COutlineItem): Promise<void> {
         if (!node) {
-            vscode.window.showErrorMessage('File data is not available for merge operation.');
+            this.messageProvider.showErrorMessage('File data is not available for merge operation.');
             return;
         }
 
         const localPath = node.getResourcePath();
         if (!localPath) {
-            vscode.window.showErrorMessage('Required local file is missing to perform merge.');
+            this.messageProvider.showErrorMessage('Required local file is missing to perform merge.');
             return;
         }
 
@@ -90,7 +96,7 @@ export class MergeCommand {
 
         const codePath = this.getVSCodeExecutablePath();
         if (!codePath) {
-            vscode.window.showErrorMessage('Visual Studio Code executable not found. Please ensure it is installed and available in your PATH.');
+            this.messageProvider.showErrorMessage('Visual Studio Code executable not found. Please ensure it is installed and available in your PATH.');
             return;
         }
 
@@ -130,7 +136,7 @@ export class MergeCommand {
         } catch (err) {
             console.error('Merge operations failed:', err);
             const details = err instanceof Error ? err.message : String(err);
-            vscode.window.showErrorMessage(`Merge operation failed: ${details}`);
+            this.messageProvider.showErrorMessage(`Merge operation failed: ${details}`);
         } finally {
             if (!exitHandled) {
                 this.mergeSessionCoordinator.cancelSession();
@@ -143,13 +149,13 @@ export class MergeCommand {
         const discovered = this.findNewestMergeFiles(local);
         const update = discovered.update;
         if (!update) {
-            vscode.window.showErrorMessage('Required update file is missing to perform merge.');
+            this.messageProvider.showErrorMessage('Required update file is missing to perform merge.');
             return undefined;
         }
 
         const base = discovered.base;
         if (!base) {
-            vscode.window.showErrorMessage('Required base file is missing to perform merge.');
+            this.messageProvider.showErrorMessage('Required base file is missing to perform merge.');
             return undefined;
         }
 
@@ -193,7 +199,7 @@ export class MergeCommand {
                 const resolved = execSync('which code', { stdio: ['pipe', 'pipe', 'ignore'] }).toString().trim();
                 if (resolved && fsUtils.fileExists(resolved)) return resolved;
             } catch (err) {
-                vscode.window.showWarningMessage(`Could not resolve 'code' binary via 'which': ${err instanceof Error ? err.message : String(err)}`);
+                this.messageProvider.showWarningMessage(`Could not resolve 'code' binary via 'which': ${err instanceof Error ? err.message : String(err)}`);
                 return undefined;
             }
         }
diff --git a/src/views/solution-outline/commands/merge-session-coordinator.test.ts b/src/views/solution-outline/commands/merge-session-coordinator.test.ts
@@ -81,6 +81,29 @@ describe('MergeSessionCoordinator', () => {
         expect(commandsProvider.executeCommand).toHaveBeenCalledWith(REFRESH_COMMAND_ID);
     });
 
+    it('emits merge-applied event on merged file save', async () => {
+        const local = path.join(tmpDir, 'component.c');
+        const update = path.join(tmpDir, 'component.c.update@1.0.0');
+        const base = path.join(tmpDir, 'component.c.base@1.0.0');
+        const merged = `${local}.merged`;
+
+        fsUtils.writeTextFile(local, '// local\n');
+        fsUtils.writeTextFile(update, '// update\n');
+        fsUtils.writeTextFile(base, '// base\n');
+        fsUtils.writeTextFile(merged, '// merged\n');
+
+        const listener = jest.fn();
+        const disposable = coordinator.onMergeApplied(listener);
+        coordinator.startSession({ local, update, base, merged, mergedMTimeBefore: 0 });
+
+        await (coordinator as unknown as {
+            handleDidSaveTextDocument: (document: vscode.TextDocument) => Promise<void>
+        }).handleDidSaveTextDocument({ uri: { fsPath: merged } } as vscode.TextDocument);
+
+        expect(listener).toHaveBeenCalledTimes(1);
+        disposable.dispose();
+    });
+
     it('ignores save events for unrelated files', async () => {
         const local = path.join(tmpDir, 'component.c');
         const update = path.join(tmpDir, 'component.c.update@1.0.0');
@@ -143,4 +166,22 @@ describe('MergeSessionCoordinator', () => {
         expect(commandsProvider.executeCommand).toHaveBeenCalledTimes(1);
         expect(commandsProvider.executeCommand).toHaveBeenCalledWith(REFRESH_COMMAND_ID);
     });
+
+    it('finalizes on merge process exit when update file is already absent but base exists', async () => {
+        const local = path.join(tmpDir, 'component.c');
+        const update = path.join(tmpDir, 'component.c.update@1.0.0');
+        const base = path.join(tmpDir, 'component.c.base@1.0.0');
+        const merged = `${local}.merged`;
+
+        fsUtils.writeTextFile(local, '// local\n');
+        fsUtils.writeTextFile(base, '// base\n');
+        fsUtils.writeTextFile(merged, '// merged\n');
+
+        coordinator.startSession({ local, update, base, merged, mergedMTimeBefore: 0 });
+        await expect(coordinator.onMergeProcessExit(0)).resolves.toEqual({ applied: true });
+
+        expect(fsUtils.fileExists(local)).toBeTruthy();
+        expect(fsUtils.readTextFile(local)).toContain('// merged');
+        expect(fsUtils.fileExists(base)).toBeTruthy();
+    });
 });
diff --git a/src/views/solution-outline/commands/merge-session-coordinator.ts b/src/views/solution-outline/commands/merge-session-coordinator.ts
