Add Guarantees Support (#39)

* Add Guarantees Support

Sources/AwaitKit/AwaitKit.swift

@@ -72,3 +72,14 @@ public func await<T>(_ body: @escaping () throws -> T) throws -> T {
 public func await<T>(_ promise: Promise<T>) throws -> T {
   return try Queue.await.ak.await(promise)
 }
+
+/**
+ Awaits that the given guarantee resolved and returns its value or throws an error if the current and target queues are the same.
+ - parameter guarantee: The guarantee to resolve.
+ - throws: when the queues are the same.
+ - returns: The value of the guarantee when it is resolved.
+ */
+@discardableResult
+public func await<T>(_ guarantee: Guarantee<T>) throws -> T {
+  return try Queue.await.ak.await(guarantee)
+}

Sources/AwaitKit/DispatchQueue+Await.swift

@@ -87,4 +87,38 @@ extension Extension where Base: DispatchQueue {
 
     return unwrappedResult
   }
+
+  /**
+   Awaits that the given guarantee resolved on the receiver and returns its value or throws an error if the current and target queues are the same.
+
+   - parameter guarantee: The guarantee to resolve.
+   - throws: when the queues are the same.
+   - returns: The value of the guarantee when it is resolved.
+   */
+  @discardableResult
+  public final func await<T>(_ guarantee: Guarantee<T>) throws -> T {
+    guard self.base.label != DispatchQueue.main.label else {
+      throw NSError(domain: "com.yannickloriot.awaitkit", code: 0, userInfo: [
+        NSLocalizedDescriptionKey: "Operation was aborted.",
+        NSLocalizedFailureReasonErrorKey: "The current and target queues are the same."
+        ])
+    }
+
+    var result: T?
+
+    let semaphore = DispatchSemaphore(value: 0)
+
+    guarantee
+      .then(on: self.base) { value -> Guarantee<Void> in
+        result = value
+
+        semaphore.signal()
+
+        return Guarantee()
+      }
+
+    _ = semaphore.wait(timeout: .distantFuture)
+
+    return result!
+  }
 }

Tests/AwaitKitTests/AwaitKitAwaitTests.swift

@@ -46,6 +46,20 @@ class AwaitKitAwaitTests: XCTestCase {
     XCTAssertEqual(name, "AwaitedPromiseKit")
   }
 
+  func testSimpleAwaitGuarantee() {
+    let guarantee: Guarantee<String> = Guarantee { fulfill in
+      let deadlineTime = DispatchTime.now() + .seconds(1)
+
+      backgroundQueue.asyncAfter(deadline: deadlineTime, execute: {
+        fulfill("AwaitedPromiseKit")
+      })
+    }
+
+    let name = try! await(guarantee)
+
+    XCTAssertEqual(name, "AwaitedPromiseKit")
+  }
+
   func testSimpleFailedAwaitPromise() {
     let promise: Promise<String> = Promise { seal in
       let deadlineTime = DispatchTime.now() + .seconds(1)
@@ -66,6 +80,14 @@ class AwaitKitAwaitTests: XCTestCase {
     XCTAssertNotNil(promise.value)
   }
 
+  func testNoValueAwaitGuarantee() {
+    let guarantee: Guarantee<Void> = Guarantee { fulfill in
+      fulfill(())
+    }
+
+    XCTAssertNotNil(guarantee.value)
+  }
+
   func testAwaitBlock() {
     var name: String = try! await {
       return "AwaitedPromiseKit"

Tests/AwaitKitTests/AwaitKitTests.swift

@@ -29,15 +29,23 @@ import PromiseKit
 import XCTest
 
 class AwaitKitTests: XCTestCase {
-  func testExcludeSameQueue() {
+  func testExcludeSameQueuePromise() {
     let promise = Promise<Void> { seal in
       seal.fulfill(())
     }
 
     XCTAssertThrowsError(try DispatchQueue.main.ak.await(promise))
   }
 
-  func testAsyncAndAwaitOnDifferentQueue() {
+  func testExcludeSameQueueGuarantee() {
+    let guarantee = Guarantee<Void> { fulfill in
+      fulfill(())
+    }
+
+    XCTAssertThrowsError(try DispatchQueue.main.ak.await(guarantee))
+  }
+
+  func testAsyncAndAwaitOnDifferentQueuePromise() {
     let expect = expectation(description: "Async should fulfill")
 
     let promise = Promise<Void> { seal in
@@ -57,7 +65,27 @@ class AwaitKitTests: XCTestCase {
     waitForExpectations(timeout: 0.1, handler: nil)
   }
 
-  func testImbricationQueue() {
+  func testAsyncAndAwaitOnDifferentQueueGuarantee() {
+    let expect = expectation(description: "Async should fulfill")
+
+    let guarantee = Guarantee<Void> { fulfill in
+      fulfill(())
+    }
+
+    let result: Promise<Void> = async {
+      try await(guarantee)
+    }
+
+    _ = result.then { _ -> Promise<Void> in
+      expect.fulfill()
+
+      return Promise()
+    }
+
+    waitForExpectations(timeout: 0.1, handler: nil)
+  }
+
+  func testImbricationQueuePromise() {
     let expect = expectation(description: "Async should fulfill")
 
     let promise = Promise<Void> { seal in
@@ -76,4 +104,24 @@ class AwaitKitTests: XCTestCase {
 
     waitForExpectations(timeout: 0.1, handler: nil)
   }
+
+  func testImbricationQueueGuarantee() {
+    let expect = expectation(description: "Async should fulfill")
+
+    let guarantee = Guarantee<Void> { fulfill in
+      fulfill(())
+    }
+
+    let result: Promise<Void> = async {
+      try await(async { try await(guarantee) })
+    }
+
+    _ = result.then { _ -> Promise<Void> in
+      expect.fulfill()
+
+      return Promise()
+    }
+
+    waitForExpectations(timeout: 0.1, handler: nil)
+  }
 }