def testResolveToAPromise(self):
p1,r1 = makePromise()
p2,r2 = makePromise()
def _check(res):
self.assertEqual(res, 1)
p1._then(_check)
r1(p2)
def _continue(res):
r2(1)
flushEventualQueue().addCallback(_continue)
return when(p1)
def testResolveToAPromise(self):
p1,r1 = makePromise()
p2,r2 = makePromise()
def _check(res):
self.failUnlessEqual(res, 1)
p1._then(_check)
r1(p2)
def _continue(res):
r2(1)
flushEventualQueue().addCallback(_continue)
return when(p1)
def testResolveToABrokenPromise(self):
p1,r1 = makePromise()
p2,r2 = makePromise()
r1(p2)
def _continue(res):
r2(Failure(KaboomError("foom")))
flushEventualQueue().addCallback(_continue)
def _check2(res):
self.assertTrue(isinstance(res, Failure))
self.assertTrue(res.check(KaboomError))
d = when(p1)
d.addBoth(_check2)
return d
def testResolveToABrokenPromise(self):
p1,r1 = makePromise()
p2,r2 = makePromise()
r1(p2)
def _continue(res):
r2(Failure(KaboomError("foom")))
flushEventualQueue().addCallback(_continue)
def _check2(res):
self.failUnless(isinstance(res, Failure))
self.failUnless(res.check(KaboomError))
d = when(p1)
d.addBoth(_check2)
return d
def testChained2(self):
p1, r = makePromise()
def _check(c, expected):
self.failUnlessEqual(c.count, expected)
p1.add(2).add(3)._then(_check, 6)
r(Counter(1))
def testResolveAfter(self):
t = Target()
p1,r = makePromise()
p2 = p1.one(2)
def _check(res):
self.failUnlessEqual(res, 3)
p2._then(_check)
r(t)
def testDisableDataflowStyle(self):
p, r = makePromise()
p._useDataflowStyle = False
def wrong(p):
p.one(12)
self.failUnlessRaises(AttributeError, wrong, p)
def testChained1(self):
p1,r = makePromise()
p2 = p1.add(2)
p3 = p2.add(3)
def _check(c):
self.assertEqual(c.count, 5)
p3._then(_check)
r(Counter(0))
def testChained1(self):
p1,r = makePromise()
p2 = p1.add(2)
p3 = p2.add(3)
def _check(c):
self.failUnlessEqual(c.count, 5)
p3._then(_check)
r(Counter(0))
def testResolveAfter(self):
t = Target()
p1,r = makePromise()
p2 = p1.one(2)
def _check(res):
self.assertEqual(res, 3)
p2._then(_check)
r(t)
def testResolveAfter(self):
t = Target()
p,r = makePromise()
p = send(p).one(2)
def _check(res):
self.assertEqual(res, 3)
when(p).addCallback(_check)
r(t)
def testResolveAfter(self):
t = Target()
p,r = makePromise()
p = send(p).one(2)
def _check(res):
self.failUnlessEqual(res, 3)
when(p).addCallback(_check)
r(t)
def testResolveFailure(self):
p,r = makePromise()
p = send(p).one(2)
def _check(res):
self.failUnless(isinstance(res, Failure))
self.failUnless(res.check(KaboomError))
when(p).addBoth(_check)
f = Failure(KaboomError("oops"))
r(f)
def testBasic(self):
p,r = makePromise()
def _check(res, *args, **kwargs):
self.assertEqual(res, 1)
self.assertEqual(args, ("one",))
self.assertEqual(kwargs, {"two": 2})
p2 = p._then(_check, "one", two=2)
self.assertIs(p2, p)
r(1)
def testResolveFailure(self):
p,r = makePromise()
p = send(p).one(2)
def _check(res):
self.assertTrue(isinstance(res, Failure))
self.assertTrue(res.check(KaboomError))
when(p).addBoth(_check)
f = Failure(KaboomError("oops"))
r(f)
def testBasic(self):
p,r = makePromise()
def _check(res, *args, **kwargs):
self.failUnlessEqual(res, 1)
self.failUnlessEqual(args, ("one",))
self.failUnlessEqual(kwargs, {"two": 2})
p2 = p._then(_check, "one", two=2)
self.failUnlessIdentical(p2, p)
r(1)
def testBasicFailure(self):
p,r = makePromise()
def _check(res, *args, **kwargs):
self.assertTrue(isinstance(res, Failure))
self.assertTrue(res.check(KaboomError))
self.assertEqual(args, ("one",))
self.assertEqual(kwargs, {"two": 2})
p2 = p._except(_check, "one", two=2)
self.assertIs(p2, p)
r(Failure(KaboomError("oops")))
def testResolveFailure(self):
p1,r = makePromise()
p2 = p1.one(2)
def _check(res):
self.assertTrue(isinstance(res, Failure))
self.assertTrue(res.check(KaboomError))
p2._then(lambda res: self.fail("this was supposed to fail"))
p2._except(_check)
f = Failure(KaboomError("oops"))
r(f)
def testResolveBefore(self):
t = Target()
p, r = makePromise()
r(t)
p = send(p).one(2)
def _check(res):
self.failUnlessEqual(res, 3)
when(p).addCallback(_check)
def testResolveAfter(self):
t = Target()
p,r = makePromise()
sendOnly(p).one(1)
r(t)
d = flushEventualQueue()
def _check(res):
self.assertEqual(t.calls, [("one", 1)])
d.addCallback(_check)
return d
def testResolveBefore(self):
t = Target()
p1, r = makePromise()
r(t)
p2 = p1.one(2)
def _check(res):
self.failUnlessEqual(res, 3)
p2._then(_check)
def testResolveAfter(self):
t = Target()
p,r = makePromise()
sendOnly(p).one(1)
r(t)
d = flushEventualQueue()
def _check(res):
self.failUnlessEqual(t.calls, [("one", 1)])
d.addCallback(_check)
return d
def testResolveFailure(self):
p1,r = makePromise()
p2 = p1.one(2)
def _check(res):
self.failUnless(isinstance(res, Failure))
self.failUnless(res.check(KaboomError))
p2._then(lambda res: self.fail("this was supposed to fail"))
p2._except(_check)
f = Failure(KaboomError("oops"))
r(f)
def testBasicFailure(self):
p,r = makePromise()
def _check(res, *args, **kwargs):
self.failUnless(isinstance(res, Failure))
self.failUnless(res.check(KaboomError))
self.failUnlessEqual(args, ("one",))
self.failUnlessEqual(kwargs, {"two": 2})
p2 = p._except(_check, "one", two=2)
self.failUnlessIdentical(p2, p)
r(Failure(KaboomError("oops")))
def testBasic(self):
p, r = makePromise()
def _check(res, *args, **kwargs):
self.failUnlessEqual(res, 1)
self.failUnlessEqual(args, ("one", ))
self.failUnlessEqual(kwargs, {"two": 2})
p2 = p._then(_check, "one", two=2)
self.failUnlessIdentical(p2, p)
r(1)
def testResolveBefore(self):
t = Target()
p, r = makePromise()
r(t)
sendOnly(p).one(1)
d = flushEventualQueue()
def _check(res):
self.failUnlessEqual(t.calls, [("one", 1)])
d.addCallback(_check)
return d
def testNoMultipleResolution(self):
p,r = makePromise()
r(3)
self.assertRaises(UsageError, r, 4)
def testNoMultipleResolution(self):
p, r = makePromise()
r(3)
self.failUnlessRaises(UsageError, r, 4)
def testDisableDataflowStyle(self):
p,r = makePromise()
p._useDataflowStyle = False
def wrong(p):
p.one(12)
self.failUnlessRaises(AttributeError, wrong, p)
def testChained2(self):
p1,r = makePromise()
def _check(c, expected):
self.failUnlessEqual(c.count, expected)
p1.add(2).add(3)._then(_check, 6)
r(Counter(1))
def testNoMultipleResolution(self):
p,r = makePromise()
r(3)
self.failUnlessRaises(UsageError, r, 4)
