def setUp(self):
# patching some global objects and preparing mockups of them
self._stderr_patcher = rlocked_patch('sys.stderr')
self.stderr_mock = self._stderr_patcher.start()
self.addCleanup(self._stderr_patcher.stop)
# patching some imported modules and preparing mockups of them
self._time_patcher = rlocked_patch('n6lib.amqp_getters_pushers.time')
self.time_mock = self._time_patcher.start()
self.addCleanup(self._time_patcher.stop)
self._traceback_patcher = rlocked_patch(
'n6lib.amqp_getters_pushers.traceback')
self.traceback_mock = self._traceback_patcher.start()
self.addCleanup(self._traceback_patcher.stop)
self._pika_patcher = rlocked_patch('n6lib.amqp_getters_pushers.pika')
self.pika_mock = self._pika_patcher.start()
self.addCleanup(self._pika_patcher.stop)
# preparing sentinel exceptions
class AMQPConnectionError_sentinel_exc(Exception):
pass
class ConnectionClosed_sentinel_exc(Exception):
pass
class generic_sentinel_exc(Exception):
pass
self.AMQPConnectionError_sentinel_exc = AMQPConnectionError_sentinel_exc
self.ConnectionClosed_sentinel_exc = ConnectionClosed_sentinel_exc
self.generic_sentinel_exc = generic_sentinel_exc
# preparing mockups of different objects
self.conn_mock = RLockedMagicMock()
self.channel_mock = RLockedMagicMock()
self.optional_setup_communication_mock = RLockedMagicMock()
self.serialize = RLockedMagicMock()
self.error_callback = RLockedMagicMock()
# configuring the mockups
self.pika_mock.exceptions.AMQPConnectionError = AMQPConnectionError_sentinel_exc
self.pika_mock.exceptions.ConnectionClosed = ConnectionClosed_sentinel_exc
self.pika_mock.ConnectionParameters.return_value = sen.conn_parameters
self.pika_mock.BlockingConnection.side_effect = [
AMQPConnectionError_sentinel_exc,
self.conn_mock,
]
self.pika_mock.BasicProperties.return_value = sen.props
self.conn_mock.channel.return_value = self.channel_mock
self.serialize.side_effect = (lambda data: data)
def test__init__using_defaults__no_ssl(self):
connection_params_dict_mock = RLockedMagicMock()
connection_params_dict_mock.get.return_value = False
self.meth.__init__(connection_params_dict=connection_params_dict_mock,
exchange='my-exchange')
# attrs
self.assertIs(self.mock._connection_params_dict,
connection_params_dict_mock)
self.assertEqual(self.mock._exchange, {'exchange': 'my-exchange'})
self.assertEqual(self.mock._exchange_name, 'my-exchange')
self.assertEqual(self.mock._queues_to_declare, [])
self.assertIsNone(self.mock._serialize)
self.assertEqual(self.mock._prop_kwargs,
AMQPThreadedPusher.DEFAULT_PROP_KWARGS)
self.assertEqual(self.mock._mandatory, False)
self.assertIs(self.mock._output_fifo.__class__, queue.Queue)
self.assertEqual(self.mock._output_fifo.maxsize, 20000)
self.assertIsNone(self.mock._error_callback)
# calls
self.assertEqual(self.mock.mock_calls, [
call._setup_communication(),
call._start_publishing(),
])
self.assertEqual(
connection_params_dict_mock.mock_calls,
[
call.get('ssl'),
('__contains__', ('client_properties', ),
{}), # because cannot use `call.__contains__`
call.__setitem__('client_properties', ANY),
])
self.assertIsInstance(
# 2nd argument passed to __setitem__()
connection_params_dict_mock.__setitem__.mock_calls[0][-2][1],
dict)
def test__init__using_defaults__no_ssl(self):
connection_params_dict_mock = RLockedMagicMock()
connection_params_dict_mock.get.return_value = False
self.meth.__init__(connection_params_dict=connection_params_dict_mock,
exchange='my-exchange')
# attrs
self.assertIs(self.mock._connection_params_dict,
connection_params_dict_mock)
self.assertEqual(self.mock._exchange, {'exchange': 'my-exchange'})
self.assertEqual(self.mock._exchange_name, 'my-exchange')
self.assertEqual(self.mock._queues_to_declare, [])
self.assertIsNone(self.mock._serialize)
self.assertEqual(self.mock._prop_kwargs,
AMQPThreadedPusher.DEFAULT_PROP_KWARGS)
self.assertEqual(self.mock._mandatory, False)
self.assertIs(self.mock._output_fifo.__class__, Queue.Queue)
self.assertEqual(self.mock._output_fifo.maxsize, 20000)
self.assertIsNone(self.mock._error_callback)
# calls
self.assertEqual(self.mock.mock_calls, [
call._setup_communication(),
call._start_publishing(),
])
self.assertEqual(connection_params_dict_mock.mock_calls, [
call.get('ssl'),
])
def test__init__specifying_all__with_ssl(self):
connection_params_dict_mock = RLockedMagicMock()
connection_params_dict_mock.get.return_value = True
connection_params_dict_mock.__contains__.return_value = True
self.meth.__init__(connection_params_dict=connection_params_dict_mock,
exchange={
'exchange': sen.exchange,
'foo': sen.foo
},
queues_to_declare=sen.queues_to_declare,
serialize=sen.serialize,
prop_kwargs=sen.prop_kwargs,
mandatory=sen.mandatory,
output_fifo_max_size=12345,
error_callback=sen.error_callback)
# attrs
self.assertIs(self.mock._connection_params_dict,
connection_params_dict_mock)
self.assertEqual(self.mock._exchange, {
'exchange': sen.exchange,
'foo': sen.foo
})
self.assertEqual(self.mock._exchange_name, sen.exchange)
self.assertEqual(self.mock._queues_to_declare, [
{
'queue': sen.queues_to_declare,
'callback': ANY
},
])
self.assertEqual(self.mock._serialize, sen.serialize)
self.assertEqual(self.mock._prop_kwargs, sen.prop_kwargs)
self.assertEqual(self.mock._mandatory, sen.mandatory)
self.assertIs(self.mock._output_fifo.__class__, queue.Queue)
self.assertEqual(self.mock._output_fifo.maxsize, 12345)
self.assertEqual(self.mock._error_callback, sen.error_callback)
# calls
self.assertEqual(self.mock.mock_calls, [
call._setup_communication(),
call._start_publishing(),
])
self.assertEqual(
connection_params_dict_mock.mock_calls,
[
call.get('ssl'),
call.setdefault('credentials', ANY),
('__contains__', ('client_properties', ),
{}), # because cannot use `call.__contains__`
])
self.assertIsInstance(
# 2nd argument passed to setdefault()
connection_params_dict_mock.setdefault.mock_calls[0][-2][1],
pika.credentials.ExternalCredentials)
def test__init__specifying_all_and_obtaining_global_conn_params__with_ssl(
self):
connection_params_dict_mock = RLockedMagicMock(
name='connection_params_dict')
connection_params_dict_mock.get.return_value = True
connection_params_dict_mock.__contains__.return_value = True
with rlocked_patch(
'n6lib.amqp_getters_pushers.get_amqp_connection_params_dict',
**{'return_value':
connection_params_dict_mock}) as get_amqp_conn_params_mock:
self.meth.__init__(connection_params_dict=None,
exchange={
'exchange': sen.exchange,
'bar': sen.bar
},
queues_to_declare=[
sen.queue1,
{
'blabla': sen.blabla
},
{
'blabla': sen.blabla,
'callback': sen.callback
},
],
serialize=sen.serialize,
prop_kwargs=sen.prop_kwargs,
mandatory=sen.mandatory,
output_fifo_max_size=54321,
error_callback=sen.error_callback)
# attrs
self.assertIs(self.mock._connection_params_dict,
connection_params_dict_mock)
self.assertEqual(self.mock._exchange, {
'exchange': sen.exchange,
'bar': sen.bar
})
self.assertEqual(self.mock._exchange_name, sen.exchange)
self.assertEqual(self.mock._queues_to_declare, [
{
'queue': sen.queue1,
'callback': ANY
},
{
'blabla': sen.blabla,
'callback': ANY
},
{
'blabla': sen.blabla,
'callback': sen.callback
},
])
self.assertEqual(self.mock._serialize, sen.serialize)
self.assertEqual(self.mock._prop_kwargs, sen.prop_kwargs)
self.assertEqual(self.mock._mandatory, sen.mandatory)
self.assertIs(self.mock._output_fifo.__class__, queue.Queue)
self.assertEqual(self.mock._output_fifo.maxsize, 54321)
self.assertEqual(self.mock._error_callback, sen.error_callback)
# calls
self.assertEqual(self.mock.mock_calls, [
call._setup_communication(),
call._start_publishing(),
])
self.assertEqual(get_amqp_conn_params_mock.mock_calls, [
call(),
])
self.assertEqual(
connection_params_dict_mock.mock_calls,
[
call.get('ssl'),
call.setdefault('credentials', ANY),
('__contains__', ('client_properties', ),
{}), # because cannot use `call.__contains__`
])
self.assertIsInstance(
connection_params_dict_mock.setdefault.mock_calls[0][-2]
[1], # 2nd arg for setdefault
pika.credentials.ExternalCredentials)