[ test ] Trying to figure out what happened on Windows

Author: banacorn

.github/workflows/test.yml

@@ -21,8 +21,10 @@ jobs:
     runs-on: ${{ matrix.os }} 
     strategy:
       matrix:
-        os: [windows-latest, ubuntu-latest, macos-latest]
-        agda: ["Agda-2.6.3", "Agda-2.6.4", "Agda-2.7.0"]
+        # os: [windows-latest, ubuntu-latest, macos-latest]
+        os: [windows-latest]
+        # agda: ["Agda-2.6.3", "Agda-2.6.4", "Agda-2.7.0"]
+        agda: ["Agda-2.7.0"]
       fail-fast: false
 
     # Steps represent a sequence of tasks that will be executed as part of the job

lib/js/src/Connection/Connection.bs.js

@@ -322,9 +322,11 @@ module Module: Module = {
   }
 
   let sendRequest = async (connection, document, request, handler) => {
+    Js.log("[ LOG ] Sending request: " ++ Request.toString(request))
     // encode the Request to some string
     let encodeRequest = (document, version) => {
       let filepath = document->VSCode.TextDocument.fileName->Parser.filepath
+      Js.log("[ LOG ] original filepath: " ++ filepath)
       let libraryPath = Config.getLibraryPath()
       let highlightingMethod = Config.Highlighting.getHighlightingMethod()
       let backend = Config.getBackend()

lib/js/src/Connection/Transport/Connection__Transport__Process.bs.js

@@ -69,6 +69,7 @@ module Module: Module = {
     ->Option.forEach(stream =>
       stream
       ->NodeJs.Stream.onData(chunk => {
+        Js.log("[ LOG ][ " ++ path ++ "] Process stdout: " ++ NodeJs.Buffer.toString(chunk))
         chan->Chan.emit(Stdout(NodeJs.Buffer.toString(chunk)))
       })
       ->ignore
@@ -80,6 +81,7 @@ module Module: Module = {
     ->Option.forEach(stream =>
       stream
       ->NodeJs.Stream.onData(chunk => {
+        Js.log("[ LOG ][ " ++ path ++ "] Process stderr: " ++ NodeJs.Buffer.toString(chunk))
         chan->Chan.emit(Stderr(NodeJs.Buffer.toString(chunk)))
         // store the latest message from stderr
         stderr := stderr.contents ++ NodeJs.Buffer.toString(chunk)
@@ -89,6 +91,7 @@ module Module: Module = {
 
     // on `close` from `stdin` or `process`
     let promiseOnClose = Promise.make((resolve, _) => {
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onClose: Waiting for process to close")
       process
       ->NodeJs.ChildProcess.stdin
       ->Option.forEach(stream =>
@@ -104,21 +107,26 @@ module Module: Module = {
 
     // on errors and anomalies
     let promiseOnExit = Promise.make((resolve, _) => {
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onExit: Waiting for process to exit")
       process
       ->NodeJs.ChildProcess.onExit(code => resolve(code))
       ->ignore
     })
 
     process
-    ->NodeJs.ChildProcess.onDisconnect(() => chan->Chan.emit(Event(OnDestroyed)))
-    ->NodeJs.ChildProcess.onError(exn =>
+    ->NodeJs.ChildProcess.onDisconnect(() => {
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onDisconnect: Process disconnected")
+      chan->Chan.emit(Event(OnDestroyed))})
+    ->NodeJs.ChildProcess.onError(exn =>{
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onError: Process error: " ++ Util.JsError.toString(exn))
       chan->Chan.emit(Event(OnError(Util.JsError.toString(exn))))
-    )
+    })
     ->ignore
 
     // emit `OnExit` when either `close` or `exit` was received
     Promise.race([promiseOnExit, promiseOnClose])
     ->Promise.thenResolve(exitCode => {
+      Js.log("[ LOG ][ " ++ path ++ "] Process.onExit: Process exited with code " ++ string_of_int(exitCode))
       chan->Chan.emit(Event(OnExit(exitCode)))
     })
     ->ignore
@@ -155,6 +163,7 @@ module Module: Module = {
   let send = (self, request): bool => {
     switch self.status {
     | Created(process) =>
+      Js.log("[ LOG ] Process.send: Sending request: " ++ request)
       let payload = NodeJs.Buffer.fromString(request ++ NodeJs.Os.eol)
       process
       ->NodeJs.ChildProcess.stdin
@@ -164,7 +173,9 @@ module Module: Module = {
         ->ignore
       )
       true
-    | _ => false
+    | _ => 
+      Js.log("[ LOG ] Process.send: Cannot send, process is not in a valid state")
+      false
     }
   }
 

lib/js/test/tests/Test__Auto.bs.js

@@ -36,61 +36,61 @@ let run = normalization => {
     }
   })
 
-  Async.it("should be responded with correct responses 2", async () => {
-    let ctx = await AgdaMode.makeAndLoad("Auto.agda")
+  // Async.it("should be responded with correct responses 2", async () => {
+  //   let ctx = await AgdaMode.makeAndLoad("Auto.agda")
 
-    let responses = switch Goals.getGoalByIndex(ctx.state.goals, 1) {
-    | Some(goal) =>
-      await ctx.state->State__Connection.sendRequestAndCollectResponses(
-        Request.Auto(normalization, goal),
-      )
-    | None => []
-    }
+  //   let responses = switch Goals.getGoalByIndex(ctx.state.goals, 1) {
+  //   | Some(goal) =>
+  //     await ctx.state->State__Connection.sendRequestAndCollectResponses(
+  //       Request.Auto(normalization, goal),
+  //     )
+  //   | None => []
+  //   }
 
-    let filteredResponses = responses->Array.filter(filteredResponse)
+  //   let filteredResponses = responses->Array.filter(filteredResponse)
 
-    switch ctx.state.agdaVersion {
-    | Some(version) =>
-      if Util.Version.gte(version, "2.7.0") {
-        Assert.deepStrictEqual(
-          filteredResponses,
-          [GiveAction(1, GiveString("n")), InteractionPoints([0])],
-        )
-      } else {
-        Assert.deepStrictEqual(
-          filteredResponses,
-          [
-            GiveAction(1, GiveString("m")),
-            DisplayInfo(AllGoalsWarnings("*All Goals*", "?0 : ℕ\n")),
-            InteractionPoints([0]),
-          ],
-        )
-      }
-    | None => Assert.fail("No Agda version found")
-    }
-  })
+  //   switch ctx.state.agdaVersion {
+  //   | Some(version) =>
+  //     if Util.Version.gte(version, "2.7.0") {
+  //       Assert.deepStrictEqual(
+  //         filteredResponses,
+  //         [GiveAction(1, GiveString("n")), InteractionPoints([0])],
+  //       )
+  //     } else {
+  //       Assert.deepStrictEqual(
+  //         filteredResponses,
+  //         [
+  //           GiveAction(1, GiveString("m")),
+  //           DisplayInfo(AllGoalsWarnings("*All Goals*", "?0 : ℕ\n")),
+  //           InteractionPoints([0]),
+  //         ],
+  //       )
+  //     }
+  //   | None => Assert.fail("No Agda version found")
+  //   }
+  // })
 }
 
 describe("agda-mode.auto", () => {
   This.timeout(4000)
 
-  // testing for Auto somehow hangs on GitHub Actions Windows runners (but works fine on my desktop Windows :))
-  // cannot find out why, so skip the tests on Windows for now
-  if OS.onUnix {
-    describe("AsIs", () => {
+  // // testing for Auto somehow hangs on GitHub Actions Windows runners (but works fine on my desktop Windows :))
+  // // cannot find out why, so skip the tests on Windows for now
+  // if OS.onUnix {
+    describe_only("AsIs", () => {
       run(AsIs)
     })
 
-    describe("Simplified", () => {
-      run(Simplified)
-    })
+    // describe("Simplified", () => {
+    //   run(Simplified)
+    // })
 
-    describe("Normalised", () => {
-      run(Normalised)
-    })
+    // describe("Normalised", () => {
+    //   run(Normalised)
+    // })
 
-    describe("HeadNormal", () => {
-      run(HeadNormal)
-    })
-  }
+    // describe("HeadNormal", () => {
+    //   run(HeadNormal)
+    // })
+  // }
 })