Forward test logs

Author: farlee2121

src/FsAutoComplete.Core/TestServer.fs

@@ -12,36 +12,36 @@ module VSTestWrapper =
 
   type TestProjectDll = string
 
-  type private TestDiscoveryHandler(notifyIncrementalUpdate: TestCase list -> unit) =
+  type private TestDiscoveryHandler(notifyDiscoveryProgress: TestCase list -> unit) =
 
     member val DiscoveredTests: TestCase ResizeArray = ResizeArray() with get, set
 
     interface ITestDiscoveryEventsHandler with
       member this.HandleDiscoveredTests(discoveredTestCases: System.Collections.Generic.IEnumerable<TestCase>) : unit =
         if (not << isNull) discoveredTestCases then
           this.DiscoveredTests.AddRange(discoveredTestCases)
-          notifyIncrementalUpdate (discoveredTestCases |> List.ofSeq)
+          notifyDiscoveryProgress (discoveredTestCases |> List.ofSeq)
 
       member this.HandleDiscoveryComplete
         (_totalTests: int64, lastChunk: System.Collections.Generic.IEnumerable<TestCase>, _isAborted: bool)
         : unit =
         if (not << isNull) lastChunk then
           this.DiscoveredTests.AddRange(lastChunk)
-          notifyIncrementalUpdate (lastChunk |> List.ofSeq)
+          notifyDiscoveryProgress (lastChunk |> List.ofSeq)
 
       member this.HandleLogMessage(_level: TestMessageLevel, _message: string) : unit = ()
 
       member this.HandleRawMessage(_rawMessage: string) : unit = ()
 
   let discoverTestsAsync
     (vstestPath: string)
-    (incrementalUpdateHandler: TestCase list -> unit)
+    (onDiscoveryProgress: TestCase list -> unit)
     (sources: TestProjectDll list)
     : Async<TestCase list> =
     async {
       let consoleParams = ConsoleParameters()
       let vstest = new VsTestConsoleWrapper(vstestPath, consoleParams)
-      let discoveryHandler = TestDiscoveryHandler(incrementalUpdateHandler)
+      let discoveryHandler = TestDiscoveryHandler(onDiscoveryProgress)
 
       use! _onCancel = Async.OnCancel(fun () -> vstest.CancelDiscovery())
 
@@ -52,14 +52,17 @@ module VSTestWrapper =
   type ProcessId = int
   type DidDebuggerAttach = bool
 
-  type TestRunUpdate = Progress of TestRunChangedEventArgs
+  type TestRunUpdate =
+    | Progress of TestRunChangedEventArgs
+    | LogMessage of string
 
-  type TestRunHandler(notifyIncrementalUpdate: TestRunUpdate -> unit) =
+  type TestRunHandler(notifyTestRunProgress: TestRunUpdate -> unit) =
 
     member val TestResults: TestResult ResizeArray = ResizeArray() with get, set
 
     interface ITestRunEventsHandler with
-      member _.HandleLogMessage(_level: TestMessageLevel, _message: string) : unit = ()
+      member _.HandleLogMessage(level: TestMessageLevel, message: string) : unit =
+        notifyTestRunProgress (LogMessage $"[{level}] {message}")
 
       member _.HandleRawMessage(_rawMessage: string) : unit = ()
 
@@ -72,15 +75,15 @@ module VSTestWrapper =
         ) : unit =
         if ((not << isNull) lastChunkArgs && (not << isNull) lastChunkArgs.NewTestResults) then
           this.TestResults.AddRange(lastChunkArgs.NewTestResults)
-          notifyIncrementalUpdate (Progress lastChunkArgs)
+          notifyTestRunProgress (Progress lastChunkArgs)
 
       member this.HandleTestRunStatsChange(testRunChangedArgs: TestRunChangedEventArgs) : unit =
         if
           ((not << isNull) testRunChangedArgs
            && (not << isNull) testRunChangedArgs.NewTestResults)
         then
           this.TestResults.AddRange(testRunChangedArgs.NewTestResults)
