mirror of
https://github.com/apple/sourcekit-lsp.git
synced 2026-06-24 12:21:58 +02:00
25harsh
824 lines
29 KiB
Swift
824 lines
29 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
import BuildServerIntegration
|
|
@_spi(SourceKitLSP) import BuildServerProtocol
|
|
import Foundation
|
|
@_spi(SourceKitLSP) import LanguageServerProtocol
|
|
@_spi(SourceKitLSP) import LanguageServerProtocolExtensions
|
|
import SKLogging
|
|
import SKOptions
|
|
import SKTestSupport
|
|
import SourceKitLSP
|
|
import SwiftExtensions
|
|
import TSCBasic
|
|
import XCTest
|
|
|
|
#if os(Windows)
|
|
import WinSDK
|
|
#endif
|
|
|
|
final class ExternalBuildServerTests: SourceKitLSPTestCase {
|
|
func testBuildSettingsFromBuildServer() async throws {
|
|
let project = try await ExternalBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": """
|
|
#if DEBUG
|
|
#error("DEBUG SET")
|
|
#else
|
|
#error("DEBUG NOT SET")
|
|
#endif
|
|
"""
|
|
],
|
|
buildServer: """
|
|
class BuildServer(AbstractBuildServer):
|
|
def workspace_build_targets(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"targets": [
|
|
{
|
|
"id": {"uri": "bsp://dummy"},
|
|
"tags": [],
|
|
"languageIds": [],
|
|
"dependencies": [],
|
|
"capabilities": {},
|
|
}
|
|
]
|
|
}
|
|
|
|
def buildtarget_sources(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"items": [
|
|
{
|
|
"target": {"uri": "bsp://dummy"},
|
|
"sources": [
|
|
{"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
def textdocument_sourcekitoptions(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"compilerArguments": [r"$TEST_DIR/Test.swift", "-DDEBUG", $SDK_ARGS]
|
|
}
|
|
"""
|
|
)
|
|
|
|
let (uri, _) = try project.openDocument("Test.swift")
|
|
|
|
try await repeatUntilExpectedResult {
|
|
let diags = try await project.testClient.send(
|
|
DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
|
|
)
|
|
return diags.fullReport?.items.map(\.message) == ["DEBUG SET"]
|
|
}
|
|
}
|
|
|
|
func testBuildTargetsChanged() async throws {
|
|
try SkipUnless.longTestsEnabled()
|
|
|
|
let project = try await ExternalBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": """
|
|
#if DEBUG
|
|
#error("DEBUG SET")
|
|
#else
|
|
#error("DEBUG NOT SET")
|
|
#endif
|
|
"""
|
|
],
|
|
buildServer: """
|
|
class BuildServer(AbstractBuildServer):
|
|
has_changed_targets: bool = False
|
|
|
|
def workspace_build_targets(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
if self.has_changed_targets:
|
|
return {
|
|
"targets": [
|
|
{
|
|
"id": {"uri": "bsp://dummy"},
|
|
"tags": [],
|
|
"languageIds": [],
|
|
"dependencies": [],
|
|
"capabilities": {},
|
|
}
|
|
]
|
|
}
|
|
else:
|
|
return {"targets": []}
|
|
|
|
def buildtarget_sources(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
assert self.has_changed_targets
|
|
return {
|
|
"items": [
|
|
{
|
|
"target": {"uri": "bsp://dummy"},
|
|
"sources": [
|
|
{"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
def textdocument_sourcekitoptions(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
assert self.has_changed_targets
|
|
return {
|
|
"compilerArguments": [r"$TEST_DIR/Test.swift", "-DDEBUG", $SDK_ARGS]
|
|
}
|
|
|
|
def workspace_did_change_watched_files(self, notification: Dict[str, object]) -> None:
|
|
self.has_changed_targets = True
|
|
self.send_notification("buildTarget/didChange", {})
|
|
"""
|
|
)
|
|
|
|
let (uri, _) = try project.openDocument("Test.swift")
|
|
|
|
// Initially, we shouldn't have any diagnostics because Test.swift is not part of any target
|
|
let initialDiagnostics = try await project.testClient.send(
|
|
DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
|
|
)
|
|
XCTAssertEqual(initialDiagnostics.fullReport?.items, [])
|
|
|
|
// We use an arbitrary file change to signal to the BSP server that it should send the targets changed notification
|
|
project.testClient.send(
|
|
DidChangeWatchedFilesNotification(changes: [
|
|
FileEvent(uri: try DocumentURI(string: "file:///dummy"), type: .created)
|
|
])
|
|
)
|
|
|
|
// But then the 1s timer in the build server should fire, we get a `buildTarget/didChange` notification and we have
|
|
// build settings for Test.swift
|
|
try await repeatUntilExpectedResult {
|
|
let diags = try await project.testClient.send(
|
|
DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
|
|
)
|
|
return diags.fullReport?.items.map(\.message) == ["DEBUG SET"]
|
|
}
|
|
}
|
|
|
|
func testSettingsOfSingleFileChanged() async throws {
|
|
try SkipUnless.longTestsEnabled()
|
|
|
|
let project = try await ExternalBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": """
|
|
#if DEBUG
|
|
#error("DEBUG SET")
|
|
#else
|
|
#error("DEBUG NOT SET")
|
|
#endif
|
|
"""
|
|
],
|
|
buildServer: """
|
|
class BuildServer(AbstractBuildServer):
|
|
has_changed_settings: bool = False
|
|
|
|
def workspace_build_targets(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"targets": [
|
|
{
|
|
"id": {"uri": "bsp://dummy"},
|
|
"tags": [],
|
|
"languageIds": [],
|
|
"dependencies": [],
|
|
"capabilities": {},
|
|
}
|
|
]
|
|
}
|
|
|
|
def buildtarget_sources(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"items": [
|
|
{
|
|
"target": {"uri": "bsp://dummy"},
|
|
"sources": [
|
|
{"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
def textdocument_sourcekitoptions(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
if self.has_changed_settings:
|
|
return {
|
|
"compilerArguments": [r"$TEST_DIR/Test.swift", "-DDEBUG", $SDK_ARGS]
|
|
}
|
|
else:
|
|
return {
|
|
"compilerArguments": [r"$TEST_DIR/Test.swift", $SDK_ARGS]
|
|
}
|
|
|
|
def workspace_did_change_watched_files(self, notification: Dict[str, object]) -> None:
|
|
self.has_changed_settings = True
|
|
self.send_notification("buildTarget/didChange", {})
|
|
"""
|
|
)
|
|
|
|
let (uri, _) = try project.openDocument("Test.swift")
|
|
|
|
// Initially, we don't have -DDEBUG set, so we should get `DEBUG NOT SET`
|
|
let initialDiagnostics = try await project.testClient.send(
|
|
DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
|
|
)
|
|
XCTAssertEqual(initialDiagnostics.fullReport?.items.map(\.message), ["DEBUG NOT SET"])
|
|
|
|
// We use an arbitrary file change to signal to the BSP server that it should send the targets changed notification
|
|
project.testClient.send(
|
|
DidChangeWatchedFilesNotification(changes: [
|
|
FileEvent(uri: try DocumentURI(string: "file:///dummy"), type: .created)
|
|
])
|
|
)
|
|
|
|
// But then the 1s timer in the build server should fire, we get a `buildTarget/didChange` notification and we get
|
|
// build settings for Test.swift that include -DDEBUG
|
|
try await repeatUntilExpectedResult {
|
|
let diags = try await project.testClient.send(
|
|
DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
|
|
)
|
|
return diags.fullReport?.items.map(\.message) == ["DEBUG SET"]
|
|
}
|
|
}
|
|
|
|
func testCrashRecovery() async throws {
|
|
try SkipUnless.longTestsEnabled()
|
|
|
|
let project = try await ExternalBuildServerTestProject(
|
|
files: [
|
|
"Crash.swift": "",
|
|
"Test.swift": """
|
|
#if DEBUG
|
|
#error("DEBUG SET")
|
|
#else
|
|
#error("DEBUG NOT SET")
|
|
#endif
|
|
""",
|
|
"should_crash": "dummy file to indicate that BSP server should crash",
|
|
],
|
|
buildServer: """
|
|
import threading
|
|
import os
|
|
|
|
class BuildServer(AbstractBuildServer):
|
|
def workspace_build_targets(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"targets": [
|
|
{
|
|
"id": {"uri": "bsp://dummy"},
|
|
"tags": [],
|
|
"languageIds": [],
|
|
"dependencies": [],
|
|
"capabilities": {},
|
|
}
|
|
]
|
|
}
|
|
|
|
def buildtarget_sources(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"items": [
|
|
{
|
|
"target": {"uri": "bsp://dummy"},
|
|
"sources": [
|
|
{"uri": "$TEST_DIR_URL/Crash.swift", "kind": 1, "generated": False},
|
|
{"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False},
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
def textdocument_sourcekitoptions(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
if os.path.exists(r"$TEST_DIR/should_crash"):
|
|
assert False
|
|
return {
|
|
"compilerArguments": [r"$TEST_DIR/Test.swift", "-DDEBUG", $SDK_ARGS]
|
|
}
|
|
"""
|
|
)
|
|
|
|
// Check that we still get results for Test.swift (after relaunching the BSP server)
|
|
let (uri, _) = try project.openDocument("Test.swift")
|
|
|
|
// While the BSP server is crashing, we shouldn't get any build settings and thus get empty diagnostics.
|
|
let diagnosticsBeforeCrash = try await project.testClient.send(
|
|
DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
|
|
)
|
|
XCTAssertEqual(diagnosticsBeforeCrash.fullReport?.items, [])
|
|
try FileManager.default.removeItem(at: project.scratchDirectory.appending(component: "should_crash"))
|
|
|
|
try await repeatUntilExpectedResult(timeout: .seconds(20)) {
|
|
let diagnostics = try await project.testClient.send(
|
|
DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
|
|
)
|
|
return diagnostics.fullReport?.items.map(\.message) == ["DEBUG SET"]
|
|
}
|
|
}
|
|
|
|
func testBuildServerConfigAtLegacyLocation() async throws {
|
|
let project = try await ExternalBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": """
|
|
#if DEBUG
|
|
#error("DEBUG SET")
|
|
#else
|
|
#error("DEBUG NOT SET")
|
|
#endif
|
|
"""
|
|
],
|
|
buildServerConfigLocation: "buildServer.json",
|
|
buildServer: """
|
|
class BuildServer(AbstractBuildServer):
|
|
def workspace_build_targets(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"targets": [
|
|
{
|
|
"id": {"uri": "bsp://dummy"},
|
|
"tags": [],
|
|
"languageIds": [],
|
|
"dependencies": [],
|
|
"capabilities": {},
|
|
}
|
|
]
|
|
}
|
|
|
|
def buildtarget_sources(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"items": [
|
|
{
|
|
"target": {"uri": "bsp://dummy"},
|
|
"sources": [
|
|
{"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
def textdocument_sourcekitoptions(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"compilerArguments": [r"$TEST_DIR/Test.swift", "-DDEBUG", $SDK_ARGS]
|
|
}
|
|
"""
|
|
)
|
|
|
|
let (uri, _) = try project.openDocument("Test.swift")
|
|
|
|
try await repeatUntilExpectedResult {
|
|
let diags = try await project.testClient.send(
|
|
DocumentDiagnosticsRequest(textDocument: TextDocumentIdentifier(uri))
|
|
)
|
|
return diags.fullReport?.items.map(\.message) == ["DEBUG SET"]
|
|
}
|
|
}
|
|
|
|
func testBuildSettingsDataPassThrough() async throws {
|
|
let project = try await ExternalBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": ""
|
|
],
|
|
buildServer: """
|
|
class BuildServer(AbstractBuildServer):
|
|
def workspace_build_targets(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"targets": [
|
|
{
|
|
"id": {"uri": "bsp://dummy"},
|
|
"tags": [],
|
|
"languageIds": [],
|
|
"dependencies": [],
|
|
"capabilities": {},
|
|
}
|
|
]
|
|
}
|
|
|
|
def buildtarget_sources(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"items": [
|
|
{
|
|
"target": {"uri": "bsp://dummy"},
|
|
"sources": [
|
|
{"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
def textdocument_sourcekitoptions(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"compilerArguments": [r"$TEST_DIR/Test.swift"],
|
|
"data": {"custom": "value"}
|
|
}
|
|
""",
|
|
options: .testDefault(experimentalFeatures: [.sourceKitOptionsRequest])
|
|
)
|
|
|
|
let (uri, _) = try project.openDocument("Test.swift")
|
|
|
|
let options = try await project.testClient.send(
|
|
SourceKitOptionsRequest(
|
|
textDocument: TextDocumentIdentifier(uri),
|
|
prepareTarget: false,
|
|
allowFallbackSettings: false
|
|
)
|
|
)
|
|
XCTAssertEqual(options.data, ["custom": "value"])
|
|
}
|
|
|
|
func testBuildSettingsForFilePartOfMultipleTargets() async throws {
|
|
let project = try await ExternalBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": ""
|
|
],
|
|
buildServer: """
|
|
class BuildServer(AbstractBuildServer):
|
|
def workspace_build_targets(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"targets": [
|
|
{
|
|
"id": {"uri": "bsp://first"},
|
|
"tags": [],
|
|
"languageIds": [],
|
|
"dependencies": [],
|
|
"capabilities": {},
|
|
},
|
|
{
|
|
"id": {"uri": "bsp://second"},
|
|
"tags": [],
|
|
"languageIds": [],
|
|
"dependencies": [],
|
|
"capabilities": {},
|
|
}
|
|
]
|
|
}
|
|
|
|
def buildtarget_sources(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return {
|
|
"items": [
|
|
{
|
|
"target": {"uri": "bsp://first"},
|
|
"sources": [
|
|
{"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
|
|
],
|
|
},
|
|
{
|
|
"target": {"uri": "bsp://second"},
|
|
"sources": [
|
|
{"uri": "$TEST_DIR_URL/Test.swift", "kind": 1, "generated": False}
|
|
],
|
|
}
|
|
]
|
|
}
|
|
|
|
def textdocument_sourcekitoptions(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
target_uri = request["target"]["uri"]
|
|
if target_uri == "bsp://first":
|
|
return {
|
|
"compilerArguments": [r"$TEST_DIR/Test.swift", "-DFIRST"]
|
|
}
|
|
elif target_uri == "bsp://second":
|
|
return {
|
|
"compilerArguments": [r"$TEST_DIR/Test.swift", "-DSECOND"]
|
|
}
|
|
else:
|
|
assert False, f"Unknown target {target_uri}"
|
|
""",
|
|
options: .testDefault(experimentalFeatures: [.sourceKitOptionsRequest])
|
|
)
|
|
|
|
let (uri, _) = try project.openDocument("Test.swift")
|
|
|
|
let firstOptions = try await project.testClient.send(
|
|
SourceKitOptionsRequest(
|
|
textDocument: TextDocumentIdentifier(uri),
|
|
target: DocumentURI(string: "bsp://first"),
|
|
prepareTarget: false,
|
|
allowFallbackSettings: false
|
|
)
|
|
)
|
|
assertContains(try XCTUnwrap(firstOptions).compilerArguments, "-DFIRST")
|
|
|
|
let secondOptions = try await project.testClient.send(
|
|
SourceKitOptionsRequest(
|
|
textDocument: TextDocumentIdentifier(uri),
|
|
target: DocumentURI(string: "bsp://second"),
|
|
prepareTarget: false,
|
|
allowFallbackSettings: false
|
|
)
|
|
)
|
|
assertContains(try XCTUnwrap(secondOptions).compilerArguments, "-DSECOND")
|
|
|
|
let optionsWithoutTarget = try await project.testClient.send(
|
|
SourceKitOptionsRequest(
|
|
textDocument: TextDocumentIdentifier(uri),
|
|
prepareTarget: false,
|
|
allowFallbackSettings: false
|
|
)
|
|
)
|
|
// We currently pick the canonical target alphabetically, which means that `bsp://first` wins over `bsp://second`
|
|
assertContains(try XCTUnwrap(optionsWithoutTarget).compilerArguments, "-DFIRST")
|
|
}
|
|
|
|
func testDontBlockBuildServerInitializationIfBuildServerIsUnresponsive() async throws {
|
|
// A build server that responds to the initialize request but not to any other requests.
|
|
final class UnresponsiveBuildServer: CustomBuildServer {
|
|
let inProgressRequestsTracker = CustomBuildServerInProgressRequestTracker()
|
|
|
|
init(projectRoot: URL, connectionToSourceKitLSP: any Connection) {}
|
|
|
|
func buildTargetSourcesRequest(_ request: BuildTargetSourcesRequest) async throws -> BuildTargetSourcesResponse {
|
|
#if os(Windows)
|
|
Sleep(60 * 60 * 1000 /*ms*/)
|
|
#else
|
|
sleep(60 * 60 /*s*/)
|
|
#endif
|
|
XCTFail("Build server should be terminated before finishing the timeout")
|
|
throw ResponseError.methodNotFound(BuildTargetSourcesRequest.method)
|
|
}
|
|
|
|
func textDocumentSourceKitOptionsRequest(
|
|
_ request: TextDocumentSourceKitOptionsRequest
|
|
) async throws -> TextDocumentSourceKitOptionsResponse? {
|
|
#if os(Windows)
|
|
Sleep(60 * 60 * 1000 /*ms*/)
|
|
#else
|
|
sleep(60 * 60 /*s*/)
|
|
#endif
|
|
XCTFail("Build server should be terminated before finishing the timeout")
|
|
throw ResponseError.methodNotFound(TextDocumentSourceKitOptionsRequest.method)
|
|
}
|
|
}
|
|
|
|
// Creating the `CustomBuildServerTestProject` waits for the initialize response and times out if it doesn't receive one.
|
|
// Make sure that we get that response back.
|
|
_ = try await CustomBuildServerTestProject(
|
|
files: ["Test.swift": ""],
|
|
buildServer: UnresponsiveBuildServer.self
|
|
)
|
|
}
|
|
|
|
func testShutdownHangs() async throws {
|
|
let startTime = Date()
|
|
do {
|
|
_ = try await ExternalBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": ""
|
|
],
|
|
buildServer: """
|
|
import time
|
|
|
|
class BuildServer(AbstractBuildServer):
|
|
def workspace_build_targets(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return { "targets": [] }
|
|
|
|
def buildtarget_sources(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
return { "items": [] }
|
|
|
|
def shutdown(self, request: Dict[str, object]) -> Dict[str, object]:
|
|
time.sleep(60)
|
|
assert False
|
|
""",
|
|
options: .testDefault(experimentalFeatures: [.sourceKitOptionsRequest])
|
|
)
|
|
}
|
|
// Check that we didn't wait the full 60 seconds for the build server to shut down and instead terminated it.
|
|
XCTAssert(Date().timeIntervalSince(startTime) < 50)
|
|
}
|
|
|
|
func testCancelPreparationOnLspShutdown() async throws {
|
|
actor BuildServer: CustomBuildServer {
|
|
let inProgressRequestsTracker = CustomBuildServerInProgressRequestTracker()
|
|
private let projectRoot: URL
|
|
let preparationStarted: XCTestExpectation
|
|
let preparationFinished: XCTestExpectation
|
|
|
|
init(projectRoot: URL, connectionToSourceKitLSP: any Connection) {
|
|
self.projectRoot = projectRoot
|
|
self.preparationStarted = XCTestExpectation(description: "Preparation started")
|
|
self.preparationFinished = XCTestExpectation(description: "Preparation finished")
|
|
}
|
|
|
|
func initializeBuildRequest(_ request: InitializeBuildRequest) async throws -> InitializeBuildResponse {
|
|
return try initializationResponseSupportingBackgroundIndexing(
|
|
projectRoot: projectRoot,
|
|
outputPathsProvider: false
|
|
)
|
|
}
|
|
|
|
func buildTargetSourcesRequest(_ request: BuildTargetSourcesRequest) -> BuildTargetSourcesResponse {
|
|
return dummyTargetSourcesResponse(files: [DocumentURI(projectRoot.appending(component: "Test.swift"))])
|
|
}
|
|
|
|
func textDocumentSourceKitOptionsRequest(
|
|
_ request: TextDocumentSourceKitOptionsRequest
|
|
) -> TextDocumentSourceKitOptionsResponse? {
|
|
return TextDocumentSourceKitOptionsResponse(compilerArguments: [request.textDocument.uri.pseudoPath])
|
|
}
|
|
|
|
func prepareTarget(_ request: BuildTargetPrepareRequest) async throws -> BuildTargetPrepareResponse {
|
|
preparationStarted.fulfill()
|
|
await assertThrowsError(try await Task.sleep(for: .seconds(defaultTimeout))) { error in
|
|
XCTAssert(error is CancellationError)
|
|
}
|
|
preparationFinished.fulfill()
|
|
return BuildTargetPrepareResponse()
|
|
}
|
|
}
|
|
|
|
let preparationFinished: XCTestExpectation
|
|
do {
|
|
let project = try await CustomBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": """
|
|
func 1️⃣myTestFunc() {}
|
|
"""
|
|
],
|
|
buildServer: BuildServer.self,
|
|
enableBackgroundIndexing: true,
|
|
pollIndex: false
|
|
)
|
|
try await fulfillmentOfOrThrow(project.buildServer().preparationStarted)
|
|
preparationFinished = try project.buildServer().preparationFinished
|
|
}
|
|
try await fulfillmentOfOrThrow(preparationFinished)
|
|
}
|
|
|
|
func testBuildServerFailsToInitialize() async throws {
|
|
actor BuildServer: CustomBuildServer {
|
|
let inProgressRequestsTracker = CustomBuildServerInProgressRequestTracker()
|
|
|
|
init(projectRoot: URL, connectionToSourceKitLSP: any Connection) {}
|
|
|
|
func initializeBuildRequest(_ request: InitializeBuildRequest) async throws -> InitializeBuildResponse {
|
|
throw ResponseError.unknown("Initialization failed with bad error")
|
|
}
|
|
|
|
func buildTargetSourcesRequest(_ request: BuildTargetSourcesRequest) async throws -> BuildTargetSourcesResponse {
|
|
throw ResponseError.unknown("Not expected to get called")
|
|
}
|
|
|
|
func textDocumentSourceKitOptionsRequest(
|
|
_ request: TextDocumentSourceKitOptionsRequest
|
|
) async throws -> TextDocumentSourceKitOptionsResponse? {
|
|
throw ResponseError.unknown("Not expected to get called")
|
|
}
|
|
}
|
|
|
|
let project = try await CustomBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": """
|
|
func 1️⃣myTestFunc() {}
|
|
"""
|
|
],
|
|
buildServer: BuildServer.self
|
|
)
|
|
let message = try await project.testClient.nextNotification(ofType: ShowMessageNotification.self)
|
|
assertContains(message.message, "Initialization failed with bad error")
|
|
}
|
|
|
|
func testBuildServerTakesLongToReply() async throws {
|
|
actor BuildServer: CustomBuildServer {
|
|
let inProgressRequestsTracker = CustomBuildServerInProgressRequestTracker()
|
|
let projectRoot: URL
|
|
let unlockBuildServerResponses = MultiEntrySemaphore(name: "Build server starts responding")
|
|
var didReceiveTargetSourcesRequest = false
|
|
var didReceiveBuildTargetsRequest = false
|
|
|
|
init(projectRoot: URL, connectionToSourceKitLSP: any Connection) {
|
|
self.projectRoot = projectRoot
|
|
}
|
|
|
|
func workspaceBuildTargetsRequest(
|
|
_ request: WorkspaceBuildTargetsRequest
|
|
) async throws -> WorkspaceBuildTargetsResponse {
|
|
// We should cache the result of the request once we receive it and not re-request information after the build
|
|
// server request timeout has fired
|
|
XCTAssert(!didReceiveBuildTargetsRequest)
|
|
didReceiveBuildTargetsRequest = true
|
|
|
|
await unlockBuildServerResponses.waitOrXCTFail()
|
|
|
|
return WorkspaceBuildTargetsResponse(targets: [
|
|
BuildTarget(
|
|
id: .dummy,
|
|
capabilities: BuildTargetCapabilities(),
|
|
languageIds: [],
|
|
dependencies: []
|
|
)
|
|
])
|
|
}
|
|
|
|
func buildTargetSourcesRequest(_ request: BuildTargetSourcesRequest) async throws -> BuildTargetSourcesResponse {
|
|
// We should cache the result of the request once we receive it and not re-request information after the build
|
|
// server request timeout has fired
|
|
XCTAssert(!didReceiveTargetSourcesRequest)
|
|
didReceiveTargetSourcesRequest = true
|
|
|
|
await unlockBuildServerResponses.waitOrXCTFail()
|
|
return dummyTargetSourcesResponse(files: [DocumentURI(projectRoot.appending(component: "Test.swift"))])
|
|
}
|
|
|
|
func textDocumentSourceKitOptionsRequest(
|
|
_ request: TextDocumentSourceKitOptionsRequest
|
|
) async throws -> TextDocumentSourceKitOptionsResponse? {
|
|
var arguments = [request.textDocument.uri.pseudoPath, "-DFOO"]
|
|
if let defaultSDKPath {
|
|
arguments += ["-sdk", defaultSDKPath]
|
|
}
|
|
return TextDocumentSourceKitOptionsResponse(compilerArguments: arguments)
|
|
}
|
|
}
|
|
|
|
var options = try await SourceKitLSPOptions.testDefault()
|
|
options.buildServerWorkspaceRequestsTimeout = 0.1 /* seconds */
|
|
|
|
let project = try await CustomBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": """
|
|
#if FOO
|
|
func foo() {}
|
|
#endif
|
|
|
|
func test() {
|
|
1️⃣foo()
|
|
}
|
|
"""
|
|
],
|
|
buildServer: BuildServer.self,
|
|
options: options
|
|
)
|
|
|
|
// Check that we can open a document using fallback settings even if the build server is unresponsive.
|
|
let (uri, positions) = try project.openDocument("Test.swift")
|
|
let definitionWithoutBuildServer = try await project.testClient.send(
|
|
DefinitionRequest(textDocument: TextDocumentIdentifier(uri), position: positions["1️⃣"])
|
|
)
|
|
XCTAssertEqual(definitionWithoutBuildServer?.locations, nil)
|
|
try project.buildServer().unlockBuildServerResponses.signal()
|
|
|
|
// Once the build server starts being responsive, we should be able to get actual results.
|
|
try await repeatUntilExpectedResult {
|
|
let definitionsWithBuildServer = try await project.testClient.send(
|
|
DefinitionRequest(textDocument: TextDocumentIdentifier(uri), position: positions["1️⃣"])
|
|
)
|
|
return definitionsWithBuildServer?.locations?.count == 1
|
|
}
|
|
}
|
|
|
|
func testBuildServerTakesLongToInitialize() async throws {
|
|
actor BuildServer: CustomBuildServer {
|
|
let inProgressRequestsTracker = CustomBuildServerInProgressRequestTracker()
|
|
let projectRoot: URL
|
|
let unlockInitializeResponses = MultiEntrySemaphore(name: "Build server starts responding")
|
|
|
|
init(projectRoot: URL, connectionToSourceKitLSP: any Connection) {
|
|
self.projectRoot = projectRoot
|
|
}
|
|
|
|
func initializeBuildRequest(_ request: InitializeBuildRequest) async throws -> InitializeBuildResponse {
|
|
await unlockInitializeResponses.waitOrXCTFail()
|
|
return initializationResponse()
|
|
}
|
|
|
|
func buildTargetSourcesRequest(_ request: BuildTargetSourcesRequest) async throws -> BuildTargetSourcesResponse {
|
|
return dummyTargetSourcesResponse(files: [DocumentURI(projectRoot.appending(component: "Test.swift"))])
|
|
}
|
|
|
|
func textDocumentSourceKitOptionsRequest(
|
|
_ request: TextDocumentSourceKitOptionsRequest
|
|
) async throws -> TextDocumentSourceKitOptionsResponse? {
|
|
var arguments = [request.textDocument.uri.pseudoPath]
|
|
if let defaultSDKPath {
|
|
arguments += ["-sdk", defaultSDKPath]
|
|
}
|
|
return TextDocumentSourceKitOptionsResponse(compilerArguments: arguments)
|
|
}
|
|
}
|
|
|
|
var options = try await SourceKitLSPOptions.testDefault()
|
|
options.buildServerWorkspaceRequestsTimeout = 0.1 /* seconds */
|
|
|
|
let project = try await CustomBuildServerTestProject(
|
|
files: [
|
|
"Test.swift": """
|
|
func foo() {}
|
|
"""
|
|
],
|
|
buildServer: BuildServer.self,
|
|
options: options,
|
|
pollIndex: false
|
|
)
|
|
|
|
let (uri, _) = try project.openDocument("Test.swift")
|
|
_ = try await project.testClient.send(DocumentSymbolRequest(textDocument: TextDocumentIdentifier(uri)))
|
|
|
|
try project.buildServer().unlockInitializeResponses.signal()
|
|
}
|
|
}
|