remove di in debugger prompt

Author: paulacamargo25

src/client/debugger/extension/adapter/browser.ts

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { env, Uri } from 'vscode';
+
+export function launch(url: string): void {
+    env.openExternal(Uri.parse(url));
+}

src/client/debugger/extension/adapter/outdatedDebuggerPrompt.ts

@@ -3,33 +3,26 @@
 
 'use strict';
 
-import { inject, injectable } from 'inversify';
 import { DebugAdapterTracker, DebugAdapterTrackerFactory, DebugSession, ProviderResult } from 'vscode';
 import { DebugProtocol } from 'vscode-debugprotocol';
-import { IApplicationShell } from '../../../common/application/types';
-import { IBrowserService } from '../../../common/types';
 import { Common, OutdatedDebugger } from '../../../common/utils/localize';
+import { showInformationMessage } from '../configuration/utils/common';
+import { launch } from './browser';
 import { IPromptShowState } from './types';
 
 // This situation occurs when user connects to old containers or server where
 // the debugger they had installed was ptvsd. We should show a prompt to ask them to update.
 class OutdatedDebuggerPrompt implements DebugAdapterTracker {
-    constructor(
-        private promptCheck: IPromptShowState,
-        private appShell: IApplicationShell,
-        private browserService: IBrowserService,
-    ) {}
+    constructor(private promptCheck: IPromptShowState) {}
 
     public onDidSendMessage(message: DebugProtocol.ProtocolMessage) {
         if (this.promptCheck.shouldShowPrompt() && this.isPtvsd(message)) {
             const prompts = [Common.moreInfo];
-            this.appShell
-                .showInformationMessage(OutdatedDebugger.outdatedDebuggerMessage, ...prompts)
-                .then((selection) => {
-                    if (selection === prompts[0]) {
-                        this.browserService.launch('https://aka.ms/migrateToDebugpy');
-                    }
-                });
+            showInformationMessage(OutdatedDebugger.outdatedDebuggerMessage, ...prompts).then((selection) => {
+                if (selection === prompts[0]) {
+                    launch('https://aka.ms/migrateToDebugpy');
+                }
+            });
         }
     }
 
@@ -68,16 +61,12 @@ class OutdatedDebuggerPromptState implements IPromptShowState {
     }
 }
 
