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_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_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)
