def test_backend_failure(self):
backends = {str(i): MagicMock() for i in range(5)}
backends['1'].send.side_effect = RuntimeError
router = RoutingBackend(backends=backends)
router.send(self.sample_event)
for backend in backends.itervalues():
backend.send.assert_called_once_with(self.sample_event)
def test_single_backend(self):
mock_backend = MagicMock()
router = RoutingBackend(backends={
'mock0': mock_backend
})
router.send(self.sample_event)
mock_backend.send.assert_called_once_with(self.sample_event)
def test_single_processor(self):
mock_processor = MagicMock()
router = RoutingBackend(processors=[
mock_processor
])
router.send(self.sample_event)
mock_processor.assert_called_once_with(self.sample_event)
def test_multiple_processors(self):
processors = [MagicMock() for __ in range(5)]
for processor in processors:
processor.return_value = self.sample_event
router = RoutingBackend(processors=processors)
router.send(self.sample_event)
for processor in processors:
processor.assert_called_once_with(self.sample_event)
def test_multiple_backends(self):
backends = {
str(i): MagicMock()
for i in range(5)
}
router = RoutingBackend(backends=backends)
router.send(self.sample_event)
for backend in backends.values():
backend.send.assert_called_once_with(self.sample_event)
def test_nested_routing_with_abort(self):
mock_abort_processing = MagicMock()
mock_abort_processing.side_effect = EventEmissionExit
left_backend = MagicMock()
left_router = RoutingBackend(backends={'0': left_backend}, processors=[mock_abort_processing])
right_backend = MagicMock()
right_router = RoutingBackend(backends={'0': right_backend})
root_router = RoutingBackend(backends={
'left': left_router,
'right': right_router,
})
root_router.send(self.sample_event)
right_backend.send.assert_called_once_with(self.sample_event)
self.assertEqual(len(left_backend.mock_calls), 0)
mock_abort_processing.assert_called_once_with(self.sample_event)
def test_multiple_backends_and_processors(self):
backends = {str(i): MagicMock() for i in range(5)}
processors = [MagicMock() for __ in range(5)]
for processor in processors:
processor.return_value = self.sample_event
router = RoutingBackend(backends=backends, processors=processors)
router.send(self.sample_event)
for processor in processors:
processor.assert_called_once_with(self.sample_event)
for backend in backends.values():
backend.send.assert_called_once_with(self.sample_event)
def test_backend_call_order(self):
class OrderRecordingBackend(object):
"""Keep track of the order that the backends are called in"""
def __init__(self, name, call_order):
self._name = name
self._order = call_order
def send(self, event): # pylint: disable=unused-argument
"""Do nothing except record that this was called"""
self._order.append(self._name)
call_order = []
backends = {
str(i): OrderRecordingBackend(str(i), call_order)
for i in range(5)
}
router = RoutingBackend(backends=backends)
router.send(self.sample_event)
self.assertEqual(call_order, ['0', '1', '2', '3', '4'])
def test_non_callable_processor_simple_type(self):
with self.assertRaisesRegexp(ValueError,
r'Processor \w+ is not callable.'):
RoutingBackend(processors=['b'])
def test_non_callable_processor(self):
with self.assertRaisesRegexp(ValueError,
r'Processor \w+ is not callable.'):
RoutingBackend(processors=[object()])
def test_backend_without_send(self):
with self.assertRaisesRegexp(
ValueError,
r'Backend \w+ does not have a callable "send" method.'):
RoutingBackend(backends={'a': object()})
def test_non_callable_backend(self):
with self.assertRaisesRegexp(
ValueError,
r'Backend \w+ does not have a callable "send" method.'):
RoutingBackend(backends={'a': 'b'})
def setUp(self):
self.sample_event = {'name': sentinel.name}
self.mock_backend = MagicMock()
self.router = RoutingBackend(backends={'0': self.mock_backend})
def __init__(self, backends=None, context_locator=None, processors=None):
self.routing_backend = RoutingBackend(backends=backends, processors=processors)
self.context_locator = context_locator or DefaultContextLocator()
def test_non_callable_processor_simple_type(self):
with self.assertRaisesRegexp( # pylint: disable=deprecated-method,useless-suppression
ValueError, r'Processor \w+ is not callable.'):
RoutingBackend(processors=['b'])
def test_backend_without_send(self):
with self.assertRaisesRegexp( # pylint: disable=deprecated-method,useless-suppression
ValueError,
r'Backend \w+ does not have a callable "send" method.'):
RoutingBackend(backends={'a': object()})
