Add WaitEvent helper function

Author: JustinGrote

test/features/DebugSession.test.ts

@@ -12,7 +12,7 @@ import * as platform from "../../src/platform";
 import { IPlatformDetails } from "../../src/platform";
 import { IEditorServicesSessionDetails, IPowerShellVersionDetails, SessionManager, SessionStatus } from "../../src/session";
 import * as utils from "../../src/utils";
-import { BuildBinaryModuleMock, InstallCSharpExtension, ensureEditorServicesIsConnected, stubInterface, testLogger } from "../utils";
+import { BuildBinaryModuleMock, InstallCSharpExtension, WaitEvent, ensureEditorServicesIsConnected, stubInterface, testLogger } from "../utils";
 
 const TEST_NUMBER = 7357; //7357 = TEST. Get it? :)
 
@@ -408,6 +408,7 @@ describe("DebugSessionFeature E2E", function slowTests() {
         let stopDebugSession: DebugSession;
         const interactiveSessionConfig = defaultDebugConfigurations[DebugConfig.InteractiveSession];
         // Asserts dont seem to fire in this event or the event doesnt resolve in the test code flow, so we need to "extract" the values for later use by the asserts
+
         const startDebugEvent = debug.onDidStartDebugSession((newDebugSession) => {
             startDebugEvent.dispose();
             startDebugSession = newDebugSession;
@@ -469,37 +470,32 @@ describe("DebugSessionFeature E2E", function slowTests() {
             const cmdletSourcePath = Uri.joinPath(workspace.workspaceFolders![0].uri, "mocks/BinaryModule/TestSampleCmdletCommand.cs");
             const testScriptDocument = await workspace.openTextDocument(testScriptPath);
             await window.showTextDocument(testScriptDocument);
+
+            // We cant see when a breakpoint is hit because the code we would spy on is in the C# extension or is vscode private, but we can see if the debug session changes which should only happen when the debug session context switches to C#, so that's good enough.
+
+            //We wire this up before starting the debug session so the event is registered
+            const dotnetDebugSessionActive = WaitEvent(debug.onDidChangeActiveDebugSession, (session) => {
+                console.log(`Debug Session Changed: ${session?.name}`);
+                return !!session?.name.match(/Dotnet Debugger/);
+            });
+
             // Break at beginProcessing of the cmdlet
             debug.addBreakpoints([
                 new SourceBreakpoint({
                     uri: cmdletSourcePath,
                     range: new Range(26, 0, 26, 0) //BeginProcessing
-                })
+                }, true, undefined, undefined, "TEST-BinaryModuleBreakpoint")
             ]);
-            // HACK: Could not find a way to detect a breakpoint hit directly, but we can detect if the editor view changes to our breakpointed file.
-            let editorChanged: () => void;
-            let activeEditorChangedToCmdletSourcePath = false;
-            const waitForEditorChange = async () => {
-                return new Promise<void>((resolve) => {editorChanged = resolve;});
-            };
-            const activeEditorChanged = window.onDidChangeActiveTextEditor((editor) => {
-                console.log(`Active editor changed to ${editor?.document.uri.path}`);
-                if (editor?.document.uri.path == cmdletSourcePath.path) {
-                    activeEditorChanged.dispose();
-                    activeEditorChangedToCmdletSourcePath = true;
-                    editorChanged();
-                } else {
-                    console.log(`${editor?.document.uri.path} doesn't match ${cmdletSourcePath.path}`);
-                }
-            });
+
             const debugStarted = await debug.startDebugging(undefined, launchScriptConfig);
             console.log(debug.breakpoints);
-            console.log("Waiting for editor change");
-            await waitForEditorChange();
+            const dotnetDebugSession = await dotnetDebugSessionActive;
+            console.log(debug.activeDebugSession);
+            console.log(debug.breakpoints);
             const debugStopped = await debug.stopDebugging(undefined);
 
             assert.ok(debugStarted);
-            assert.ok(activeEditorChangedToCmdletSourcePath);
+            assert.ok(dotnetDebugSession);
             assert.ok(debugStopped);
         });
     });

test/utils.ts

@@ -163,3 +163,18 @@ export function BuildBinaryModuleMock() {
     const buildResult = execSync(`dotnet publish ${projectPath}`);
     console.log(buildResult.toString());
 }
+
+/** Waits until the registered vscode event is fired and returns the trigger result of the event.
+ * @param event The event to wait for
+ * @param filter An optional filter to apply to the event TResult. The filter will continue to monitor the event firings until the filter returns true.
+*/
+export function WaitEvent<TResult>(event: vscode.Event<TResult>, filter?: (event: TResult) => boolean | undefined): Promise<TResult> {
+    return new Promise<TResult>((resolve) => {
+        const listener = event((result: TResult) => {
+            if (!filter || filter(result)) {
+                listener.dispose();
+                resolve(result);
+            }
+        });
+    });
+}