-          notifyIncrementalUpdate (Progress testRunChangedArgs)
+          notifyTestRunProgress (Progress testRunChangedArgs)
 
       member _.LaunchProcessWithDebuggerAttached(_testProcessStartInfo: TestProcessStartInfo) : int =
         raise (System.NotImplementedException())
@@ -116,7 +119,7 @@ module VSTestWrapper =
   /// attachDebugger assumes that the debugger is attached when the method returns. The test project will continue execution as soon as attachDebugger returns
   let runTestsAsync
     (vstestPath: string)
-    (incrementalUpdateHandler: TestRunUpdate -> unit)
+    (onTestRunProgress: TestRunUpdate -> unit)
     (onAttachDebugger: ProcessId -> DidDebuggerAttach)
     (sources: TestProjectDll list)
     (testCaseFilter: string option)
@@ -125,7 +128,7 @@ module VSTestWrapper =
     async {
       let consoleParams = ConsoleParameters()
       let vstest = new VsTestConsoleWrapper(vstestPath, consoleParams)
-      let runHandler = TestRunHandler(incrementalUpdateHandler)
+      let runHandler = TestRunHandler(onTestRunProgress)
 
       let options = new TestPlatformOptions()
       testCaseFilter |> Option.iter (TestPlatformOptions.withTestCaseFilter options)

src/FsAutoComplete/LspHelpers.fs

@@ -619,11 +619,10 @@ type TestRunRequest =
 type TestDiscoveryUpdateNotification = { Tests: TestServer.TestItem array }
 
 type TestRunProgress =
-  { TestResults: TestServer.TestResult array
+  { TestLogs: string array
+    TestResults: TestServer.TestResult array
     ActiveTests: TestServer.TestItem array }
 
-type TestRunUpdateNotification = Progress of TestRunProgress
-
 type ProjectParms =
   {
     /// Project file to compile

src/FsAutoComplete/LspHelpers.fsi

@@ -205,11 +205,10 @@ type TestRunRequest =
 type TestDiscoveryUpdateNotification = { Tests: TestServer.TestItem array }
 
 type TestRunProgress =
-  { TestResults: TestServer.TestResult array
+  { TestLogs: string array
+    TestResults: TestServer.TestResult array
     ActiveTests: TestServer.TestItem array }
 
-type TestRunUpdateNotification = Progress of TestRunProgress
-
 type ProjectParms =
   {
     /// Project file to compile

src/FsAutoComplete/LspServers/AdaptiveServerState.fs

@@ -2588,12 +2588,12 @@ type AdaptiveState
         testCases
         |> List.choose (TestServer.TestItem.tryTestCaseToDTO projectLookup.TryFind)
 
-      let incrementalUpdateHandler (tests: Microsoft.VisualStudio.TestPlatform.ObjectModel.TestCase list) =
+      let onDiscoveryProgress (tests: Microsoft.VisualStudio.TestPlatform.ObjectModel.TestCase list) =
         lspClient.NotifyTestDiscoveryUpdate({ Tests = tests |> tryTestCasesToDTOs |> Array.ofList })
         |> Async.RunSynchronously
 
       let! testCases =
-        TestServer.VSTestWrapper.discoverTestsAsync vstestBinary.FullName incrementalUpdateHandler testProjectBinaries
+        TestServer.VSTestWrapper.discoverTestsAsync vstestBinary.FullName onDiscoveryProgress testProjectBinaries
 
       let testDTOs: TestServer.TestItem list = testCases |> tryTestCasesToDTOs
 
@@ -2625,20 +2625,24 @@ type AdaptiveState
 
       use! _onCancel = Async.OnCancel(fun _ -> tokenSource.Cancel())
 
-      let incrementalUpdateHandler (runUpdate: TestServer.VSTestWrapper.TestRunUpdate) =
+      let onTestRunProgress (runUpdate: TestServer.VSTestWrapper.TestRunUpdate) =
         let dto =
           match runUpdate with
           | TestServer.VSTestWrapper.TestRunUpdate.Progress progress ->
-            TestRunUpdateNotification.Progress
-              { TestResults = progress.NewTestResults |> List.ofSeq |> tryTestResultsToDTOs |> Array.ofSeq
-                ActiveTests =
-                  progress.ActiveTests
-                  |> Seq.choose (TestServer.TestItem.tryTestCaseToDTO projectLookup.TryFind)
-                  |> Array.ofSeq }
+            { TestLogs = [||]
+              TestResults = progress.NewTestResults |> List.ofSeq |> tryTestResultsToDTOs |> Array.ofSeq
+              ActiveTests =
+                progress.ActiveTests
+                |> Seq.choose (TestServer.TestItem.tryTestCaseToDTO projectLookup.TryFind)
+                |> Array.ofSeq }
+          | TestServer.VSTestWrapper.TestRunUpdate.LogMessage message ->
+            { TestLogs = [| message |]
+              TestResults = [||]
+              ActiveTests = [||] }
 
         Async.RunSynchronously(async { do! lspClient.NotifyTestRunUpdate(dto) }, cancellationToken = tokenSource.Token)
 
-      let attachDebugger (processId: int) : bool =
+      let onAttachDebugger (processId: int) : bool =
         let result =
           Async.RunSynchronously(lspClient.AttachDebuggerForTestRun(processId), cancellationToken = tokenSource.Token)
 
@@ -2655,8 +2659,8 @@ type AdaptiveState
       let! testResults =
         TestServer.VSTestWrapper.runTestsAsync
           vstestBinary.FullName
-          incrementalUpdateHandler
-          attachDebugger
+          onTestRunProgress
+          onAttachDebugger
           testProjectBinaries
           testCaseFilter
           shouldDebug

src/FsAutoComplete/LspServers/FSharpLspClient.fs

@@ -66,11 +66,9 @@ type FSharpLspClient(sendServerNotification: ClientNotificationSender, sendServe
     sendServerNotification "test/testDiscoveryUpdate" (box { Content = JsonSerializer.writeJson p })
     |> Async.Ignore
 
-  member __.NotifyTestRunUpdate(p: TestRunUpdateNotification) =
-    match p with
-    | Progress progress ->
-      sendServerNotification "test/testRunProgressUpdate" (box { Content = JsonSerializer.writeJson progress })
-      |> Async.Ignore
+  member __.NotifyTestRunUpdate(p: TestRunProgress) =
+    sendServerNotification "test/testRunProgressUpdate" (box { Content = JsonSerializer.writeJson p })
+    |> Async.Ignore
 
   member __.AttachDebuggerForTestRun(processId: int) : AsyncLspResult<bool> =
     sendServerRequest.Send "test/processWaitingForDebugger" (box { Content = string processId })

src/FsAutoComplete/LspServers/FSharpLspClient.fsi

@@ -33,7 +33,7 @@ type FSharpLspClient =
   member NotifyDocumentAnalyzed: p: DocumentAnalyzedNotification -> Async<unit>
   member NotifyTestDetected: p: TestDetectedNotification -> Async<unit>
   member NotifyTestDiscoveryUpdate: p: TestDiscoveryUpdateNotification -> Async<unit>
-  member NotifyTestRunUpdate: p: TestRunUpdateNotification -> Async<unit>
+  member NotifyTestRunUpdate: p: TestRunProgress -> Async<unit>
   member AttachDebuggerForTestRun: processId: int -> AsyncLspResult<bool>
   member CodeLensRefresh: unit -> Async<unit>
   override WindowWorkDoneProgressCreate: WorkDoneProgressCreateParams -> AsyncLspResult<unit>