From 099f4cae2f0fdc9fec06759f08b68da59dec66bb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Stormacq?= <sebastien.stormacq@gmail.com>
Date: Tue, 15 Oct 2024 20:46:50 +0200
Subject: [PATCH 1/7] migrate to swift-test

---
 Package.swift                                 |  11 +-
 .../Router/RouterGraphTest.swift              | 180 ++++++++++--------
 .../Router/RouterNodeTest.swift               | 100 ++++++----
 3 files changed, 174 insertions(+), 117 deletions(-)

diff --git a/Package.swift b/Package.swift
index 63d8d2b..46d51a0 100644
--- a/Package.swift
+++ b/Package.swift
@@ -11,9 +11,10 @@ let package = Package(
     products: [.library(name: "OpenAPILambda", targets: ["OpenAPILambda"])],
     dependencies: [
         .package(url: "https://github.com/apple/swift-openapi-runtime.git", from: "1.0.0"),
-        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.1"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.3"),
         .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "0.3.0"),
         .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
+        .package(url: "https://github.com/apple/swift-testing.git", branch: "main"),
     ],
     targets: [
         .target(
@@ -27,6 +28,12 @@ let package = Package(
             swiftSettings: [.enableExperimentalFeature("StrictConcurrency=complete")]
         ),
         // test targets
-        .testTarget(name: "OpenAPILambdaTests", dependencies: [.byName(name: "OpenAPILambda")]),
+        .testTarget(
+            name: "OpenAPILambdaTests",
+            dependencies: [
+                .byName(name: "OpenAPILambda"),
+                .product(name: "Testing", package: "swift-testing"),
+            ]
+        ),
     ]
 )
diff --git a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
index 4405261..9a53e66 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
@@ -15,10 +15,11 @@
 import HTTPTypes
 import OpenAPIRuntime
 
-import XCTest
+import Testing
 @testable import OpenAPILambda
 
