Add timeouts to most subprocess calls in tests

Just a speculative fix to avoid timeouts during the `swift test` invocation

Author: ahoppen

Sources/SKTestSupport/IndexedSingleSwiftFileTestProject.swift

@@ -13,6 +13,7 @@
 @_spi(Testing) import BuildSystemIntegration
 package import Foundation
 package import LanguageServerProtocol
+import SKLogging
 import SKOptions
 import SourceKitLSP
 import SwiftExtensions
@@ -126,7 +127,11 @@ package struct IndexedSingleSwiftFileTestProject {
 
     // Run swiftc to build the index store
     do {
-      try await Process.checkNonZeroExit(arguments: [swiftc.filePath] + compilerArguments)
+      let compilerArgumentsCopy = compilerArguments
+      let output = try await withTimeout(defaultTimeoutDuration) {
+        try await Process.checkNonZeroExit(arguments: [swiftc.filePath] + compilerArgumentsCopy)
+      }
+      logger.debug("swiftc output:\n\(output)")
     } catch {
       if !allowBuildFailure {
         throw error

Sources/SKTestSupport/SkipUnless.swift

@@ -222,19 +222,22 @@ package actor SkipUnless {
           throw FailedToCrateInputFileError()
         }
         // If we can't compile for wasm, this fails complaining that it can't find the stdlib for wasm.
-        let process = Process(
-          args: try swiftFrontend.filePath,
-          "-typecheck",
-          try input.filePath,
-          "-triple",
-          "wasm32-unknown-none-wasm",
-          "-enable-experimental-feature",
-          "Embedded",
-          "-Xcc",
-          "-fdeclspec"
-        )
-        try process.launch()
-        let result = try await process.waitUntilExit()
+        let result = try await withTimeout(defaultTimeoutDuration) {
+          try await Process.run(
+            arguments: [
+              try swiftFrontend.filePath,
+              "-typecheck",
+              try input.filePath,
+              "-triple",
+              "wasm32-unknown-none-wasm",
+              "-enable-experimental-feature",
+              "Embedded",
+              "-Xcc",
+              "-fdeclspec",
+            ],
+            workingDirectory: nil
+          )
+        }
         if result.exitStatus == .terminated(code: 0) {
           return .featureSupported
         }

Sources/SKTestSupport/SwiftPMDependencyProject.swift

@@ -13,6 +13,7 @@
 package import Foundation
 import LanguageServerProtocolExtensions
 import SwiftExtensions
+import TSCExtensions
 import XCTest
 
 import struct TSCBasic.AbsolutePath
@@ -45,11 +46,12 @@ package class SwiftPMDependencyProject {
     }
     // We can't use `workingDirectory` because Amazon Linux doesn't support working directories (or at least
     // TSCBasic.Process doesn't support working directories on Amazon Linux)
-    let process = TSCBasic.Process(
-      arguments: [try git.filePath, "-C", try workingDirectory.filePath] + arguments
-    )
-    try process.launch()
-    let processResult = try await process.waitUntilExit()
+    let processResult = try await withTimeout(defaultTimeoutDuration) {
+      try await TSCBasic.Process.run(
+        arguments: [try git.filePath, "-C", try workingDirectory.filePath] + arguments,
+        workingDirectory: nil
+      )
+    }
     guard processResult.exitStatus == .terminated(code: 0) else {
       throw Error.processedTerminatedWithNonZeroExitCode(processResult)
     }

Sources/SKTestSupport/SwiftPMTestProject.swift

@@ -12,6 +12,7 @@
 
 package import Foundation
 package import LanguageServerProtocol
+import SKLogging
 package import SKOptions
 package import SourceKitLSP
 import SwiftExtensions
@@ -260,7 +261,16 @@ package class SwiftPMTestProject: MultiFileTestProject {
         "-Xswiftc", "-module-cache-path", "-Xswiftc", try globalModuleCache.filePath,
       ]
     }
-    try await Process.checkNonZeroExit(arguments: arguments)
+    let argumentsCopy = arguments
+    let output = try await withTimeout(defaultTimeoutDuration) {
+      try await Process.checkNonZeroExit(arguments: argumentsCopy)
+    }
+    logger.debug(
+      """
+      'swift build' output: 
+      \(output)
+      """
+    )
   }
 
   /// Resolve package dependencies for the package at `path`.
@@ -274,6 +284,14 @@ package class SwiftPMTestProject: MultiFileTestProject {
       "resolve",
       "--package-path", try path.filePath,
     ]
-    try await Process.checkNonZeroExit(arguments: arguments)
+    let output = try await withTimeout(defaultTimeoutDuration) {
+      try await Process.checkNonZeroExit(arguments: arguments)
+    }
+    logger.debug(
+      """
+      'swift package resolve' output: 
+      \(output)
+      """
+    )
   }
 }

