Let's update testing

Author: akbashev

Sources/SWIMNIOExample/SWIMNIOShell.swift

@@ -51,8 +51,8 @@ public final class SWIMNIOShell: Sendable {
     }
 
     /// Cancellable of the periodicPingTimer (if it was kicked off)
-    private let _nextPeriodicTickCancellable: Mutex<SWIMCancellable?> = .init(.none)
-    private var nextPeriodicTickCancellable: SWIMCancellable? {
+    private let _nextPeriodicTickCancellable: Mutex<Task<Void, any Error>?> = .init(.none)
+    private var nextPeriodicTickCancellable: Task<Void, any Error>? {
         get { _nextPeriodicTickCancellable.withLock { $0 } }
         set { _nextPeriodicTickCancellable.withLock { $0 = newValue } }
     }
@@ -66,7 +66,6 @@ public final class SWIMNIOShell: Sendable {
         self.settings = settings
 
         self.channel = try .init(wrappingChannelSynchronously: channel)
-//        self.eventLoop = channel.
 
         let myself = try SWIM.NIOPeer(node: node, channel: channel)
         self.myself = myself
@@ -97,12 +96,6 @@ public final class SWIMNIOShell: Sendable {
     /// Upon shutdown the myself member is marked as `.dead`, although it should not be expected to spread this
     /// information to other nodes. It technically could, but it is not expected not required to.
     public func receiveShutdown() {
-//        guard self.eventLoop.inEventLoop else {
-//            return self.eventLoop.execute {
-//                self.receiveShutdown()
-//            }
-//        }
-
         self.nextPeriodicTickCancellable?.cancel()
         switch self.swim.confirmDead(peer: self.peer) {
         case .applied(let change):
@@ -112,26 +105,10 @@ public final class SWIMNIOShell: Sendable {
             () // ok
         }
     }
-
-    /// Start a *single* timer, to run the passed task after given delay.
-//    @discardableResult
-//    private func schedule(delay: Duration, _ task: @Sendable @escaping () -> Void) -> SWIMCancellable {
-//        self.eventLoop.assertInEventLoop()
-
-//        let scheduled: Scheduled<Void> = self.eventLoop.scheduleTask(in: delay.toNIO) { () in task() }
-//        return SWIMCancellable { scheduled.cancel() }
-//    }
-
     // ==== ------------------------------------------------------------------------------------------------------------
     // MARK: Receiving messages
 
     public func receiveMessage(message: SWIM.Message) {
-//        guard self.eventLoop.inEventLoop else {
-//            return self.eventLoop.execute {
-//                self.receiveMessage(message: message)
-//            }
-//        }
-
         self.tracelog(.receive, message: "\(message)")
 
         switch message {
@@ -148,12 +125,6 @@ public final class SWIMNIOShell: Sendable {
 
     /// Allows for typical local interactions with the shell
     public func receiveLocalMessage(message: SWIM.LocalMessage) {
-//        guard self.eventLoop.inEventLoop else {
-//            return self.eventLoop.execute {
-//                self.receiveLocalMessage(message: message)
-//            }
-//        }
-
         self.tracelog(.receive, message: "\(message)")
 
         switch message {
@@ -166,12 +137,6 @@ public final class SWIMNIOShell: Sendable {
     }
 
     private func receivePing(pingOrigin: SWIM.NIOPeer, payload: SWIM.GossipPayload<SWIM.NIOPeer>?, sequenceNumber: SWIM.SequenceNumber) {
-//        guard self.eventLoop.inEventLoop else {
-//            return self.eventLoop.execute {
-//                self.receivePing(pingOrigin: pingOrigin, payload: payload, sequenceNumber: sequenceNumber)
-//            }
-//        }
-
         self.log.trace("Received ping@\(sequenceNumber)", metadata: self.swim.metadata([
             "swim/ping/pingOrigin": "\(pingOrigin.swimNode)",
             "swim/ping/payload": "\(String(describing: payload))",
@@ -199,12 +164,6 @@ public final class SWIMNIOShell: Sendable {
         payload: SWIM.GossipPayload<SWIM.NIOPeer>?,
         sequenceNumber: SWIM.SequenceNumber
     ) {
-//        guard self.eventLoop.inEventLoop else {
-//            return self.eventLoop.execute {
-//                self.receivePingRequest(target: target, pingRequestOrigin: pingRequestOrigin, payload: payload, sequenceNumber: sequenceNumber)
-//            }
-//        }
-
         self.log.trace("Received pingRequest", metadata: [
             "swim/pingRequest/origin": "\(pingRequestOrigin.node)",
             "swim/pingRequest/sequenceNumber": "\(sequenceNumber)",
@@ -244,12 +203,6 @@ public final class SWIMNIOShell: Sendable {
         pingRequestOriginPeer: SWIM.NIOPeer?,
         pingRequestSequenceNumber: SWIM.SequenceNumber?
     ) {
-//        guard self.eventLoop.inEventLoop else {
-//            return self.eventLoop.execute {
-//                self.receivePingResponse(response: response, pingRequestOriginPeer: pingRequestOriginPeer, pingRequestSequenceNumber: pingRequestSequenceNumber)
-//            }
-//        }
-
         self.log.trace("Receive ping response: \(response)", metadata: self.swim.metadata([
             "swim/pingRequest/origin": "\(pingRequestOriginPeer, orElse: "nil")",
             "swim/pingRequest/sequenceNumber": "\(pingRequestSequenceNumber, orElse: "nil")",
@@ -283,11 +236,6 @@ public final class SWIMNIOShell: Sendable {
     }
 
     func receiveEveryPingRequestResponse(result: SWIM.PingResponse<SWIM.NIOPeer, SWIM.NIOPeer>, pingedPeer: SWIM.NIOPeer) {
-//        guard self.eventLoop.inEventLoop else {
-//            return self.eventLoop.execute {
-//                self.receiveEveryPingRequestResponse(result: result, pingedPeer: pingedPeer)
-//            }
-//        }
         self.tracelog(.receive(pinged: pingedPeer), message: "\(result)")
         let directives = self.swim.onEveryPingRequestResponse(result, pinged: pingedPeer)
         if !directives.isEmpty {
@@ -301,12 +249,6 @@ public final class SWIMNIOShell: Sendable {
     }
 
     func receivePingRequestResponse(result: SWIM.PingResponse<SWIM.NIOPeer, SWIM.NIOPeer>, pingedPeer: SWIM.NIOPeer) {
-//        guard self.eventLoop.inEventLoop else {
-//            return self.eventLoop.execute {
-//                self.receivePingRequestResponse(result: result, pingedPeer: pingedPeer)
-//            }
-//        }
-
         self.tracelog(.receive(pinged: pingedPeer), message: "\(result)")
         // TODO: do we know here WHO replied to us actually? We know who they told us about (with the ping-req), could be useful to know
 
@@ -394,7 +336,6 @@ public final class SWIMNIOShell: Sendable {
         // We are only interested in successful pings, as a single success tells us the node is
         // still alive. Therefore we propagate only the first success, but no failures.
         // The failure case is handled through the timeout of the whole operation.
-//        let firstSuccessPromise = self.eventLoop.makePromise(of: SWIM.PingResponse<SWIM.NIOPeer, SWIM.NIOPeer>.self)
         let pingTimeout = directive.timeout
         let target = directive.target
         let startedSendingPingRequestsSentAt: ContinuousClock.Instant = .now
@@ -415,7 +356,8 @@ public final class SWIMNIOShell: Sendable {
                             target: target,
                             payload: payload,
                             from: self.peer,
-                            timeout: pingTimeout, sequenceNumber: sequenceNumber
+                            timeout: pingTimeout,
+                            sequenceNumber: sequenceNumber
                         )
 
                         // we only record successes
@@ -428,10 +370,19 @@ public final class SWIMNIOShell: Sendable {
                             // While this has a slight timing implication on time timeout of the pings -- the node that is last
                             // in the list that we ping, has slightly less time to fulfil the "total ping timeout"; as we set a total timeout on the entire `firstSuccess`.
                             // In practice those timeouts will be relatively large (seconds) and the few millis here should not have a large impact on correctness.
-//                            firstSuccessPromise.succeed(response)
+                            self.swim.metrics.shell.pingRequestResponseTimeFirst.record(duration: startedSendingPingRequestsSentAt.duration(to: .now))
+                            self.receivePingRequestResponse(result: response, pingedPeer: target)
                         }
                     } catch {
-                        self.receiveEveryPingRequestResponse(result: .timeout(target: target, pingRequestOrigin: self.myself, timeout: pingTimeout, sequenceNumber: sequenceNumber), pingedPeer: target)
+                        self.receiveEveryPingRequestResponse(
+                            result: .timeout(
+                                target: target,
+                                pingRequestOrigin: self.myself,
+                                timeout: pingTimeout,
+                                sequenceNumber: sequenceNumber
+                            ),
+                            pingedPeer: target
+                        )
                         // these are generally harmless thus we do not want to log them on higher levels
                         self.log.trace("Failed pingRequest", metadata: [
                             "swim/target": "\(target)",
@@ -443,19 +394,6 @@ public final class SWIMNIOShell: Sendable {
                 }
             }
         }
-
-//        // guaranteed to be on "our" EL
-//        firstSuccessPromise.futureResult.whenComplete { result in
-//            switch result {
-//            case .success(let response):
-//                self.swim.metrics.shell.pingRequestResponseTimeFirst.record(duration: startedSendingPingRequestsSentAt.duration(to: .now))
-//                self.receivePingRequestResponse(result: response, pingedPeer: target)
-//
-//            case .failure(let error):
-//                self.log.debug("Failed to pingRequest via \(directive.requestDetails.count) peers", metadata: ["pingRequest/target": "\(target)", "error": "\(error)"])
-//                self.receivePingRequestResponse(result: .timeout(target: target, pingRequestOrigin: nil, timeout: pingTimeout, sequenceNumber: 0), pingedPeer: target) // sequence number does not matter
-//            }
-//        }
     }
 
     // ==== ------------------------------------------------------------------------------------------------------------
@@ -465,8 +403,6 @@ public final class SWIMNIOShell: Sendable {
     ///
     /// This is the heart of the periodic gossip performed by SWIM.
     func handlePeriodicProtocolPeriodTick() {
-//        self.eventLoop.assertInEventLoop()
-
         let directives = self.swim.onPeriodicPingTick()
         for directive in directives {
             switch directive {
@@ -480,23 +416,17 @@ public final class SWIMNIOShell: Sendable {
                 }
 
             case .scheduleNextTick(let delay):
-                break
-//                self.nextPeriodicTickCancellable = self.schedule(delay: delay) {
-//                    self.handlePeriodicProtocolPeriodTick()
-//                }
+                self.nextPeriodicTickCancellable = Task {
+                    try await Task.sleep(for: delay)
+                    self.handlePeriodicProtocolPeriodTick()
+                }
             }
         }
     }
 
     /// Extra functionality, allowing external callers to ask this swim shell to start monitoring a specific node.
     // TODO: Add some attempts:Int + maxAttempts: Int and handle them appropriately; https://github.com/apple/swift-cluster-membership/issues/32
     private func receiveStartMonitoring(node: Node) {
-//        guard self.eventLoop.inEventLoop else {
-//            return self.eventLoop.execute {
-//                self.receiveStartMonitoring(node: node)
-//            }
-//        }
-
         guard self.node.withoutUID != node.withoutUID else {
             return // no need to monitor ourselves, nor a replacement of us (if node is our replacement, we should have been dead already)
         }

Tests/ClusterMembershipDocumentationTests/SWIMDocExamples.swift

@@ -18,6 +18,6 @@ import SWIM
 
 // end::imports[]
 
-import XCTest
+import Testing
 
-final class SWIMDocExamples: XCTestCase {}
+struct SWIMDocExamples {}

Tests/ClusterMembershipTests/NodeTests.swift

@@ -13,31 +13,35 @@
 //===----------------------------------------------------------------------===//
 
 @testable import ClusterMembership
-import XCTest
+import Testing
 
-final class NodeTests: XCTestCase {
+struct NodeTests {
+   
     let firstNode = ClusterMembership.Node(protocol: "test", host: "127.0.0.1", port: 7001, uid: 1111)
     let secondNode = ClusterMembership.Node(protocol: "test", host: "127.0.0.1", port: 7002, uid: 2222)
     let thirdNode = ClusterMembership.Node(protocol: "test", host: "127.0.0.2", port: 7001, uid: 3333)
 
+    @Test
     func testCompareSameProtocolAndHost() throws {
-        XCTAssertLessThan(self.firstNode, self.secondNode)
-        XCTAssertGreaterThan(self.secondNode, self.firstNode)
-        XCTAssertNotEqual(self.firstNode, self.secondNode)
+        #expect(self.firstNode < self.secondNode)
+        #expect(self.secondNode > self.firstNode)
+        #expect(self.firstNode != self.secondNode)
     }
 
+    @Test
     func testCompareDifferentHost() throws {
-        XCTAssertLessThan(self.firstNode, self.thirdNode)
-        XCTAssertGreaterThan(self.thirdNode, self.firstNode)
-        XCTAssertNotEqual(self.firstNode, self.thirdNode)
-        XCTAssertLessThan(self.secondNode, self.thirdNode)
-        XCTAssertGreaterThan(self.thirdNode, self.secondNode)
+        #expect(self.firstNode < self.thirdNode)
+        #expect(self.thirdNode > self.firstNode)
+        #expect(self.firstNode != self.thirdNode)
+        #expect(self.secondNode < self.thirdNode)
+        #expect(self.thirdNode > self.secondNode)
     }
 
+    @Test
     func testSort() throws {
         let nodes: Set<ClusterMembership.Node> = [secondNode, firstNode, thirdNode]
         let sorted_nodes = nodes.sorted()
 
-        XCTAssertEqual(sorted_nodes, [self.firstNode, self.secondNode, self.thirdNode])
+        #expect(sorted_nodes == [self.firstNode, self.secondNode, self.thirdNode])
     }
 }

Tests/LinuxMain.swift

@@ -17,9 +17,10 @@ import Foundation
 import NIO
 import SWIM
 @testable import SWIMNIOExample
-import XCTest
+import Testing
 
-final class CodingTests: XCTestCase {
+struct CodingTests {
+    
     lazy var nioPeer: SWIM.NIOPeer = SWIM.NIOPeer(node: .init(protocol: "udp", host: "127.0.0.1", port: 1111, uid: 12121), channel: try! .init(wrappingChannelSynchronously: EmbeddedChannel()))
     lazy var nioPeerOther: SWIM.NIOPeer = SWIM.NIOPeer(node: .init(protocol: "udp", host: "127.0.0.1", port: 2222, uid: 234_324), channel: try! .init(wrappingChannelSynchronously: EmbeddedChannel()))
 
@@ -28,15 +29,16 @@ final class CodingTests: XCTestCase {
     lazy var memberThree = SWIM.Member(peer: nioPeer, status: .alive(incarnation: 2), protocolPeriod: 0)
 
     // TODO: add some more "nasty" cases, since the node parsing code is very manual and not hardened / secure
+    @Test
     func test_serializationOf_node() throws {
         try self.shared_serializationRoundtrip(
-            ContainsNode(node: Node(protocol: "udp", host: "127.0.0.1", port: 1111, uid: 12121))
+            Node(protocol: "udp", host: "127.0.0.1", port: 1111, uid: 12121)
         )
         try self.shared_serializationRoundtrip(
-            ContainsNode(node: Node(protocol: "udp", host: "127.0.0.1", port: 1111, uid: nil))
+            Node(protocol: "udp", host: "127.0.0.1", port: 1111, uid: nil)
         )
         try self.shared_serializationRoundtrip(
-            ContainsNode(node: Node(protocol: "udp", host: "127.0.0.1", port: 1111, uid: .random(in: 0 ... UInt64.max)))
+            Node(protocol: "udp", host: "127.0.0.1", port: 1111, uid: .random(in: 0 ... UInt64.max))
         )
         try self.shared_serializationRoundtrip(
             Node(protocol: "udp", host: "127.0.0.1", port: 1111, uid: .random(in: 0 ... UInt64.max))
@@ -48,15 +50,18 @@ final class CodingTests: XCTestCase {
         )
     }
 
-    func test_serializationOf_peer() throws {
-        try self.shared_serializationRoundtrip(ContainsPeer(peer: self.nioPeer))
+    @Test
+    mutating func test_serializationOf_peer() throws {
+        try self.shared_serializationRoundtrip(self.nioPeer)
     }
 
-    func test_serializationOf_member() throws {
-        try self.shared_serializationRoundtrip(ContainsMember(member: self.memberOne))
+    @Test
+    mutating func test_serializationOf_member() throws {
+        try self.shared_serializationRoundtrip(self.memberOne)
     }
 
-    func test_serializationOf_ping() throws {
+    @Test
+    mutating func test_serializationOf_ping() throws {
         let payloadSome: SWIM.GossipPayload = .init(
             members: [
                 self.memberOne,
@@ -67,7 +72,8 @@ final class CodingTests: XCTestCase {
         try self.shared_serializationRoundtrip(SWIM.Message.ping(replyTo: self.nioPeer, payload: payloadSome, sequenceNumber: 1212))
     }
 
-    func test_serializationOf_pingReq() throws {
+    @Test
+    mutating func test_serializationOf_pingReq() throws {
         try self.shared_serializationRoundtrip(
             SWIM.Message.pingRequest(
                 target: self.nioPeer,
@@ -96,21 +102,6 @@ final class CodingTests: XCTestCase {
         decoder.userInfo[.channelUserInfoKey] = EmbeddedChannel()
         let deserialized = try decoder.decode(T.self, from: repr)
 
-        XCTAssertEqual("\(obj)", "\(deserialized)")
+        #expect("\(obj)" == "\(deserialized)")
     }
 }
-
-// This is a workaround until Swift 5.2.5 is available with the "top level string value encoding" support.
-struct ContainsPeer: Codable {
-    let peer: SWIM.NIOPeer
-}
-
-// This is a workaround until Swift 5.2.5 is available with the "top level string value encoding" support.
-struct ContainsMember: Codable {
-    let member: SWIM.Member<SWIM.NIOPeer>
-}
-
-// This is a workaround until Swift 5.2.5 is available with the "top level string value encoding" support.
-struct ContainsNode: Codable {
-    let node: ClusterMembership.Node
-}