-final class RouterGraphTest: XCTestCase {
+struct RouterGraphTests {
+    @Test("Path with no parameters")
     func testPathNoParams() async throws {
         // given
         let strMethod = "GET"
@@ -29,41 +30,43 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method, path: path, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method, path: path, handler: handler) }
+
         // then
         var node: Node? = graph.root()
 
         // first node is GET
         node = node?.children[strMethod]
         if case .httpMethod(let retrievedMethod) = node?.value {
-            XCTAssert(retrievedMethod == method)
+            #expect(retrievedMethod == method)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
         // all other nodes but last are path elements
         node = node?.children["element1"]
-        XCTAssertNotNil(node)
-        XCTAssert(node?.children.count == 1)
-        if case .pathElement(let element) = node?.value { XCTAssert(element == "element1") }
+        #expect(node != nil)
+        #expect(node?.children.count == 1)
+        if case .pathElement(let element) = node?.value { #expect(element == "element1") }
         node = node?.children["element2"]
-        XCTAssertNotNil(node)
-        XCTAssert(node?.children.count == 1)
-        if case .pathElement(let element) = node?.value { XCTAssert(element == "element2") }
+        #expect(node != nil)
+        #expect(node?.children.count == 1)
+        if case .pathElement(let element) = node?.value { #expect(element == "element2") }
 
         // last node is a handler
         node = node?.children["handler"]
         if case .handler(let retrievedHandler) = node?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
     }
+    @Test("Path with one parameter")
     func testPathOneParams() async throws {
         // given
         let strMethod = "GET"
@@ -74,41 +77,42 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method, path: path, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method, path: path, handler: handler) }
         // then
         var node: Node? = graph.root()
 
         // first node is GET
         node = node?.children[strMethod]
         if case .httpMethod(let retrievedMethod) = node?.value {
-            XCTAssert(retrievedMethod == method)
+            #expect(retrievedMethod == method)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
         // next node  is a  path elements
         node = node?.children["element1"]
-        XCTAssertNotNil(node)
-        XCTAssert(node?.children.count == 1)
-        if case .pathElement(let element) = node?.value { XCTAssert(element == "element1") }
+        #expect(node != nil)
+        #expect(node?.children.count == 1)
+        if case .pathElement(let element) = node?.value { #expect(element == "element1") }
         node = node?.children["param1"]
-        XCTAssertNotNil(node)
-        XCTAssert(node?.children.count == 1)
-        if case .pathParameter(let param) = node?.value { XCTAssert(param == "param1") }
+        #expect(node != nil)
+        #expect(node?.children.count == 1)
+        if case .pathParameter(let param) = node?.value { #expect(param == "param1") }
 
         // last node is a handler
         node = node?.children["handler"]
         if case .handler(let retrievedHandler) = node?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
     }
+    @Test("Two GET paths")
     func testTwoGETPaths() async throws {
         // given
         let strMethod = "GET"
@@ -120,8 +124,8 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method, path: path1, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method, path: path2, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method, path: path1, handler: handler) }
+        #expect(throws: Never.self) { try graph.add(method: method, path: path2, handler: handler) }
 
         // then
         var node: Node? = graph.root()
@@ -129,49 +133,50 @@ final class RouterGraphTest: XCTestCase {
         // first node is GET
         node = node?.children[strMethod]
         if case .httpMethod(let retrievedMethod) = node?.value {
-            XCTAssert(retrievedMethod == method)
+            #expect(retrievedMethod == method)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
         // next nodes are a path elements
         let node1 = node?.children["element1"]
-        XCTAssertNotNil(node1)
-        XCTAssert(node1?.children.count == 1)
-        if case .pathElement(let element) = node1?.value { XCTAssert(element == "element1") }
+        #expect(node1 != nil)
+        #expect(node1?.children.count == 1)
+        if case .pathElement(let element) = node1?.value { #expect(element == "element1") }
 
         let node2 = node?.children["element2"]
-        XCTAssertNotNil(node2)
-        XCTAssert(node2?.children.count == 1)
-        if case .pathElement(let element) = node2?.value { XCTAssert(element == "element2") }
+        #expect(node2 != nil)
+        #expect(node2?.children.count == 1)
+        if case .pathElement(let element) = node2?.value { #expect(element == "element2") }
 
         // last node is a handler
         let node3 = node1?.children["handler"]
-        XCTAssertNotNil(node3)
+        #expect(node3 != nil)
         if case .handler(let retrievedHandler) = node3?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
 
         let node4 = node2?.children["handler"]
-        XCTAssertNotNil(node3)
+        try #require(node4 != nil)
         if case .handler(let retrievedHandler) = node4?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
     }
+    @Test("Multiple HTTP methods")
     func testMultipleHTTPMethods() throws {
         // given
         let strMethod1 = "GET"
@@ -184,8 +189,8 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method1, path: path, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method2, path: path, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method1, path: path, handler: handler) }
+        #expect(throws: Never.self) { try graph.add(method: method2, path: path, handler: handler) }
 
         // then
         var node: Node? = graph.root()
@@ -193,29 +198,29 @@ final class RouterGraphTest: XCTestCase {
         // first node is GET
         let node1 = node?.children[strMethod1]
         if case .httpMethod(let retrievedMethod) = node1?.value {
-            XCTAssert(retrievedMethod == method1)
+            #expect(retrievedMethod == method1)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
         // but there is also a POST node at level 1
         let node2 = node?.children[strMethod2]
         if case .httpMethod(let retrievedMethod) = node2?.value {
-            XCTAssert(retrievedMethod == method2)
+            #expect(retrievedMethod == method2)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
 
         // all other nodes but last are path elements
         node = node1?.children["element1"]
-        XCTAssertNotNil(node1)
-        XCTAssert(node1?.children.count == 1)
-        if case .pathElement(let element) = node1?.value { XCTAssert(element == "element1") }
+        #expect(node1 != nil)
+        #expect(node1?.children.count == 1)
+        if case .pathElement(let element) = node1?.value { #expect(element == "element1") }
         node = node2?.children["element2"]
-        XCTAssertNotNil(node2)
-        XCTAssert(node2?.children.count == 1)
-        if case .pathElement(let element) = node2?.value { XCTAssert(element == "element2") }
+        #expect(node2 != nil)
+        #expect(node2?.children.count == 1)
+        if case .pathElement(let element) = node2?.value { #expect(element == "element2") }
     }
     //    func testDeepSearch() {
     //        // given
@@ -270,6 +275,7 @@ final class RouterGraphTest: XCTestCase {
     //        }
     //    }
 
+    @Test("No method path")
     func testNoMethodPath() {
         // given
         let strMethod = "GET"
@@ -279,8 +285,13 @@ final class RouterGraphTest: XCTestCase {
         // when
         // then
         let noExistingMethod = HTTPRequest.Method("POST")!
-        XCTAssertThrowsError(try graph.find(method: noExistingMethod, path: "/dummy"))
+        // #expect(throws: OpenAPILambdaRouterError.noRouteForMethod(noExistingMethod).self) {
+        #expect(throws: OpenAPILambdaRouterError.self) {
+            try graph.find(method: noExistingMethod, path: "/dummy")
+        }
     }
+
+    @Test("No two param children")
     func testNoTwoParamChilds() {
         let strMethod = "GET"
         let method = HTTPRequest.Method(strMethod)!
@@ -291,10 +302,15 @@ final class RouterGraphTest: XCTestCase {
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
         // when
-        XCTAssertNoThrow(try graph.add(method: method, path: path1, handler: handler))
+        #expect(throws: Never.self) { try graph.add(method: method, path: path1, handler: handler) }
+
         // then
-        XCTAssertThrowsError(try graph.add(method: method, path: path2, handler: handler))
+        #expect(throws: URIPathCollectionError.self) {
+            try graph.add(method: method, path: path2, handler: handler)
+        }
     }
+
+    @Test("Find handler 1")
     func testFindHandler1() throws {
         // given
         let strMethod = "GET"
@@ -303,11 +319,13 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element1/element2"
 
         //when
-        XCTAssertNoThrow(try graph.find(method: method, path: pathToTest))
+        #expect(throws: Never.self) { try graph.find(method: method, path: pathToTest) }
         let (handler, metadata) = try graph.find(method: method, path: pathToTest)
-        XCTAssert(metadata.count == 0)
-        XCTAssertNotNil(handler)
+        #expect(metadata.count == 0)
+        #expect(handler != nil)
     }
+
+    @Test("Find handler 2")
     func testFindHandler2() throws {
         // given
         let strMethod = "GET"
@@ -316,12 +334,13 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element3/value1/element4"
 
         //when
-        XCTAssertNoThrow(try graph.find(method: method, path: pathToTest))
+        #expect(throws: Never.self) { try graph.find(method: method, path: pathToTest) }
         let (handler, metadata) = try graph.find(method: method, path: pathToTest)
-        XCTAssert(metadata.count == 1)
-        XCTAssertNotNil(handler)
+        #expect(metadata.count == 1)
+        #expect(handler != nil)
     }
 
+    @Test("Find handler 3")
     func testFindHandler3() throws {
         // given
         let strMethod = "GET"
@@ -330,12 +349,13 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element5/value1"
 
         //when
-        XCTAssertNoThrow(try graph.find(method: method, path: pathToTest))
+        #expect(throws: Never.self) { try graph.find(method: method, path: pathToTest) }
         let (handler, metadata) = try graph.find(method: method, path: pathToTest)
-        XCTAssert(metadata.count == 1)
-        XCTAssertNotNil(handler)
+        #expect(metadata.count == 1)
+        #expect(handler != nil)
     }
 
+    @Test("Find handler error 1")
     func testFindHandlerError1() throws {
         // given
         let strMethod = "GET"
@@ -344,9 +364,12 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element6/value1"
 
         //when
-        XCTAssertThrowsError(try graph.find(method: method, path: pathToTest))
+        #expect(throws: OpenAPILambdaRouterError.self) {
+            try graph.find(method: method, path: pathToTest)
+        }
     }
 
+    @Test("Find handler error 2")
     func testFindHandlerError2() throws {
         // given
         let strMethod = "GET"
@@ -355,9 +378,12 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element6"
 
         //when
-        XCTAssertThrowsError(try graph.find(method: method, path: pathToTest))
+        #expect(throws: OpenAPILambdaRouterError.self) {
+            try graph.find(method: method, path: pathToTest)
+        }
     }
 
+    @Test("Find handler error no HTTP method")
     func testFindHandlerErrorNoHttpMethod() throws {
         // given
         let strMethod = "GET"
@@ -366,7 +392,9 @@ final class RouterGraphTest: XCTestCase {
         let pathToTest = "/element1/element2"
 
         //when
-        XCTAssertThrowsError(try graph.find(method: HTTPRequest.Method(rawValue: "POST")!, path: pathToTest))
+        #expect(throws: OpenAPILambdaRouterError.self) {
+            try graph.find(method: HTTPRequest.Method(rawValue: "POST")!, path: pathToTest)
+        }
     }
 
     private func prepareGraph(for method: HTTPRequest.Method) -> URIPath {
@@ -376,8 +404,8 @@ final class RouterGraphTest: XCTestCase {
         let bodyString = "bodyString"
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
-        XCTAssertNoThrow(try graph.add(method: method, path: path1, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method, path: path2, handler: handler))
+        try! graph.add(method: method, path: path1, handler: handler)
+        try! graph.add(method: method, path: path2, handler: handler)
         return graph
     }
 
@@ -389,9 +417,9 @@ final class RouterGraphTest: XCTestCase {
         let bodyString = "bodyString"
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
 
-        XCTAssertNoThrow(try graph.add(method: method, path: path1, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method, path: path2, handler: handler))
-        XCTAssertNoThrow(try graph.add(method: method, path: path3, handler: handler))
+        try! graph.add(method: method, path: path1, handler: handler)
+        try! graph.add(method: method, path: path2, handler: handler)
+        try! graph.add(method: method, path: path3, handler: handler)
 
         return graph
     }
diff --git a/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift b/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
index bd6a4c1..7f53a5d 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
@@ -15,128 +15,147 @@
 import HTTPTypes
 import OpenAPIRuntime
 
-import XCTest
+import Testing
 @testable import OpenAPILambda
 
-final class RouterNodeTest: XCTestCase {
+struct RouterNodeTests {
+    @Test("First node is root")
     func testFirstNodeIsRoot() throws {
         // given
         let node = Node()
         // when
         guard case .root = node.value else {
-            XCTFail("Top level node is not root")
+            Issue.record("Top level node is not root")
             return
         }
         // then
         // succeed
     }
+
+    @Test("Add path element")
     func testAddPathElement() throws {
         // given
         let pathElement = "test"
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(pathElement: pathElement))
+        #expect(throws: Never.self) { try node.add(pathElement: pathElement) }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         let child = node.children[pathElement]
         if case .pathElement(let element) = child?.value {
-            XCTAssert(element == pathElement)
+            #expect(element == pathElement)
         }
         else {
-            XCTFail("Not a path element")
+            Issue.record("Not a path element")
         }
     }
+
+    @Test("Add HTTP method")
     func testAddHTTPMethod() throws {
         // given
         let methodStr = "GET"
         let method = HTTPRequest.Method(methodStr)!
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(httpMethod: method))
+        #expect(throws: Never.self) { try node.add(httpMethod: method) }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         let child = node.children[methodStr]
         if case .httpMethod(let retrievedMethod) = child?.value {
-            XCTAssert(retrievedMethod == method)
+            #expect(retrievedMethod == method)
         }
         else {
-            XCTFail("Not an HTTP method")
+            Issue.record("Not an HTTP method")
         }
     }
+
+    @Test("Add parameter")
     func testAddParameter() throws {
         // given
         let parameter = "parameter"
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(parameter: "parameter"))
+        #expect(throws: Never.self) { try node.add(parameter: "parameter") }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         let child = node.children[parameter]
         if case .pathParameter(let param) = child?.value {
-            XCTAssert(param == parameter)
+            #expect(param == parameter)
         }
         else {
-            XCTFail("Not a parameter")
+            Issue.record("Not a parameter")
         }
     }
+
+    @Test("Add handler")
     func testAddHandler() async throws {
         // given
         let bodyString = "bodyString"
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(handler: handler))
+        #expect(throws: Never.self) { try node.add(handler: handler) }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         let child = node.children["handler"]
         if case .handler(let retrievedHandler) = child?.value {
             let request = HTTPRequest(method: .init("GET")!, scheme: "https", authority: nil, path: "")
             let (response, body) = try await retrievedHandler(request, nil, ServerRequestMetadata())
-            XCTAssert(response.status == .ok)
+            #expect(response.status == .ok)
             let retrievedBody = try? await String(collecting: body ?? "", upTo: 10 * 1024 * 1024)
-            XCTAssert(retrievedBody == bodyString)
+            #expect(retrievedBody == bodyString)
         }
         else {
-            XCTFail("Not a handler")
+            Issue.record("Not a handler")
         }
     }
+
+    @Test("Cannot add node to handler")
     func testCanNotAddNodeToHandler() {
         // given
         let bodyString = "bodyString"
         let handler: OpenAPIHandler = { a, b, c in (HTTPResponse(status: .ok), HTTPBody(bodyString)) }
         let node = Node()
-        XCTAssertNoThrow(try node.add(handler: handler))
+        let _ = try? node.add(handler: handler)
         // when
         let child = node.children["handler"]
         // should throw an error
-        XCTAssertThrowsError(try child?.add(pathElement: "test"))
+        #expect(throws: URIPathCollectionError.self) {
+            try child?.add(pathElement: "test")
+        }
     }
+
+    @Test("Add duplicate node")
     func testAddDuplicateNode() throws {
         // given
         let pathElement = "test"
         let node = Node()
         // when
-        XCTAssertNoThrow(try node.add(pathElement: pathElement))
-        XCTAssertNoThrow(try node.add(pathElement: pathElement))
+        #expect(throws: Never.self) { try node.add(pathElement: pathElement) }
+        #expect(throws: Never.self) { try node.add(pathElement: pathElement) }
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
     }
+
+    @Test("Returns new node")
     func testReturnsNewNode() throws {
         // given
         let pathElement = "test"
         let node = Node()
         // when
         let newNode = try? node.add(pathElement: pathElement)
-        XCTAssertNotNil(newNode)
+        #expect(newNode != nil)
         // then
-        XCTAssert(node.children.count == 1)
+        #expect(node.children.count == 1)
         if case .pathElement(let element) = newNode?.value {
-            XCTAssert(element == pathElement)
+            #expect(element == pathElement)
         }
         else {
-            XCTFail("Not a path element")
+            Issue.record("Not a path element")
         }
     }
+
+    @Test("Returns existing child")
     func testReturnsExistingChild() throws {
         // given
         let pathElement = "test"
@@ -144,18 +163,20 @@ final class RouterNodeTest: XCTestCase {
         // when
         let _ = try? node.add(pathElement: pathElement)
         let existingNode = try? node.add(pathElement: pathElement)
-        XCTAssertNotNil(existingNode)
+        #expect(existingNode != nil)
 
         // then
-        XCTAssert(node.children.count == 1)
-        XCTAssert(existingNode?.children.count == 0)
+        #expect(node.children.count == 1)
+        #expect(existingNode?.children.count == 0)
         if case .pathElement(let element) = existingNode?.value {
-            XCTAssert(element == pathElement)
+            #expect(element == pathElement)
         }
         else {
-            XCTFail("Not a path element")
+            Issue.record("Not a path element")
         }
     }
+
+    @Test("Retrieve param child exists")
     func testRetrieveParamChildExist() {
         // given
         let pathElement = "element1"
@@ -163,14 +184,15 @@ final class RouterNodeTest: XCTestCase {
 
         // when
         let pathNode = try? root.add(pathElement: pathElement)
-        XCTAssertNotNil(pathNode)
+        #expect(pathNode != nil)
         let _ = try? pathNode?.add(parameter: "param1")
 
         // then
         let paramNode = pathNode!.parameterChild()
-        XCTAssertNotNil(paramNode)
-
+        #expect(paramNode != nil)
     }
+
+    @Test("Retrieve param child does not exist")
     func testRetrieveParamChildNOTExist() {
         // given
         let pathElement = "element1"
@@ -178,12 +200,12 @@ final class RouterNodeTest: XCTestCase {
 
         // when
         let pathNode = try? root.add(pathElement: pathElement)
-        XCTAssertNotNil(pathNode)
+        #expect(pathNode != nil)
         let _ = try? pathNode?.add(pathElement: "element2")
 
         // then
         let paramNode = pathNode!.parameterChild()
-        XCTAssertNil(paramNode)
+        #expect(paramNode == nil)
     }
 
 }

From 61d9ff2433c75bcae9d89cf3d5c2468ee5996a71 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Stormacq?= <sebastien.stormacq@gmail.com>
Date: Tue, 15 Oct 2024 21:00:20 +0200
Subject: [PATCH 2/7] differentiate swift 6

---
 Package-5.10.swift                            | 37 +++++++++++++++++++
 .../Router/RouterGraphTest.swift              |  2 +
 .../Router/RouterNodeTest.swift               |  5 ++-
 3 files changed, 43 insertions(+), 1 deletion(-)
 create mode 100644 Package-5.10.swift

diff --git a/Package-5.10.swift b/Package-5.10.swift
new file mode 100644
index 0000000..c2d845b
--- /dev/null
+++ b/Package-5.10.swift
@@ -0,0 +1,37 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "swift-openapi-lambda",
+    platforms: [
+        .macOS(.v12), .iOS(.v15), .tvOS(.v15), .watchOS(.v8),
+    ],
+    products: [.library(name: "OpenAPILambda", targets: ["OpenAPILambda"])],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-openapi-runtime.git", from: "1.0.0"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.3"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "0.3.0"),
+        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
+    ],
+    targets: [
+        .target(
+            name: "OpenAPILambda",
+            dependencies: [
+                .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
+                .product(name: "AWSLambdaEvents", package: "swift-aws-lambda-events"),
+                .product(name: "OpenAPIRuntime", package: "swift-openapi-runtime"),
+            ],
+            path: "Sources",
+            swiftSettings: [.enableExperimentalFeature("StrictConcurrency=complete")]
+        ),
+        // test targets
+        .testTarget(
+            name: "OpenAPILambdaTests",
+            dependencies: [
+                .byName(name: "OpenAPILambda"),
+            ]
+        ),
+    ]
+)
diff --git a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
index 9a53e66..d872bed 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
@@ -15,6 +15,7 @@
 import HTTPTypes
 import OpenAPIRuntime
 
+#if swift(>=6.0)
 import Testing
 @testable import OpenAPILambda
 
@@ -425,3 +426,4 @@ struct RouterGraphTests {
     }
 
 }
+#endif
diff --git a/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift b/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
index 7f53a5d..8fe069a 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
@@ -15,9 +15,11 @@
 import HTTPTypes
 import OpenAPIRuntime
 
-import Testing
 @testable import OpenAPILambda
 
+#if swift(>=6.0)
+import Testing
+
 struct RouterNodeTests {
     @Test("First node is root")
     func testFirstNodeIsRoot() throws {
@@ -209,3 +211,4 @@ struct RouterNodeTests {
     }
 
 }
+#endif

From d230244d93ef87efd3c6ed47e8eee794e69d0a6d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Stormacq?= <sebastien.stormacq@gmail.com>
Date: Tue, 15 Oct 2024 21:00:47 +0200
Subject: [PATCH 3/7] fix

---
 Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
index d872bed..ac12864 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
@@ -15,9 +15,10 @@
 import HTTPTypes
 import OpenAPIRuntime
 
+@testable import OpenAPILambda
+
 #if swift(>=6.0)
 import Testing
-@testable import OpenAPILambda
 
 struct RouterGraphTests {
     @Test("Path with no parameters")
@@ -426,4 +427,4 @@ struct RouterGraphTests {
     }
 
 }
-#endif
+#endif
\ No newline at end of file

From 306b74e35798f0187143f331019a7af300c1487a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Stormacq?= <sebastien.stormacq@gmail.com>
Date: Tue, 15 Oct 2024 21:01:40 +0200
Subject: [PATCH 4/7] swift-fromat

---
 Package-5.10.swift                                    | 2 +-
 Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Package-5.10.swift b/Package-5.10.swift
index c2d845b..265ea88 100644
--- a/Package-5.10.swift
+++ b/Package-5.10.swift
@@ -30,7 +30,7 @@ let package = Package(
         .testTarget(
             name: "OpenAPILambdaTests",
             dependencies: [
-                .byName(name: "OpenAPILambda"),
+                .byName(name: "OpenAPILambda")
             ]
         ),
     ]
diff --git a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
index ac12864..4f5b3cf 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
@@ -427,4 +427,4 @@ struct RouterGraphTests {
     }
 
 }
-#endif
\ No newline at end of file
+#endif

From e1d689689d66d1fe3656709c28f8d67a2360ab72 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Stormacq?= <sebastien.stormacq@gmail.com>
Date: Tue, 15 Oct 2024 21:03:49 +0200
Subject: [PATCH 5/7] fix

---
 ...age-5.10.swift => Package@swift-5.10.swift |  2 +-
 Package@swift-5.9.swift                       | 37 +++++++++++++++++++
 2 files changed, 38 insertions(+), 1 deletion(-)
 rename Package-5.10.swift => Package@swift-5.10.swift (98%)
 create mode 100644 Package@swift-5.9.swift

diff --git a/Package-5.10.swift b/Package@swift-5.10.swift
similarity index 98%
rename from Package-5.10.swift
rename to Package@swift-5.10.swift
index 265ea88..c9d55cc 100644
--- a/Package-5.10.swift
+++ b/Package@swift-5.10.swift
@@ -1,4 +1,4 @@
-// swift-tools-version: 5.9
+// swift-tools-version: 5.10
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
diff --git a/Package@swift-5.9.swift b/Package@swift-5.9.swift
new file mode 100644
index 0000000..c9d55cc
--- /dev/null
+++ b/Package@swift-5.9.swift
@@ -0,0 +1,37 @@
+// swift-tools-version: 5.10
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "swift-openapi-lambda",
+    platforms: [
+        .macOS(.v12), .iOS(.v15), .tvOS(.v15), .watchOS(.v8),
+    ],
+    products: [.library(name: "OpenAPILambda", targets: ["OpenAPILambda"])],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-openapi-runtime.git", from: "1.0.0"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-runtime.git", from: "1.0.0-alpha.3"),
+        .package(url: "https://github.com/swift-server/swift-aws-lambda-events.git", from: "0.3.0"),
+        .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.3.0"),
+    ],
+    targets: [
+        .target(
+            name: "OpenAPILambda",
+            dependencies: [
+                .product(name: "AWSLambdaRuntime", package: "swift-aws-lambda-runtime"),
+                .product(name: "AWSLambdaEvents", package: "swift-aws-lambda-events"),
+                .product(name: "OpenAPIRuntime", package: "swift-openapi-runtime"),
+            ],
+            path: "Sources",
+            swiftSettings: [.enableExperimentalFeature("StrictConcurrency=complete")]
+        ),
+        // test targets
+        .testTarget(
+            name: "OpenAPILambdaTests",
+            dependencies: [
+                .byName(name: "OpenAPILambda")
+            ]
+        ),
+    ]
+)

From 4333b4e6ddce1c0e00998a6f5bae05b8279756c3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Stormacq?= <sebastien.stormacq@gmail.com>
Date: Tue, 15 Oct 2024 21:08:57 +0200
Subject: [PATCH 6/7] fix

---
 Package.swift           | 2 +-
 Package@swift-5.9.swift | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Package.swift b/Package.swift
index 46d51a0..136d5cc 100644
--- a/Package.swift
+++ b/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version: 5.9
+// swift-tools-version: 6.0
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
diff --git a/Package@swift-5.9.swift b/Package@swift-5.9.swift
index c9d55cc..265ea88 100644
--- a/Package@swift-5.9.swift
+++ b/Package@swift-5.9.swift
@@ -1,4 +1,4 @@
-// swift-tools-version: 5.10
+// swift-tools-version: 5.9
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription

From d9ca6a42a93df966d92f11d860b503e853b75904 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Stormacq?= <sebastien.stormacq@gmail.com>
Date: Tue, 15 Oct 2024 21:20:32 +0200
Subject: [PATCH 7/7] add comment

---
 Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift | 1 +
 Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift  | 1 +
 2 files changed, 2 insertions(+)

diff --git a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
index 4f5b3cf..beecae5 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterGraphTest.swift
@@ -17,6 +17,7 @@ import OpenAPIRuntime
 
 @testable import OpenAPILambda
 
+// only run unit tests on Swift 6.x
 #if swift(>=6.0)
 import Testing
 
diff --git a/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift b/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
index 8fe069a..dee9a86 100644
--- a/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
+++ b/Tests/OpenAPILambdaTests/Router/RouterNodeTest.swift
@@ -17,6 +17,7 @@ import OpenAPIRuntime
 
 @testable import OpenAPILambda
 
+// only run unit tests on Swift 6.x
 #if swift(>=6.0)
 import Testing