Migrate from XCTest to Swift Testing (#195)

Migrating `swift-distributed-tracing` from XCTest to Swift Testing

### Motivation

Swift Testing is a modern alternative to XCTest. Swift Server Ecosystem
packages should serve as reference implementations for modern Swift
features and best practices.

### Modifications

- 1-to-1 migration of test suites, tests, and assertions to Swift
Testing syntax with XCTest import removed

### Result

Successfully executes 57 tests with `swift test --disable-xctest`.

Author: kukushechkin

CONTRIBUTING.md

@@ -56,7 +56,38 @@ We require that your commit messages match our template. The easiest way to do t
 
 ### Run CI checks locally
 
-You can run the Github Actions workflows locally using [act](https://github.com/nektos/act). For detailed steps on how to do this please see [https://github.com/swiftlang/github-workflows?tab=readme-ov-file#running-workflows-locally](https://github.com/swiftlang/github-workflows?tab=readme-ov-file#running-workflows-locally).
+You can run the Github Actions workflows locally using
+[act](https://github.com/nektos/act). To run all the jobs that run on a pull
+request, use the following command:
+
+```
+% act pull_request
+```
+
+To run just a single job, use `workflow_call -j <job>`, and specify the inputs
+the job expects. For example, to run just shellcheck:
+
+```
+% act workflow_call -j soundness --input shell_check_enabled=true
+```
+
+To bind-mount the working directory to the container, rather than a copy, use
+`--bind`. For example, to run just the formatting, and have the results
+reflected in your working directory:
+
+```
+% act --bind workflow_call -j soundness --input format_check_enabled=true
+```
+
+If you'd like `act` to always run with certain flags, these can be be placed in
+an `.actrc` file either in the current working directory or your home
+directory, for example:
+
+```
+--container-architecture=linux/amd64
+--remote-name upstream
+--action-offline-mode
+```
 
 ## How to contribute your work
 

Tests/InMemoryTracingTests/InMemoryTracerTests.swift

@@ -12,11 +12,10 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if canImport(Testing)
+@_spi(Testing) import InMemoryTracing
 @_spi(Locking) import Instrumentation
 import Testing
 import Tracing
-@_spi(Testing) import InMemoryTracing
 
 @Suite("InMemoryTracer")
 struct InMemoryTracerTests {
@@ -437,5 +436,3 @@ private final class MockClock {
         Instant(nanosecondsSinceEpoch: self._now)
     }
 }
-
-#endif

Tests/InstrumentationTests/InstrumentTests.swift

@@ -12,12 +12,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Foundation
 import Instrumentation
 import ServiceContextModule
-import XCTest
+import Testing
 
-final class InstrumentTests: XCTestCase {
-    func testMultiplexInvokesAllInstruments() {
+@Suite("MultiplexInstrument")
+struct InstrumentTests {
+    @Test("MultiplexInstrument invokes all instruments")
+    func multiplexInvokesAllInstruments() {
         let instrument = MultiplexInstrument([
             FirstFakeTracer(),
             SecondFakeTracer(),
@@ -26,15 +29,14 @@ final class InstrumentTests: XCTestCase {
         var context = ServiceContext.topLevel
         instrument.extract([String: String](), into: &context, using: DictionaryExtractor())
 
-        XCTAssertEqual(context[FirstFakeTracer.TraceIDKey.self], FirstFakeTracer.defaultTraceID)
-        XCTAssertEqual(context[SecondFakeTracer.TraceIDKey.self], SecondFakeTracer.defaultTraceID)
+        #expect(context[FirstFakeTracer.TraceIDKey.self] == FirstFakeTracer.defaultTraceID)
+        #expect(context[SecondFakeTracer.TraceIDKey.self] == SecondFakeTracer.defaultTraceID)
 
         var subsequentRequestHeaders = ["Accept": "application/json"]
         instrument.inject(context, into: &subsequentRequestHeaders, using: DictionaryInjector())
 
-        XCTAssertEqual(
-            subsequentRequestHeaders,
-            [
+        #expect(
+            subsequentRequestHeaders == [
                 "Accept": "application/json",
                 FirstFakeTracer.headerName: FirstFakeTracer.defaultTraceID,
                 SecondFakeTracer.headerName: SecondFakeTracer.defaultTraceID,

Tests/TracingTests/ActorTracingTests.swift

@@ -13,14 +13,19 @@
 //===----------------------------------------------------------------------===//
 
 import ServiceContextModule
+import Testing
 import Tracing
-import XCTest
 
 @testable import Instrumentation
 
 /// This is a compile-time test
-final class ActorTracingTests: XCTestCase {
-    func test() {}
+@Suite("Actor Tracing Compatibility")
+struct ActorTracingTests {
+    @Test("Compiles with actor isolation")
+    func compilesWithActorIsolation() {
+        // This test exists purely to verify that the code compiles
+        // with Swift's strict concurrency checking
+    }
 }
 
 func work() async {}

Tests/TracingTests/DynamicTracepointTracerTests.swift

@@ -12,14 +12,17 @@
 //
 //===----------------------------------------------------------------------===//
 
+import Foundation
 import ServiceContextModule
+import Testing
 import Tracing
-import XCTest
 
 @testable import Instrumentation
 
-final class DynamicTracepointTracerTests: XCTestCase {
-    func test_adhoc_enableBySourceLoc() {
+@Suite("Dynamic Tracepoint Tracer Tests")
+struct DynamicTracepointTracerTests {
+    @Test("Ad-hoc tracepoint enable by source location")
+    func adhoc_enableBySourceLoc() {
         let tracer = DynamicTracepointTestTracer()
 
         let fileID = #fileID
@@ -49,16 +52,17 @@ final class DynamicTracepointTracerTests: XCTestCase {
             }
         }
 
-        XCTAssertEqual(tracer.spans.count, 4)
+        #expect(tracer.spans.count == 4)
 
         for span in tracer.spans {
-            XCTAssertEqual(span.context.traceID, "trace-id-fake-\(fileID)-\(fakeLine)")
+            #expect(span.context.traceID == "trace-id-fake-\(fileID)-\(fakeLine)")
         }
-        XCTAssertEqual(tracer.spans[0].context.spanID, "span-id-fake-\(fileID)-\(fakeLine)")
-        XCTAssertEqual(tracer.spans[1].context.spanID, "span-id-fake-\(fileID)-\(fakeNextLine)")
+        #expect(tracer.spans[0].context.spanID == "span-id-fake-\(fileID)-\(fakeLine)")
+        #expect(tracer.spans[1].context.spanID == "span-id-fake-\(fileID)-\(fakeNextLine)")
     }
 
-    func test_adhoc_enableByFunction() {
+    @Test("Ad-hoc tracepoint enable by function")
+    func adhoc_enableByFunction() {
         let tracer = DynamicTracepointTestTracer()
 
         let fileID = #fileID
@@ -70,12 +74,12 @@ final class DynamicTracepointTracerTests: XCTestCase {
         self.logic(fakeLine: 55, tracer: tracer)
         self.traceMeLogic(fakeLine: fakeLine, tracer: tracer)
 
-        XCTAssertEqual(tracer.spans.count, 2)
+        #expect(tracer.spans.count == 2)
         for span in tracer.spans {
-            XCTAssertEqual(span.context.traceID, "trace-id-fake-\(fileID)-\(fakeLine)")
+            #expect(span.context.traceID == "trace-id-fake-\(fileID)-\(fakeLine)")
         }
-        XCTAssertEqual(tracer.spans[0].context.spanID, "span-id-fake-\(fileID)-\(fakeLine)")
-        XCTAssertEqual(tracer.spans[1].context.spanID, "span-id-fake-\(fileID)-\(fakeNextLine)")
+        #expect(tracer.spans[0].context.spanID == "span-id-fake-\(fileID)-\(fakeLine)")
+        #expect(tracer.spans[1].context.spanID == "span-id-fake-\(fileID)-\(fakeNextLine)")
     }
 
     func logic(fakeLine: UInt, tracer: any Tracer) {