fix(ci): prevent type-provider integration test hangs

Author: pchalamet

.github/workflows/ci-main.yml

@@ -13,6 +13,7 @@ permissions:
 jobs:
   build-and-test:
     runs-on: ubuntu-latest
+    timeout-minutes: 25
 
     steps:
       - name: Checkout

.github/workflows/ci-pr.yml

@@ -17,6 +17,7 @@ permissions:
 jobs:
   build-and-test:
     runs-on: ubuntu-latest
+    timeout-minutes: 25
 
     steps:
       - name: Checkout

CHANGELOG.md

@@ -5,6 +5,7 @@ All notable changes to FScript are documented in this file.
 ## [Unreleased]
 
 - Added a new `MagnusOpera.FScript.TypeProvider` package that type-checks scripts at compile time and exposes exported functions as strongly-typed F# members with runtime signature compatibility checks.
+- Stabilized type-provider integration tests in CI by hardening spawned `dotnet` process handling and adding job-level CI timeouts to prevent long hangs.
 
 ## [0.59.0]
 

tests/FScript.TypeProvider.Tests/TypeProviderIntegrationTests.fs

@@ -3,8 +3,16 @@ namespace FScript.TypeProvider.Tests
 open System
 open System.Diagnostics
 open System.IO
+open System.Text
 open NUnit.Framework
 
+type ProcessRunResult =
+    { ExitCode: int
+      Stdout: string
+      Stderr: string
+      Duration: TimeSpan
+      TimedOut: bool }
+
 [<TestFixture>]
 type TypeProviderIntegrationTests () =
     let findRepoRoot () =
@@ -21,7 +29,14 @@ type TypeProviderIntegrationTests () =
 
         loop TestContext.CurrentContext.TestDirectory
 
-    let runProcess (workingDirectory: string) (fileName: string) (arguments: string) =
+    let runProcess
+        (workingDirectory: string)
+        (fileName: string)
+        (arguments: string)
+        (timeout: TimeSpan)
+        : ProcessRunResult =
+        let stdout = StringBuilder()
+        let stderr = StringBuilder()
         let startInfo =
             ProcessStartInfo(
                 FileName = fileName,
@@ -31,42 +46,97 @@ type TypeProviderIntegrationTests () =
                 RedirectStandardError = true,
                 UseShellExecute = false)
 
+        use outputClosed = new System.Threading.ManualResetEventSlim(false)
+        use errorClosed = new System.Threading.ManualResetEventSlim(false)
+
         use proc = new Process(StartInfo = startInfo)
+        proc.OutputDataReceived.Add(fun args ->
+            match args.Data with
+            | null -> outputClosed.Set()
+            | value -> stdout.AppendLine(value) |> ignore)
+        proc.ErrorDataReceived.Add(fun args ->
+            match args.Data with
+            | null -> errorClosed.Set()
+            | value -> stderr.AppendLine(value) |> ignore)
+
+        let startedAt = DateTimeOffset.UtcNow
         proc.Start() |> ignore
-        let stdout = proc.StandardOutput.ReadToEnd()
-        let stderr = proc.StandardError.ReadToEnd()
-        proc.WaitForExit()
-        proc.ExitCode, stdout, stderr
+        proc.BeginOutputReadLine()
+        proc.BeginErrorReadLine()
+
+        let completed = proc.WaitForExit(int timeout.TotalMilliseconds)
+        if not completed then
+            try
+                proc.Kill(true)
+            with _ -> ()
+            proc.WaitForExit()
+
+        outputClosed.Wait(TimeSpan.FromSeconds(5.0)) |> ignore
+        errorClosed.Wait(TimeSpan.FromSeconds(5.0)) |> ignore
+        let endedAt = DateTimeOffset.UtcNow
+
+        { ExitCode = proc.ExitCode
+          Stdout = stdout.ToString()
+          Stderr = stderr.ToString()
+          Duration = endedAt - startedAt
+          TimedOut = not completed }
+
+    let formatResult (commandLine: string) (result: ProcessRunResult) =
+        let output = result.Stdout + "\n" + result.Stderr
+        let trimmedOutput =
+            if output.Length > 12000 then
+                output.Substring(0, 12000) + "\n...[truncated]..."
+            else
+                output
+        $"Command: {commandLine}\nExitCode: {result.ExitCode}\nTimedOut: {result.TimedOut}\nDuration: {result.Duration}\nOutput:\n{trimmedOutput}"
+
+    let buildCommand fixturePath =
+        $"build \"{fixturePath}\" -c Release --disable-build-servers /p:UseSharedCompilation=false /nodeReuse:false"
 
     [<Test>]
     member _.``type provider builds valid script fixture`` () =
         let repoRoot = findRepoRoot ()
         let fixturePath = Path.Combine(repoRoot, "tests", "FScript.TypeProvider.Tests.Fixtures.Valid")
