khanlou / promise Goto Github PK

extension Promises {
    public static func allSettled<T>(_ promises: [Promise<T>]) -> Promise<[T?]> {
        return Promises.all(promises.map { promise in
            return Promise { fulfill, reject in
                promise.then { value in
                    fulfill(value)
                }.catch { _ in
                    fulfill(nil)
                }
            }
        })
    }
}

func testQueues() {
    var then: DispatchTime!
    var always: DispatchTime!
    weak var expectation = self.expectation(description: "Threading is hard!")
    Promise(value: 1)
    .then(on: DispatchQueue.global(qos: .default), { value in
        return 2
    })
    .then(on: DispatchQueue.global(qos: .background)) { value -> Promise<Int> in
        return Promise<Int>(queue: .main) { s, f in
            DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(3)) {
                s(3)
            }
        }
    }
    .then(on: DispatchQueue.global(qos: .background)) { value in
        return 4
    }
    .then(on: DispatchQueue.global(qos: .utility), { value in
        then = DispatchTime.now()
    })
    .catch(on: DispatchQueue.global(qos: .default)) { err in
        // do nothing, won't fail
    }
    .then(on: DispatchQueue.global(qos: .default)) { value in
        always = DispatchTime.now()
        XCTAssert(then != nil)
        XCTAssert(always > then)
        expectation?.fulfill()
    }
    waitForExpectations(timeout: 5, handler: nil)
}

private func fireCallbacksIfCompleted() {
    lockQueue.async(execute: {
        guard !self.state.isPending else { return }
        self.callbacks.forEach { callback in
            switch self.state {
            case let .fulfilled(value):
                callback.callFulfill(value)
            case let .rejected(error):
                callback.callReject(error)
            default:
                break
            }
        }
        self.callbacks.removeAll()
    })
}

    func verify(userId: String, withToken: String) -> Promise<Void> {
        Promise<Void>(work: { [self] fulfill, reject in
            let networking = makeClient(headers: ["X-Application-Publishable-Key" : apiKey])
            networking.post("/api/users/\(userId)/verify/", parameters: ["token" : withToken]) { result in
                switch result {
                case .success(let response):
                    fulfill() <---- PROBLEM HERE
                case .failure(let response):
                    //unpack the error etc 
                    reject(clientError)
                }
            }
        })
    }

    public static func join<T1, T2>(_ p1: Promise<T1>, _ p2: Promise<T2>) -> Promise<(T1, T2)> {
        return Promise<(T1, T2)>(work: { fulfill, reject in
            p1.then({ value in
                if let p2val = p2.value {
                    fulfill((value, p2val))
                }
            }).catch(reject)
            p2.then({ value in
                if let p1val = p1.value {
                    fulfill((p1val, value))
                }
            }).catch(reject)
        })
    }

    public static func join<T1, T2, T3>(_ p1: Promise<T1>, _ p2: Promise<T2>, _ last: Promise<T3>) -> Promise<(T1, T2, T3)> {
        return Promise<(T1, T2, T3)>(work: { fulfill, reject in
            let joined = join(p1, p2)

            func callFulfill(_ joinedVal: (T1, T2), _ lastVal: T3) -> Void {
                fulfill((joinedVal.0, joinedVal.1, lastVal))
            }

            joined.then({ value in
                if let lastval = last.value {
                    callFulfill(value, lastval)
                }
            }).catch(reject)
            last.then({ value in
                if let jval = joined.value {
                    callFulfill(jval, value)
                }
            }).catch(reject)
        })
    }

func types(_ n: Int) -> String {
    return (1...n).map { "T\($0)" }.joined(separator: ", ")
}


func createJoin(_ n: Int) -> String {
    var output: String = "public static func join<"
    output.append(types(n))
    output.append(">(")
    output.append((1...n-1).map { "_ p\($0): Promise<T\($0)>, " }.joined())
    output.append("_ last: Promise<T\(n)>) -> Promise<(\(types(n)))> {\n")

    output.append("return Promise<(\(types(n)))>(work: { fulfill, reject in\n")

    output.append("let joined = join(")
    output.append((1...n-1).map { "p\($0)" }.joined(separator: ", "))
    output.append(")\n\n")

    output.append("func callFulfill(_ joinedVal: (\(types(n-1))), _ lastVal: T\(n)) -> Void {\n")

    output.append("fulfill((")
    output.append((0...n-2).map { "joinedVal.\($0), " }.joined())
    output.append("lastVal))\n")
    output.append("}\n\n")

    ["joined.then({ value in",
     "if let lastval = last.value {",
     "callFulfill(value, lastval)",
     "}",
     "}).catch(reject)",
     "last.then({ value in",
     "if let jval = joined.value {",
     "callFulfill(jval, value)",
     "}",
     "}).catch(reject)"].forEach { line in
        output.append(line)
        output.append("\n")
    }

    output.append("})\n}")

    return output
}

print(createJoin(3))

    func promiseAny() -> Promise<Any> {
        return Promise<Any> { fulfill, _ in
            fulfill("a")
        }
    }
    
    func testMatch() {
        let exp = expectation(description: "")
        Promise<Int>(value: 1).then { _ in
            return self.promiseAny()
        }.then { value in
            XCTAssert(value == "a")
            exp.fulfill()
        }
        waitForExpectations(timeout: 1, handler: nil)
    }

