Python aplus.Promise类代码示例

def _handle_server_status(self, msg_json):

	self.fee.set_load_scale(msg_json)
	p = Promise()
	p.fulfill(self.fee.calculate_fee())
	self.fee_promise = p
	return True

    def testNonFunction(nonFunction):
        def foo(k, r):
            results[k] = r

        p1 = Promise()
        p2 = p1.then(nonFunction, lambda r: foo(str(nonFunction), r))
        p1.reject(Exception("Error: " + str(nonFunction)))

def _handle_ledger_closed(self, msg_json):

	self.fee.set_fee_scale(msg_json)
	p = Promise()
	p.fulfill(self.fee.calculate_fee())
	self.fee_promise = p
	return True

def test_3_2_6_5_rejected():
    """
    Handles the case where the arguments to then
    are values, not functions or promises.
    """
    p1 = Promise()
    p1.reject("Error")
    p2 = p1.then(None, 5)
    assert_equals("Error", p1.reason)
    assert p2.isRejected()
    assert_equals("Error", p2.reason)

def test_exceptions():
    def throws(v):
        assert False

    p1 = Promise()
    p1.addCallback(throws)
    p1.fulfill(5)

    p2 = Promise()
    p2.addErrback(throws)
    p2.reject("Error")

def test_3_2_6_4_fulfilled():
    """
    Handles the case where the arguments to then
    are values, not functions or promises.
    """
    p1 = Promise()
    p1.fulfill(10)
    p2 = p1.then(5)
    assert_equals(10, p1.value)
    assert p2.isFulfilled()
    assert_equals(10, p2.value)

def test_3_2_6_5_rejected():
    """
    Handles the case where the arguments to then
    are values, not functions or promises.
    """
    p1 = Promise()
    p1.reject(Exception("Error"))
    p2 = p1.then(None, 5)
    assert_exception(p1.reason, Exception, "Error")
    assert p2.isRejected
    assert_exception(p2.reason, Exception, "Error")

def test_3_2_6_1_literally():
    """
    If _either_ onFulfilled or onRejected returns a value 
    that is not a promise, promise2 must be fulfilled with that value
    """
    def _raise(e):
        raise e
    
    p1 = Promise()
    pf = p1.then(lambda v : _raise(Exception("Error")), lambda x : "catched")
    p1.fulfill(5)
    assert_equals(pf.value, "catched")

def test_3_2_3_3():
    """
    Make sure rejected callback never called if promise is fulfilled
    """

    cf = Counter()
    cr = Counter()
    p1 = Promise()
    p2 = p1.then(lambda v: cf.tick(), lambda r: cr.tick())
    p1.fulfill(5)
    assert_equals(0, cr.value())
    assert_equals(1, cf.value())

def test_exceptions():
    def throws(v):
        assert False

    p1 = Promise()
    p1.addCallback(throws)
    p1.fulfill(5)

    p2 = Promise()
    p2.addErrback(throws)
    p2.reject(Exception())

    assert_raises(Exception, p2.get)

def test_3_2_3_1():
    """
    The second argument to 'then' must be called when a promise is
    rejected.
    """

    c = Counter()
    def check(r, c):
        assert_equals(r, "Error")
        c.tick()
    p1 = Promise()
    p2 = p1.then(None, lambda r: check(r, c))
    p1.reject("Error")
    assert_equals(1, c.value())

def test_3_2_2_1():
    """
    The first argument to 'then' must be called when a promise is
    fulfilled.
    """

    c = Counter()
    def check(v, c):
        assert_equals(v, 5)
        c.tick()
    p1 = Promise()
    p2 = p1.then(lambda v: check(v, c))
    p1.fulfill(5)
    assert_equals(1, c.value())

def test_3_2_5_2_if():
    """
    Then can be called multiple times on the same promise
    and callbacks must be called in the order of the
    then calls.
    """

    def add(l, v):
        l.append(v)
    p1 = Promise()
    p1.reject("Error")
    order = []
    p2 = p1.then(None, lambda v: add(order, "p2"))
    p3 = p1.then(None, lambda v: add(order, "p3"))
    assert_equals(2, len(order))
    assert_equals("p2", order[0])
    assert_equals("p3", order[1])

def test_3_2_1():
    """
    Test that the arguments to 'then' are optional.
    """

    p1 = Promise()
    p2 = p1.then()
    p3 = Promise()
    p4 = p3.then()
    p1.fulfill(5)
    p3.reject("How dare you!")

def test_list_promise_if():
    p1 = Promise()
    p1.fulfill(5)
    p2 = Promise()
    p2.fulfill(10)
    pl = listPromise(p1, p2)
    assert p1.isFulfilled()
    assert p2.isFulfilled()
    assert pl.isFulfilled()
    assert_equals(5, p1.value)
    assert_equals(10, p2.value)
    assert_equals(5, pl.value[0])
    assert_equals(10, pl.value[1])