-@injectable()
 export class OutdatedDebuggerPromptFactory implements DebugAdapterTrackerFactory {
     private readonly promptCheck: OutdatedDebuggerPromptState;
-    constructor(
-        @inject(IApplicationShell) private readonly appShell: IApplicationShell,
-        @inject(IBrowserService) private browserService: IBrowserService,
-    ) {
+    constructor() {
         this.promptCheck = new OutdatedDebuggerPromptState();
     }
     public createDebugAdapterTracker(_session: DebugSession): ProviderResult<DebugAdapterTracker> {
-        return new OutdatedDebuggerPrompt(this.promptCheck, this.appShell, this.browserService);
+        return new OutdatedDebuggerPrompt(this.promptCheck);
     }
 }

src/client/debugger/extension/configuration/utils/common.ts

@@ -6,7 +6,7 @@
 
 'use strict';
 
-import { WorkspaceFolder } from 'vscode';
+import { WorkspaceFolder, window } from 'vscode';
 import { getWorkspaceFolder } from './workspaceFolder';
 
 /**
@@ -38,3 +38,7 @@ export function resolveVariables(
         return match && (match.indexOf('env.') > 0 || match.indexOf('env:') > 0) ? '' : match;
     });
 }
+
+export function showInformationMessage(message: string, ...items: string[]): Thenable<any> {
+    return window.showInformationMessage(message, ...items);
+}

src/test/debugger/extension/adapter/outdatedDebuggerPrompt.unit.test.ts

@@ -4,23 +4,23 @@
 'use strict';
 
 import * as assert from 'assert';
-import { anyString, anything, instance, mock, verify, when } from 'ts-mockito';
+import * as sinon from 'sinon';
+import { anyString, mock, when } from 'ts-mockito';
 import { DebugSession, WorkspaceFolder } from 'vscode';
 import { DebugProtocol } from 'vscode-debugprotocol';
-import { ApplicationShell } from '../../../../client/common/application/applicationShell';
-import { IApplicationShell } from '../../../../client/common/application/types';
 import { ConfigurationService } from '../../../../client/common/configuration/service';
-import { BrowserService } from '../../../../client/common/net/browser';
-import { IBrowserService, IPythonSettings } from '../../../../client/common/types';
 import { createDeferred, sleep } from '../../../../client/common/utils/async';
 import { Common } from '../../../../client/common/utils/localize';
 import { OutdatedDebuggerPromptFactory } from '../../../../client/debugger/extension/adapter/outdatedDebuggerPrompt';
 import { clearTelemetryReporter } from '../../../../client/telemetry';
+import * as browser from '../../../../client/debugger/extension/adapter/browser';
+import * as common from '../../../../client/debugger/extension/configuration/utils/common';
+import { IPythonSettings } from '../../../../client/common/types';
 
 suite('Debugging - Outdated Debugger Prompt tests.', () => {
     let promptFactory: OutdatedDebuggerPromptFactory;
-    let appShell: IApplicationShell;
-    let browserService: IBrowserService;
+    let showInformationMessageStub: sinon.SinonStub;
+    let browserLaunchStub: sinon.SinonStub;
 
     const ptvsdOutputEvent: DebugProtocol.OutputEvent = {
         seq: 1,
@@ -42,12 +42,14 @@ suite('Debugging - Outdated Debugger Prompt tests.', () => {
             experiments: { enabled: true },
         } as any) as IPythonSettings);
 
-        appShell = mock(ApplicationShell);
-        browserService = mock(BrowserService);
-        promptFactory = new OutdatedDebuggerPromptFactory(instance(appShell), instance(browserService));
+        showInformationMessageStub = sinon.stub(common, 'showInformationMessage');
+        browserLaunchStub = sinon.stub(browser, 'launch');
+
+        promptFactory = new OutdatedDebuggerPromptFactory();
     });
 
     teardown(() => {
+        sinon.restore();
         clearTelemetryReporter();
     });
 
@@ -67,33 +69,38 @@ suite('Debugging - Outdated Debugger Prompt tests.', () => {
         };
     }
 
-    test('Show prompt when attaching to ptvsd, more info is NOT clicked', async () => {
-        when(appShell.showInformationMessage(anything(), anything())).thenReturn(Promise.resolve(undefined));
-
+    test.only('Show prompt when attaching to ptvsd, more info is NOT clicked', async () => {
+        // when(appShell.showInformationMessage(anything(), anything())).thenReturn(Promise.resolve(undefined));
+        showInformationMessageStub.returns(Promise.resolve(undefined));
         const session = createSession();
         const prompter = await promptFactory.createDebugAdapterTracker(session);
         if (prompter) {
             prompter.onDidSendMessage!(ptvsdOutputEvent);
         }
 
-        verify(browserService.launch(anyString())).never();
+        browserLaunchStub.neverCalledWith(anyString());
+
         // First call should show info once
-        verify(appShell.showInformationMessage(anything(), anything())).once();
+
+        sinon.assert.calledOnce(showInformationMessageStub);
         assert(prompter);
 
         prompter!.onDidSendMessage!(ptvsdOutputEvent);
         // Can't use deferred promise here
         await sleep(1);
 
-        verify(browserService.launch(anyString())).never();
+        browserLaunchStub.neverCalledWith(anyString());
         // Second time it should not be called, so overall count is one.
-        verify(appShell.showInformationMessage(anything(), anything())).once();
+        sinon.assert.calledOnce(showInformationMessageStub);
     });
 
     test('Show prompt when attaching to ptvsd, more info is clicked', async () => {
-        when(appShell.showInformationMessage(anything(), anything())).thenReturn(Promise.resolve(Common.moreInfo));
+        // when(appShell.showInformationMessage(anything(), anything())).thenReturn(Promise.resolve(Common.moreInfo));
+        showInformationMessageStub.returns(Promise.resolve(Common.moreInfo));
+
         const deferred = createDeferred();
-        when(browserService.launch(anything())).thenCall(() => deferred.resolve());
+        // when(browserService.launch(anything())).thenCall(() => deferred.resolve());
+        browserLaunchStub.callsFake(() => deferred.resolve());
 
         const session = createSession();
         const prompter = await promptFactory.createDebugAdapterTracker(session);
@@ -102,22 +109,26 @@ suite('Debugging - Outdated Debugger Prompt tests.', () => {
         prompter!.onDidSendMessage!(ptvsdOutputEvent);
         await deferred.promise;
 
-        verify(browserService.launch(anything())).once();
+        // verify(browserService.launch(anything())).once();
+        sinon.assert.calledOnce(browserLaunchStub);
+
         // First call should show info once
-        verify(appShell.showInformationMessage(anything(), anything())).once();
+        // verify(appShell.showInformationMessage(anything(), anything())).once();
+        sinon.assert.calledOnce(showInformationMessageStub);
 
         prompter!.onDidSendMessage!(ptvsdOutputEvent);
         // The second call does not go through the same path. So we just give enough time for the
         // operation to complete.
         await sleep(1);
 
-        verify(browserService.launch(anyString())).once();
+        // verify(browserService.launch(anyString())).once();
         // Second time it should not be called, so overall count is one.
-        verify(appShell.showInformationMessage(anything(), anything())).once();
+        // verify(appShell.showInformationMessage(anything(), anything())).once();
     });
 
     test("Don't show prompt attaching to debugpy", async () => {
-        when(appShell.showInformationMessage(anything(), anything())).thenReturn(Promise.resolve(undefined));
+        // when(appShell.showInformationMessage(anything(), anything())).thenReturn(Promise.resolve(undefined));
+        showInformationMessageStub.returns(Promise.resolve(undefined));
 
         const session = createSession();
         const prompter = await promptFactory.createDebugAdapterTracker(session);
@@ -127,7 +138,7 @@ suite('Debugging - Outdated Debugger Prompt tests.', () => {
         // Can't use deferred promise here
         await sleep(1);
 
-        verify(appShell.showInformationMessage(anything(), anything())).never();
+        // verify(appShell.showInformationMessage(anything(), anything())).never();
     });
 
     const someRequest: DebugProtocol.RunInTerminalRequest = {
@@ -155,7 +166,8 @@ suite('Debugging - Outdated Debugger Prompt tests.', () => {
 
     [someRequest, someEvent, someOutputEvent].forEach((message) => {
         test(`Don't show prompt when non-telemetry events are seen: ${JSON.stringify(message)}`, async () => {
-            when(appShell.showInformationMessage(anything(), anything())).thenReturn(Promise.resolve(undefined));
+            // when(appShell.showInformationMessage(anything(), anything())).thenReturn(Promise.resolve(undefined));
+            showInformationMessageStub.returns(Promise.resolve(undefined));
 
             const session = createSession();
             const prompter = await promptFactory.createDebugAdapterTracker(session);
@@ -165,7 +177,7 @@ suite('Debugging - Outdated Debugger Prompt tests.', () => {
             // Can't use deferred promise here
             await sleep(1);
 
-            verify(appShell.showInformationMessage(anything(), anything())).never();
+            // verify(appShell.showInformationMessage(anything(), anything())).never();
         });
     });
 });