Add Waitable and Waiter. Update Tests errors (#1)

* Add Waitable and Waiter. Update Tests errors

* Remove escaping from operation parameter

Author: 0xLeif

Sources/Test/Test.swift

@@ -37,14 +37,20 @@ public func Test(
     functionName: String = #function,
     fileName: String = #file
 ) throws {
-    let result = t.suite(named: name) {
-        try operation(tester)
+    var result: Error?
+
+    t.suite(named: name) {
+        do {
+            try operation(tester)
+        } catch {
+            result = error
+        }
     }
 
-    guard result == true else {
+    if let result = result {
         let testName = name.map { "\($0) Test" } ?? "Test"
         throw TestError(
-            description: "\(testName) failed.",
+            description: "\(testName) failed. \(result.localizedDescription)",
             lineNumber: lineNumber,
             functionName: functionName,
             fileName: fileName
@@ -89,14 +95,20 @@ public func Test(
     functionName: String = #function,
     fileName: String = #file
 ) async throws {
-    let result = await t.suite(named: name) {
-        try await operation(tester)
+    var result: Error?
+    
+    await t.suite(named: name) {
+        do {
+            try await operation(tester)
+        } catch {
+            result = error
+        }
     }
 
-    guard result == true else {
+    if let result = result {
         let testName = name.map { "\($0) Test" } ?? "Test"
         throw TestError(
-            description: "\(testName) failed.",
+            description: "\(testName) failed. \(result.localizedDescription)",
             lineNumber: lineNumber,
             functionName: functionName,
             fileName: fileName

Sources/Test/Wait/Waitable+Default.swift

@@ -0,0 +1,69 @@
+import Foundation
+
+extension Waitable {
+    @discardableResult
+    public func wait<Value>(
+        for keyPath: KeyPath<Self, Value>,
+        duration: TimeInterval = 3,
+        interval: TimeInterval = 0.1,
+        expecting: @escaping (Value) -> Bool
+    ) async throws -> Value {
+        try await wait(
+            for: keyPath,
+            interation: 0,
+            duration: abs(duration),
+            interval: abs(interval),
+            expecting: expecting
+        )
+    }
+
+    @discardableResult
+    public func wait<Value: Equatable>(
+        for keyPath: KeyPath<Self, Value>,
+        duration: TimeInterval = 3,
+        interval: TimeInterval = 0.1,
+        expecting: Value
+    ) async throws -> Value {
+        try await wait(
+            for: keyPath,
+            interation: 0,
+            duration: abs(duration),
+            interval: abs(interval),
+            expecting: { value in
+                expecting == value
+            }
+        )
+    }
+
+    private func wait(duration: TimeInterval) async throws {
+        try await Task.sleep(nanoseconds: UInt64(1_000_000_000 * abs(duration)))
+    }
+
+    private func wait<Value>(
+        for keyPath: KeyPath<Self, Value>,
+        interation: UInt,
+        duration: TimeInterval,
+        interval: TimeInterval,
+        expecting: @escaping (Value) -> Bool
+    ) async throws -> Value {
+        guard Double(interation) * interval < duration else {
+            throw WaitableError.timeout(duration)
+        }
+
+        let value = self[keyPath: keyPath]
+
+        if expecting(value) {
+            return value
+        }
+
+        try await wait(duration: interval)
+
+        return try await wait(
+            for: keyPath,
+            interation: interation + 1,
+            duration: duration,
+            interval: interval,
+            expecting: expecting
+        )
+    }
+}

Sources/Test/Wait/Waitable.swift

@@ -0,0 +1,19 @@
+import Foundation
+
+public protocol Waitable {
+    @discardableResult
+    func wait<Value>(
+        for keyPath: KeyPath<Self, Value>,
+        duration: TimeInterval,
+        interval: TimeInterval,
+        expecting: @escaping (Value) -> Bool
+    ) async throws -> Value
+
+    @discardableResult
+    func wait<Value: Equatable>(
+        for keyPath: KeyPath<Self, Value>,
+        duration: TimeInterval,
+        interval: TimeInterval,
+        expecting: Value
+    ) async throws -> Value
+}

Sources/Test/Wait/WaitableError.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+public enum WaitableError: LocalizedError {
+    case timeout(TimeInterval)
+
+    public var errorDescription: String? {
+        switch self {
+        case let .timeout(duration): return "Waitable Timeout: Exceeded duration of \(duration) seconds."
+        }
+    }
+}

Sources/Test/Wait/Waiter.swift

@@ -0,0 +1,9 @@
+import Foundation
+
+public struct Waiter<Value: AnyObject>: Waitable {
+    public var value: Value
+
+    public init(_ value: Value) {
+        self.value = value
+    }
+}

Tests/TestTests/TestTests.swift

@@ -25,7 +25,7 @@ final class TestTests: XCTestCase {
                 ]
             ),
             operation: { tester in
-                try await Expect(description) {
+                try await Expect("Examples") {
                     tester.logInfo("Info!")
 
                     try tester.assert(0, isEqualTo: 0)
@@ -37,4 +37,31 @@ final class TestTests: XCTestCase {
             }
         )
     }
+
+    func testWaiter() async throws {
+        class Value {
+            var count = 0
+        }
+
+        let value = Value()
+        let waiter = Waiter(value)
+
+        try await waiter.wait(
+            for: \.value.count,
+            expecting: 0
+        )
+
+        XCTAssertEqual(value.count, 0)
+
+        Task {
+            try await Task.sleep(nanoseconds: 500_000_000)
+            value.count += 1
+        }
+
+        XCTAssertEqual(value.count, 0)
+
+        try await waiter.wait(for: \.value.count, duration: 2, interval: 0.5, expecting: 1)
+
+        XCTAssertEqual(value.count, 1)
+    }
 }