import Foundation
import Promise

class Chain {

    func verify(userId: String, withToken: String) -> Promise<Void> {
        chunk1()
            .then { [self] result in
                chunk2()
            }
            .then {
                print("All done!")
            }
    }

    func chunk1() -> Promise<String> {
        first()
            .then { [self] result in
                second()
            }
            .then { [self] result in
                third()
            }
            .then { [self] result in
                fourth()
            }
    }

    func chunk2() -> Promise<String> {
        fifth()
            .then { [self] result in
                sixth()
            }
            .then { [self] result in
                seventh()
            }
            .then { [self] result in
                eighth()
            }
    }

    func first() -> Promise<String> {
        Promise<String>(work: { fulfill, reject in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 1"
                print(message)
                fulfill(message)
            }
        })
    }

    func second() -> Promise<String> {
        Promise<String>(work: { fulfill, reject in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 2"
                print(message)
                fulfill(message)
            }
        })
    }

    func third() -> Promise<String> {
        Promise<String>(work: { fulfill, reject in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 3"
                print(message)
                fulfill(message)
            }
        })
    }

    func fourth() -> Promise<String> {
        Promise<String>(work: { fulfill, reject in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 4"
                print(message)
                fulfill(message)
            }
        })
    }

    func fifth() -> Promise<String> {
        Promise<String>(work: { fulfill, reject in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 5"
                print(message)
                fulfill(message)
            }
        })
    }

    func sixth() -> Promise<String> {
        Promise<String>(work: { fulfill, reject in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 6"
                print(message)
                reject(RuntimeError(reason: "bang at 6"))
            }
        })
    }

    func seventh() -> Promise<String> {
        Promise<String>(work: { fulfill, reject in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 7"
                print(message)
                fulfill(message)
            }
        })
    }

    func eighth() -> Promise<String> {
        Promise<String>(work: { fulfill, reject in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 8"
                print(message)
                fulfill(message)
            }
        })
    }

    func ninth() -> Promise<String> {
        Promise<String>(work: { fulfill, reject in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 9"
                print(message)
                fulfill(message)
            }
        })
    }

}

class PromiseTest : XCTestCase {


    func test_it_handles_chain() {

        var result: Bool? = nil

        let chain = Chain()

        chain.verify(userId: "foo", withToken: "foo")
            .then {
                result = false
            }
            .catch { error in
                result = true
            }


        expect {
            result != nil
        }

        print("Go the final result: \(result)")
        XCTAssertEqual(result, true)

    }

}

class PKChain {

    func verify(userId: String, withToken: String) -> Promise<Void> {
        chunk1()
            .then { [self] result in
                chunk2()
            }
            .done { result in
                print("All done!")
            }
    }

    func chunk1() -> Promise<String> {
        first()
            .then { [self] result in
                second()
            }
            .then { [self] result in
                third()
            }
            .then { [self] result in
                fourth()
            }
    }

    func chunk2() -> Promise<String> {
        fifth()
            .then { [self] result in
                sixth()
            }
            .then { [self] result in
                seventh()
            }
            .then { [self] result in
                eighth()
            }
    }

    func first() -> Promise<String> {
        Promise { seal in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 1"
                print(message)
                seal.fulfill(message)
            }
        }
    }

    func second() -> Promise<String> {
        Promise { seal in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 2"
                print(message)
                seal.fulfill(message)
            }
        }
    }

    func third() -> Promise<String> {
        Promise { seal in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 3"
                print(message)
                seal.fulfill(message)
            }
        }
    }

    func fourth() -> Promise<String> {
        Promise { seal in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 4"
                print(message)
                seal.fulfill(message)
            }
        }
    }

    func fifth() -> Promise<String> {
        Promise { seal in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 5"
                print(message)
                seal.fulfill(message)
            }
        }
    }

    func sixth() -> Promise<String> {
        Promise { seal in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 6"
                print(message)
                seal.reject(RuntimeError(reason: "bang at 6"))
            }
        }
    }

    func seventh() -> Promise<String> {
        Promise { seal in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 7"
                print(message)
                seal.fulfill(message)
            }
        }
    }

    func eighth() -> Promise<String> {
        Promise { seal in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 8"
                print(message)
                seal.fulfill(message)
            }
        }
    }

    func ninth() -> Promise<String> {
        Promise { seal in
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                let message = "message 9"
                print(message)
                seal.fulfill(message)
            }
        }
    }

}

class PKPromisesTest : XCTestCase {

    func test_it_handles_chain() {

        var result: Bool? = nil

        let chain = PKChain()

        chain.verify(userId: "foo", withToken: "foo")
            .done { string in
                result = false
            }
            .catch { error in
                print("Ahahahahah error: \(error)")
                result = true
            }


        expect {
            result != nil
        }

        print("Go the final result: \(result)")
        XCTAssertEqual(result, true)

    }

}

func expect(condition: @escaping () -> Bool) {
    expectWithin(seconds: 7, condition: condition)
}

func expectWithin(seconds: TimeInterval, condition: @escaping () -> Bool) {
    for _ in 0..<Int(seconds) {
        if condition() {
            return
        } else {
            RunLoop.current.run(until: Date(timeIntervalSinceNow: 1))
        }
    }
    fatalError("Condition didn't happen before timeout:\(seconds)")
}