class RouterBackendTest(CreateDataMixin, TestCase):
"""BlockingRouter backend tests."""
def setUp(self):
self.router = BlockingRouter(apps=[], backends={})
def test_valid_backend_path(self):
"""Valid RapidSMS backend modules should load properly."""
backend = self.router.add_backend(
"backend", "rapidsms.backends.base.BackendBase")
self.assertEqual(1, len(self.router.backends.keys()))
self.assertEqual(backend, self.router.backends["backend"])
def test_router_downcases_backend_configs(self):
"""Backend configuration should automatically be lowercased."""
test_backend = "rapidsms.backends.base.BackendBase"
test_conf = {"a": 1, "B": 2, "Cc": 3}
backend = self.router.add_backend("backend", test_backend, test_conf)
self.assertEqual(len(backend._config), 3)
self.assertIn("a", backend._config)
self.assertIn("b", backend._config)
self.assertIn("cc", backend._config)
self.assertNotIn("B", backend._config)
self.assertNotIn("Cc", backend._config)
def test_add_backend_class(self):
"""Router.add_backend should also accept a class."""
self.router.add_backend("backend", BackendBase)
self.assertEqual(1, len(self.router.backends.keys()))
self.assertIn("backend", self.router.backends.keys())
self.assertEqual("backend", self.router.backends['backend'].name)
def test_router_not_configured_with_backend(self):
"""
send_to_backend should raise MessageSendingError if backend
hasn't been configured with the router.
"""
args = ("missing-backend", "1234", "hello", ["1112223333"], {})
self.assertRaises(MessageSendingError, self.router.send_to_backend,
*args)
def test_backend_send_raises_error(self):
"""
send_to_backend should capture all backend exceptions and raise the
standard MessageSendingError.
"""
backend = self.router.add_backend("backend", RaisesBackend)
args = (backend.model.name, "1234", "hello", ["1112223333"], {})
self.assertRaises(MessageSendingError, self.router.send_to_backend,
*args)
@mock.patch('rapidsms.router.blocking.router.logger')
def test_send_captures_exception(self, mock_logger):
"""BlockingRouter should catch exceptions during sending."""
backend = self.router.add_backend("backend", RaisesBackend)
msg = self.create_outgoing_message(backend=backend.model)
# shouldn't raise an error
self.router.send_outgoing(msg)
# but should log an exception
mock_logger.exception.assert_called_once_with(
'backend encountered an error while sending.')
class RouterBackendTest(CreateDataMixin, TestCase):
"""BlockingRouter backend tests."""
def setUp(self):
self.router = BlockingRouter(apps=[], backends={})
def test_valid_backend_path(self):
"""Valid RapidSMS backend modules should load properly."""
backend = self.router.add_backend("backend",
"rapidsms.backends.base.BackendBase")
self.assertEqual(1, len(self.router.backends.keys()))
self.assertEqual(backend, self.router.backends["backend"])
def test_router_downcases_backend_configs(self):
"""Backend configuration should automatically be lowercased."""
test_backend = "rapidsms.backends.base.BackendBase"
test_conf = {"a": 1, "B": 2, "Cc": 3}
backend = self.router.add_backend("backend", test_backend, test_conf)
self.assertEqual(len(backend._config), 3)
self.assertIn("a", backend._config)
self.assertIn("b", backend._config)
self.assertIn("cc", backend._config)
self.assertNotIn("B", backend._config)
self.assertNotIn("Cc", backend._config)
def test_add_backend_class(self):
"""Router.add_backend should also accept a class."""
self.router.add_backend("backend", BackendBase)
self.assertEqual(1, len(self.router.backends.keys()))
self.assertIn("backend", self.router.backends.keys())
self.assertEqual("backend", self.router.backends['backend'].name)
def test_router_not_configured_with_backend(self):
"""
send_to_backend should raise MessageSendingError if backend
hasn't been configured with the router.
"""
args = ("missing-backend", "1234", "hello", ["1112223333"], {})
self.assertRaises(MessageSendingError, self.router.send_to_backend,
*args)
def test_backend_send_raises_error(self):
"""
send_to_backend should capture all backend exceptions and raise the
standard MessageSendingError.
"""
backend = self.router.add_backend("backend", RaisesBackend)
args = (backend.model.name, "1234", "hello", ["1112223333"], {})
self.assertRaises(MessageSendingError, self.router.send_to_backend,
*args)
@mock.patch('rapidsms.router.blocking.router.logger')
def test_send_captures_exception(self, mock_logger):
"""BlockingRouter should catch exceptions during sending."""
backend = self.router.add_backend("backend", RaisesBackend)
msg = self.create_outgoing_message(backend=backend.model)
# shouldn't raise an error
self.router.send_outgoing(msg)
# but should log an exception
mock_logger.exception.assert_called_once_with('backend encountered an error while sending.')
class BlockingRouterTest(harness.CreateDataMixin, TestCase):
"""Test router phases and message classes."""
def setUp(self):
self.router = BlockingRouter(apps=[], backends={})
def test_router_incoming_phases(self):
"""Incoming messages should trigger proper router phases."""
self.router.add_app(harness.MockApp)
self.router.receive_incoming(self.create_incoming_message())
self.assertEqual(set(self.router.apps[0].calls),
set(self.router.incoming_phases))
def test_router_outgoing_phases(self):
"""Outgoing messages should trigger proper router phases."""
self.router.add_app(harness.MockApp)
self.router.add_backend("mockbackend", harness.MockBackend)
backend = self.create_backend(data={'name': 'mockbackend'})
connection = self.create_connection(data={'backend': backend})
msg = self.create_outgoing_message(data={'connections': [connection]})
self.router.send_outgoing(msg)
self.assertEqual(set(self.router.apps[0].calls),
set(self.router.outgoing_phases))
def test_new_incoming_message(self):
"""BaseRouter should return a standard IncomingMessage by default."""
fields = {'foo': 'bar'}
connection = self.create_connection()
msg = self.router.new_incoming_message(text="foo",
connections=[connection],
fields=fields)
self.assertTrue(isinstance(msg, IncomingMessage))
self.assertEqual("foo", msg.text)
self.assertEqual(connection, msg.connections[0])
self.assertEqual(fields['foo'], msg.fields['foo'])
def test_new_incoming_message_class(self):
"""Make sure you can customize the incoming message class."""
class TestIncomingMessage(IncomingMessage):
pass
connection = self.create_connection()
msg = self.router.new_incoming_message(text="foo",
connections=[connection],
class_=TestIncomingMessage)
self.assertTrue(isinstance(msg, TestIncomingMessage))
def test_new_outgoing_message(self):
"""BaseRouter should return a standard OutgoingMessage by default."""
fields = {'foo': 'bar'}
connection = self.create_connection()
incoming_message = self.create_incoming_message()
msg = self.router.new_outgoing_message(text="foo",
connections=[connection],
fields=fields,
in_response_to=incoming_message)
self.assertTrue(isinstance(msg, OutgoingMessage))
self.assertEqual("foo", msg.text)
self.assertEqual(connection, msg.connections[0])
self.assertEqual(fields['foo'], msg.fields['foo'])
self.assertEqual(incoming_message, msg.in_response_to)
def test_new_outgoing_message_class(self):
"""Make sure you can customize the outgoing message class."""
class TestOutgoingMessage(OutgoingMessage):
pass
connection = self.create_connection()
msg = self.router.new_outgoing_message(text="foo",
connections=[connection],
class_=TestOutgoingMessage)
self.assertTrue(isinstance(msg, TestOutgoingMessage))
class BlockingRouterTest(harness.CreateDataMixin, TestCase):
"""Test router phases and message classes."""
def setUp(self):
self.router = BlockingRouter(apps=[], backends={})
def test_router_incoming_phases(self):
"""Incoming messages should trigger proper router phases."""
self.router.add_app(harness.MockApp)
self.router.receive_incoming(self.create_incoming_message())
self.assertEqual(set(self.router.apps[0].calls),
set(self.router.incoming_phases))
def test_router_outgoing_phases(self):
"""Outgoing messages should trigger proper router phases."""
self.router.add_app(harness.MockApp)
self.router.add_backend("mockbackend", harness.MockBackend)
backend = self.create_backend(data={'name': 'mockbackend'})
connection = self.create_connection(data={'backend': backend})
msg = self.create_outgoing_message(data={'connections': [connection]})
self.router.send_outgoing(msg)
self.assertEqual(set(self.router.apps[0].calls),
set(self.router.outgoing_phases))
def test_new_incoming_message(self):
"""BaseRouter should return a standard IncomingMessage by default."""
fields = {'foo': 'bar'}
connection = self.create_connection()
msg = self.router.new_incoming_message(text="foo",
connections=[connection],
fields=fields)
self.assertTrue(isinstance(msg, IncomingMessage))
self.assertEqual("foo", msg.text)
self.assertEqual(connection, msg.connections[0])
self.assertEqual(fields['foo'], msg.fields['foo'])
def test_new_incoming_message_class(self):
"""Make sure you can customize the incoming message class."""
class TestIncomingMessage(IncomingMessage):
pass
connection = self.create_connection()
msg = self.router.new_incoming_message(text="foo",
connections=[connection],
class_=TestIncomingMessage)
self.assertTrue(isinstance(msg, TestIncomingMessage))
def test_new_outgoing_message(self):
"""BaseRouter should return a standard OutgoingMessage by default."""
fields = {'foo': 'bar'}
connection = self.create_connection()
incoming_message = self.create_incoming_message()
msg = self.router.new_outgoing_message(text="foo",
connections=[connection],
fields=fields,
in_response_to=incoming_message)
self.assertTrue(isinstance(msg, OutgoingMessage))
self.assertEqual("foo", msg.text)
self.assertEqual(connection, msg.connections[0])
self.assertEqual(fields['foo'], msg.fields['foo'])
self.assertEqual(incoming_message, msg.in_response_to)
def test_new_outgoing_message_class(self):
"""Make sure you can customize the outgoing message class."""
class TestOutgoingMessage(OutgoingMessage):
pass
connection = self.create_connection()
msg = self.router.new_outgoing_message(text="foo",
connections=[connection],
class_=TestOutgoingMessage)
self.assertTrue(isinstance(msg, TestOutgoingMessage))
