def test_default(self): """ You can use it to receive particular interfaces """ source = Source([IInput]) receiver = FakeReceiver([IInput]) source.subscribe(receiver) data = Input('', '', '', '') r = source.emit(data) self.assertTrue(r.called, "Should callback immediately by default") receiver.receive.assert_called_once_with(data) self.assertEqual(len(receiver.results), 1) self.assertEqual(self.successResultOf(receiver.results[0]), self.successResultOf(r)[0][1])
def test_return_factory(self): """ You can have a return_factory. """ source = Source([IInput]) receiver = FakeReceiver([IInput], lambda x: defer.Deferred()) source.subscribe(receiver) data = Input('', '', '', '') r = source.emit(data) self.assertFalse(r.called, "Should not callback, because it's returning" " Deferreds") self.assertEqual(len(receiver.results), 1) receiver.receive.assert_called_once_with(data) receiver.results[-1].callback('foo') self.assertTrue(r.called)
def test_NothingToOffer(self): """ If the Source isn't a source of an interface of the receiver, it should raise an exception. """ source = Source([IA]) recv = FakeReceiver([IB]) self.assertRaises(NothingToOffer, source.subscribe, recv) # this shouldn't fail, because at least one of the interfaces this # receiver cares about is provided by the source. recv = FakeReceiver([IA, IB]) r = source.subscribe(recv) self.assertEqual(r, [IA], "Should list interfaces that will be used")
def test_onlyReceivedRequestedInterfaces(self): """ If a receiver doesn't accept a particular interface, it should not receive it. """ source = Source([IA, IB]) recv = FakeReceiver([IA]) source.subscribe(recv) a = A() b = B() source.emit(a) self.assertEqual(recv.received, [a]) source.emit(b) self.assertEqual(recv.received, [a], "Should not receive IB things")
def test_basic(self): """ By default, you can subscribe to data of a particular type and receive emissions. """ source = Source([IA, IB]) recv = FakeReceiver([IA, IB]) source.subscribe(recv) a = A() b = B() source.emit(a) self.assertEqual(recv.received, [a]) source.emit(b) self.assertEqual(recv.received, [a, b])
def test_emitError(self): """ Errors should cause the result to errback """ source = Source([IA]) recv1 = FakeReceiver([IA], defer.succeed('foo')) source.subscribe(recv1) recv2 = FakeReceiver([IA], defer.fail(Exception('foo'))) source.subscribe(recv2) a = A() r = source.emit(a) def cb(r): self.fail("Should have errbacked") def eb(r): pass return r.addCallbacks(cb, eb)
def test_emitReturn(self): """ The emission should not return until all the receivers acknowledge receipt. """ source = Source([IA]) recv1 = FakeReceiver([IA], defer.Deferred()) source.subscribe(recv1) recv2 = FakeReceiver([IA], defer.Deferred()) source.subscribe(recv2) a = A() r = source.emit(a) self.assertFalse(r.called, "Should not have called back yet") recv1.return_value.callback('foo') self.assertFalse(r.called) recv2.return_value.callback('foo') self.assertTrue(r.called)