Example #1
0
 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])
Example #2
0
 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)
Example #3
0
    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")
Example #4
0
 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")
Example #5
0
 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])
Example #6
0
 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)
Example #7
0
 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)