Migrate to Swift Testing (#70)

Migrating `swift-service-context` 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 10 tests with `swift test --disable-xctest`.

Author: kukushechkin

CONTRIBUTING.md

@@ -50,7 +50,38 @@ A good patch is:
 
 ### 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/ServiceContextTests/ServiceContextTests.swift

@@ -12,33 +12,37 @@
 //
 //===----------------------------------------------------------------------===//
 
-import XCTest
+import Testing
 
 @testable import ServiceContextModule
 
-final class ServiceContextTests: XCTestCase {
-    func test_topLevelServiceContextIsEmpty() {
+@Suite("ServiceContext Tests")
+struct ServiceContextTests {
+    @Test("Top-level ServiceContext is empty")
+    func topLevelServiceContextIsEmpty() {
         let context = ServiceContext.topLevel
 
-        XCTAssertTrue(context.isEmpty)
-        XCTAssertEqual(context.count, 0)
+        #expect(context.isEmpty)
+        #expect(context.count == 0)
     }
 
-    func test_readAndWriteThroughSubscript() throws {
+    @Test("Read and write values through subscript")
+    func readAndWriteThroughSubscript() throws {
         var context = ServiceContext.topLevel
-        XCTAssertNil(context[FirstTestKey.self])
-        XCTAssertNil(context[SecondTestKey.self])
+        #expect(context[FirstTestKey.self] == nil)
+        #expect(context[SecondTestKey.self] == nil)
 
         context[FirstTestKey.self] = 42
         context[SecondTestKey.self] = 42.0
 
-        XCTAssertFalse(context.isEmpty)
-        XCTAssertEqual(context.count, 2)
-        XCTAssertEqual(context[FirstTestKey.self], 42)
-        XCTAssertEqual(context[SecondTestKey.self], 42.0)
+        #expect(!context.isEmpty)
+        #expect(context.count == 2)
+        #expect(context[FirstTestKey.self] == 42)
+        #expect(context[SecondTestKey.self] == 42.0)
     }
 
-    func test_forEachIteratesOverAllServiceContextItems() {
+    @Test("Context forEach iterates over all context items")
+    func forEachIteratesOverAllServiceContextItems() {
         var context = ServiceContext.topLevel
 
         context[FirstTestKey.self] = 42
@@ -50,51 +54,59 @@ final class ServiceContextTests: XCTestCase {
         context.forEach { key, value in
             contextItems[key] = value
         }
-        XCTAssertEqual(contextItems.count, 3)
-        XCTAssertTrue(contextItems.contains(where: { $0.key.name == "FirstTestKey" }))
-        XCTAssertTrue(contextItems.contains(where: { $0.value as? Int == 42 }))
-        XCTAssertTrue(contextItems.contains(where: { $0.key.name == "SecondTestKey" }))
-        XCTAssertTrue(contextItems.contains(where: { $0.value as? Double == 42.0 }))
-        XCTAssertTrue(contextItems.contains(where: { $0.key.name == "explicit" }))
-        XCTAssertTrue(contextItems.contains(where: { $0.value as? String == "test" }))
+        #expect(contextItems.count == 3)
+        #expect(contextItems.contains(where: { $0.key.name == "FirstTestKey" }))
+        #expect(contextItems.contains(where: { $0.value as? Int == 42 }))
+        #expect(contextItems.contains(where: { $0.key.name == "SecondTestKey" }))
+        #expect(contextItems.contains(where: { $0.value as? Double == 42.0 }))
+        #expect(contextItems.contains(where: { $0.key.name == "explicit" }))
+        #expect(contextItems.contains(where: { $0.value as? String == "test" }))
     }
 
-    func test_TODO_doesNotCrashWithoutExplicitCompilerFlag() {
+    @Test("TODO Context does not crash without explicit compiler flag")
+    func TODO_doesNotCrashWithoutExplicitCompilerFlag() {
         _ = ServiceContext.TODO(#function)
     }
 
-    func test_serviceContextKeyName_withoutOverride() {
+    @Test("ServiceContextKey name defaults to type name without override")
+    func serviceContextKeyName_withoutOverride() {
         let name = FirstTestKey.name
-        XCTAssertEqual(name, "FirstTestKey")
+        #expect(name == "FirstTestKey")
     }
 
-    func test_serviceContextKeyName_withOverride() {
+    @Test("ServiceContextKey name uses explicit override when provided")
+    func serviceContextKeyName_withOverride() {
         let name = ThirdTestKey.name
-        XCTAssertEqual(name, "explicit")
+        #expect(name == "explicit")
     }
 
-    func test_anyServiceContextKeyName_withoutOverride() {
+    @Test("AnyServiceContextKey name defaults to type name without override")
+    func anyServiceContextKeyName_withoutOverride() {
         let anyKey = AnyServiceContextKey(FirstTestKey.self)
-        XCTAssertEqual(anyKey.name, "FirstTestKey")
+        #expect(anyKey.name == "FirstTestKey")
     }
 
-    func test_anyServiceContextKeyName_withOverride() {
+    @Test("AnyServiceContextKey name uses explicit override when provided")
+    func anyServiceContextKeyName_withOverride() {
         let anyKey = AnyServiceContextKey(ThirdTestKey.self)
-        XCTAssertEqual(anyKey.name, "explicit")
+        #expect(anyKey.name == "explicit")
     }
 
-    func test_serviceContextKeyName_matchesAnyServiceContextKeyName() {
-        XCTAssertEqual(FirstTestKey.name, AnyServiceContextKey(FirstTestKey.self).name)
-        XCTAssertEqual(SecondTestKey.name, AnyServiceContextKey(SecondTestKey.self).name)
-        XCTAssertEqual(ThirdTestKey.name, AnyServiceContextKey(ThirdTestKey.self).name)
+    @Test("ServiceContextKey name matches AnyServiceContextKey name")
+    func serviceContextKeyName_matchesAnyServiceContextKeyName() {
+        #expect(FirstTestKey.name == AnyServiceContextKey(FirstTestKey.self).name)
+        #expect(SecondTestKey.name == AnyServiceContextKey(SecondTestKey.self).name)
+        #expect(ThirdTestKey.name == AnyServiceContextKey(ThirdTestKey.self).name)
     }
 
-    func test_automaticPropagationThroughTaskLocal() throws {
+    @Test("Automatic propagation through task-local storage")
+    func automaticPropagationThroughTaskLocal() throws {
         guard #available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) else {
-            throw XCTSkip("Task locals are not supported on this platform.")
+            #expect(Bool(true), "Task locals are not supported on this platform.")
+            return
         }
 
-        XCTAssertNil(ServiceContext.current)
+        #expect(ServiceContext.current == nil)
 
         var context = ServiceContext.topLevel
         context[FirstTestKey.self] = 42
@@ -107,8 +119,8 @@ final class ServiceContextTests: XCTestCase {
         let c = ServiceContext.$current
         c.withValue(context, operation: exampleFunction)
 
-        XCTAssertEqual(propagatedServiceContext?.count, 1)
-        XCTAssertEqual(propagatedServiceContext?[FirstTestKey.self], 42)
+        #expect(propagatedServiceContext?.count == 1)
+        #expect(propagatedServiceContext?[FirstTestKey.self] == 42)
     }
 
     actor SomeActor {