def test_poll(self, declare_queue_binding_mock):
incoming_message_class_mock = mock.Mock()
poller = pika_poller.PikaPoller(
self._pika_engine,
self._prefetch_count,
incoming_message_class=incoming_message_class_mock)
unused = object()
method = object()
properties = object()
body = object()
self._poller_connection_mock.process_data_events.side_effect = (
lambda time_limit: poller._on_message_with_ack_callback(
unused, method, properties, body))
poller.start()
res = poller.poll()
self.assertEqual(len(res), 1)
self.assertEqual(res[0], incoming_message_class_mock.return_value)
incoming_message_class_mock.assert_called_once_with(
self._pika_engine, self._poller_channel_mock, method, properties,
body)
self.assertTrue(self._pika_engine.create_connection.called)
self.assertTrue(self._poller_connection_mock.channel.called)
self.assertTrue(declare_queue_binding_mock.called)
def test_message_processing(self, declare_queue_binding_mock):
res = []
def on_incoming_callback(incoming):
res.append(incoming)
incoming_message_class_mock = mock.Mock()
poller = pika_poller.PikaPoller(
self._pika_engine,
1,
None,
self._prefetch_count,
incoming_message_class=incoming_message_class_mock)
unused = object()
method = object()
properties = object()
body = object()
poller.start(on_incoming_callback)
poller._on_message_with_ack_callback(unused, method, properties, body)
self.assertEqual(len(res), 1)
self.assertEqual(res[0], [incoming_message_class_mock.return_value])
incoming_message_class_mock.assert_called_once_with(
self._pika_engine, self._poller_channel_mock, method, properties,
body)
self.assertTrue(self._pika_engine.create_connection.called)
self.assertTrue(self._poller_connection_mock.channel.called)
self.assertTrue(declare_queue_binding_mock.called)
def test_start(self, declare_queue_binding_mock):
poller = pika_poller.PikaPoller(self._pika_engine, 1, None,
self._prefetch_count, None)
poller.start(None)
self.assertTrue(self._pika_engine.create_connection.called)
self.assertTrue(self._poller_connection_mock.channel.called)
self.assertTrue(declare_queue_binding_mock.called)
def test_start_when_connection_unavailable(self):
incoming_message_class_mock = mock.Mock()
poller = pika_poller.PikaPoller(
self._pika_engine,
self._prefetch_count,
incoming_message_class=incoming_message_class_mock)
self._pika_engine.create_connection.side_effect = socket.timeout()
# start() should not raise socket.timeout exception
poller.start()
def test_start_when_connection_unavailable(self):
poller = pika_poller.PikaPoller(self._pika_engine, 1, None,
self._prefetch_count, None)
self._pika_engine.create_connection.side_effect = (
pika_drv_exc.EstablishConnectionException)
# start() should not raise socket.timeout exception
poller.start(None)
# stop is needed to stop reconnection background job
poller.stop()
def test_message_processing_batch_with_timeout(self,
declare_queue_binding_mock):
incoming_message_class_mock = mock.Mock()
n = 10
timeout = 1
res = []
evt = threading.Event()
def on_incoming_callback(incoming):
res.append(incoming)
evt.set()
poller = pika_poller.PikaPoller(
self._pika_engine,
n,
timeout,
self._prefetch_count,
incoming_message_class=incoming_message_class_mock)
params = []
success_count = 5
poller.start(on_incoming_callback)
for i in range(n):
params.append((object(), object(), object(), object()))
for i in range(success_count):
poller._on_message_with_ack_callback(*params[i])
self.assertTrue(evt.wait(timeout * 2))
self.assertEqual(len(res), 1)
self.assertEqual(len(res[0]), success_count)
self.assertEqual(incoming_message_class_mock.call_count, success_count)
for i in range(success_count):
self.assertEqual(res[0][i],
incoming_message_class_mock.return_value)
self.assertEqual(incoming_message_class_mock.call_args_list[i][0],
(self._pika_engine, self._poller_channel_mock) +
params[i][1:])
self.assertTrue(self._pika_engine.create_connection.called)
self.assertTrue(self._poller_connection_mock.channel.called)
self.assertTrue(declare_queue_binding_mock.called)
def test_poll_after_stop(self, declare_queue_binding_mock):
incoming_message_class_mock = mock.Mock()
poller = pika_poller.PikaPoller(
self._pika_engine,
self._prefetch_count,
incoming_message_class=incoming_message_class_mock)
n = 10
params = []
for i in range(n):
params.append((object(), object(), object(), object()))
index = [0]
def f(time_limit):
for i in range(10):
poller._on_message_no_ack_callback(*params[index[0]])
index[0] += 1
self._poller_connection_mock.process_data_events.side_effect = f
poller.start()
res = poller.poll(prefetch_size=1)
self.assertEqual(len(res), 1)
self.assertEqual(res[0], incoming_message_class_mock.return_value)
self.assertEqual(incoming_message_class_mock.call_args_list[0][0],
(self._pika_engine, None) + params[0][1:])
poller.stop()
res2 = poller.poll(prefetch_size=n)
self.assertEqual(len(res2), n - 1)
self.assertEqual(incoming_message_class_mock.call_count, n)
self.assertEqual(
self._poller_connection_mock.process_data_events.call_count, 1)
for i in range(n - 1):
self.assertEqual(res2[i], incoming_message_class_mock.return_value)
self.assertEqual(
incoming_message_class_mock.call_args_list[i + 1][0],
(self._pika_engine, None) + params[i + 1][1:])
self.assertTrue(self._pika_engine.create_connection.called)
self.assertTrue(self._poller_connection_mock.channel.called)
self.assertTrue(declare_queue_binding_mock.called)
def test_poll_batch_with_timeout(self, declare_queue_binding_mock):
incoming_message_class_mock = mock.Mock()
poller = pika_poller.PikaPoller(
self._pika_engine,
self._prefetch_count,
incoming_message_class=incoming_message_class_mock)
n = 10
timeout = 1
sleep_time = 0.2
params = []
success_count = 5
for i in range(n):
params.append((object(), object(), object(), object()))
index = [0]
def f(time_limit):
time.sleep(sleep_time)
poller._on_message_with_ack_callback(*params[index[0]])
index[0] += 1
self._poller_connection_mock.process_data_events.side_effect = f
poller.start()
res = poller.poll(prefetch_size=n, timeout=timeout)
self.assertEqual(len(res), success_count)
self.assertEqual(incoming_message_class_mock.call_count, success_count)
for i in range(success_count):
self.assertEqual(res[i], incoming_message_class_mock.return_value)
self.assertEqual(incoming_message_class_mock.call_args_list[i][0],
(self._pika_engine, self._poller_channel_mock) +
params[i][1:])
self.assertTrue(self._pika_engine.create_connection.called)
self.assertTrue(self._poller_connection_mock.channel.called)
self.assertTrue(declare_queue_binding_mock.called)
def test_message_processing_batch(self, declare_queue_binding_mock):
incoming_message_class_mock = mock.Mock()
n = 10
params = []
res = []
def on_incoming_callback(incoming):
res.append(incoming)
poller = pika_poller.PikaPoller(
self._pika_engine,
n,
None,
self._prefetch_count,
incoming_message_class=incoming_message_class_mock)
for i in range(n):
params.append((object(), object(), object(), object()))
poller.start(on_incoming_callback)
for i in range(n):
poller._on_message_with_ack_callback(*params[i])
self.assertEqual(len(res), 1)
self.assertEqual(len(res[0]), 10)
self.assertEqual(incoming_message_class_mock.call_count, n)
for i in range(n):
self.assertEqual(res[0][i],
incoming_message_class_mock.return_value)
self.assertEqual(incoming_message_class_mock.call_args_list[i][0],
(self._pika_engine, self._poller_channel_mock) +
params[i][1:])
self.assertTrue(self._pika_engine.create_connection.called)
self.assertTrue(self._poller_connection_mock.channel.called)
self.assertTrue(declare_queue_binding_mock.called)