-        let exitCode, stdout, stderr = runProcess repoRoot "dotnet" $"build \"{fixturePath}\" -c Release"
-        let output = stdout + "\n" + stderr
-        Assert.That(exitCode, Is.EqualTo(0), $"Expected build success. Output:\n{output}")
+        let command = buildCommand fixturePath
+        let commandLine = "dotnet " + command
+        let result = runProcess repoRoot "dotnet" command (TimeSpan.FromSeconds(120.0))
+        let detail = formatResult commandLine result
+        Assert.That(result.TimedOut, Is.False, $"Build command timed out.\n{detail}")
+        Assert.That(result.ExitCode, Is.EqualTo(0), $"Expected build success.\n{detail}")
 
     [<Test>]
     member _.``type provider fails compilation on script type error`` () =
         let repoRoot = findRepoRoot ()
         let fixturePath = Path.Combine(repoRoot, "tests", "FScript.TypeProvider.Tests.Fixtures.Invalid")
-        let exitCode, stdout, stderr = runProcess repoRoot "dotnet" $"build \"{fixturePath}\" -c Release"
-        let output = stdout + "\n" + stderr
-        Assert.That(exitCode, Is.Not.EqualTo(0), "Expected build failure for invalid script.")
-        Assert.That(output, Does.Contain("Failed to type-check FScript"))
+        let command = buildCommand fixturePath
+        let commandLine = "dotnet " + command
+        let result = runProcess repoRoot "dotnet" command (TimeSpan.FromSeconds(120.0))
+        let output = result.Stdout + "\n" + result.Stderr
+        let detail = formatResult commandLine result
+        Assert.That(result.TimedOut, Is.False, $"Build command timed out.\n{detail}")
+        Assert.That(result.ExitCode, Is.Not.EqualTo(0), $"Expected build failure for invalid script.\n{detail}")
+        Assert.That(output, Does.Contain("Failed to type-check FScript"), detail)
 
     [<Test>]
     member _.``type provider fails unsupported exported signature`` () =
         let repoRoot = findRepoRoot ()
         let fixturePath = Path.Combine(repoRoot, "tests", "FScript.TypeProvider.Tests.Fixtures.Unsupported")
-        let exitCode, stdout, stderr = runProcess repoRoot "dotnet" $"build \"{fixturePath}\" -c Release"
-        let output = stdout + "\n" + stderr
-        Assert.That(exitCode, Is.Not.EqualTo(0), "Expected build failure for unsupported signature.")
-        Assert.That(output, Does.Contain("not supported in exported signatures"))
+        let command = buildCommand fixturePath
+        let commandLine = "dotnet " + command
+        let result = runProcess repoRoot "dotnet" command (TimeSpan.FromSeconds(120.0))
+        let output = result.Stdout + "\n" + result.Stderr
+        let detail = formatResult commandLine result
+        Assert.That(result.TimedOut, Is.False, $"Build command timed out.\n{detail}")
+        Assert.That(result.ExitCode, Is.Not.EqualTo(0), $"Expected build failure for unsupported signature.\n{detail}")
+        Assert.That(output, Does.Contain("not supported in exported signatures"), detail)
 
     [<Test>]
     member _.``runtime resolver override can replace implementation and mismatch is rejected`` () =
         let repoRoot = findRepoRoot ()
         let fixturePath = Path.Combine(repoRoot, "tests", "FScript.TypeProvider.Tests.Fixtures.RuntimeOverride")
-        let exitCode, stdout, stderr = runProcess repoRoot "dotnet" $"run --project \"{fixturePath}\" -c Release"
-        Assert.That(exitCode, Is.EqualTo(0), $"Expected runtime fixture success.\nStdout:\n{stdout}\nStderr:\n{stderr}")
+        let command = $"run --project \"{fixturePath}\" -c Release --disable-build-servers"
+        let commandLine = "dotnet " + command
+        let result = runProcess repoRoot "dotnet" command (TimeSpan.FromSeconds(180.0))
+        let detail = formatResult commandLine result
+        Assert.That(result.TimedOut, Is.False, $"Runtime command timed out.\n{detail}")
+        Assert.That(result.ExitCode, Is.EqualTo(0), $"Expected runtime fixture success.\n{detail}")