Sources/SourceKitLSP/Swift/DocumentFormatting.swift

@@ -196,7 +196,9 @@ extension SwiftLanguageService {
     writeStream.send(snapshot.text)
     try writeStream.close()
 
-    let result = try await process.waitUntilExitStoppingProcessOnTaskCancellation()
+    let result = try await withTimeout(.seconds(60)) {
+      try await process.waitUntilExitStoppingProcessOnTaskCancellation()
+    }
     guard result.exitStatus == .terminated(code: 0) else {
       let swiftFormatErrorMessage: String
       switch result.stderrOutput {

Tests/SourceKitLSPTests/BackgroundIndexingTests.swift

@@ -1353,14 +1353,24 @@ final class BackgroundIndexingTests: XCTestCase {
     //  - The user runs `swift package update`
     //  - This updates `Package.resolved`, which we watch
     //  - We reload the package, which updates `Dependency.swift` in `.build/index-build/checkouts`, which we also watch.
-    try await Process.run(
-      arguments: [
-        unwrap(ToolchainRegistry.forTesting.default?.swift?.filePath),
-        "package", "update",
-        "--package-path", project.scratchDirectory.filePath,
-      ],
-      workingDirectory: nil
+    let projectURL = project.scratchDirectory
+    let packageUpdateOutput = try await withTimeout(defaultTimeoutDuration) {
+      try await Process.run(
+        arguments: [
+          unwrap(ToolchainRegistry.forTesting.default?.swift?.filePath),
+          "package", "update",
+          "--package-path", projectURL.filePath,
+        ],
+        workingDirectory: nil
+      )
+    }
+    logger.debug(
+      """
+      'swift package update' output:
+      \(packageUpdateOutput)
+      """
     )
+
     XCTAssertNotEqual(try String(contentsOf: packageResolvedURL, encoding: .utf8), originalPackageResolvedContents)
     project.testClient.send(
       DidChangeWatchedFilesNotification(changes: [

Tests/SourceKitLSPTests/WorkspaceTests.swift

@@ -690,13 +690,7 @@ final class WorkspaceTests: XCTestCase {
 
     let packageDir = try project.uri(for: "Package.swift").fileURL!.deletingLastPathComponent()
 
-    try await TSCBasic.Process.checkNonZeroExit(arguments: [
-      ToolchainRegistry.forTesting.default!.swift!.filePath,
-      "build",
-      "--package-path", packageDir.filePath,
-      "-Xswiftc", "-index-ignore-system-modules",
-      "-Xcc", "-index-ignore-system-symbols",
-    ])
+    try await SwiftPMTestProject.build(at: packageDir)
 
     let (otherPackageUri, positions) = try project.openDocument("otherPackage.swift")
     let testPosition = positions["1️⃣"]
@@ -1356,13 +1350,16 @@ final class WorkspaceTests: XCTestCase {
     )
 
     let clang = try unwrap(await ToolchainRegistry.forTesting.default?.clang)
-    try await Process.checkNonZeroExit(
-      arguments: [
-        clang.filePath, "-index-store-path", scratchDirectory.appendingPathComponent("index").filePath,
-        scratchDirectory.appendingPathComponent("test.c").filePath,
-        "-fsyntax-only",
-      ]
-    )
+    let clangOutput = try await withTimeout(defaultTimeoutDuration) {
+      try await Process.checkNonZeroExit(
+        arguments: [
+          clang.filePath, "-index-store-path", scratchDirectory.appendingPathComponent("index").filePath,
+          scratchDirectory.appendingPathComponent("test.c").filePath,
+          "-fsyntax-only",
+        ]
+      )
+    }
+    logger.debug("Clang output:\n\(clangOutput)")
 
     let testClient = try await TestSourceKitLSPClient(
       options: .testDefault(experimentalFeatures: [.sourceKitOptionsRequest]),

Tests/TSCExtensionsTests/ProcessRunTests.swift

@@ -38,10 +38,12 @@ final class ProcessRunTests: XCTestCase {
       print(os.getcwd(), end='')
       """.write(to: pythonFile, atomically: true, encoding: .utf8)
 
-      let result = try await Process.run(
-        arguments: [python.filePath, pythonFile.filePath],
-        workingDirectory: AbsolutePath(validating: workingDir.filePath)
-      )
+      let result = try await withTimeout(defaultTimeoutDuration) {
+        try await Process.run(
+          arguments: [python.filePath, pythonFile.filePath],
+          workingDirectory: AbsolutePath(validating: workingDir.filePath)
+        )
+      }
       let stdout = try unwrap(String(bytes: result.output.get(), encoding: .utf8))
       XCTAssertEqual(stdout, try workingDir.filePath)
     }