async def test_get_many(self):
expected = [
BrokerHandlerEntry(1, "fooReply", 0,
FakeModel("test1").avro_bytes),
BrokerHandlerEntry(2, "fooReply", 0,
FakeModel("test2").avro_bytes),
BrokerHandlerEntry(3, "fooReply", 0,
FakeModel("test3").avro_bytes),
BrokerHandlerEntry(4, "fooReply", 0,
FakeModel("test4").avro_bytes),
]
async def _fn():
await self._insert_one(
Message("fooReply", 0,
FakeModel("test1").avro_bytes))
await self._insert_one(
Message("fooReply", 0,
FakeModel("test2").avro_bytes))
await sleep(0.5)
await self._insert_one(
Message("fooReply", 0,
FakeModel("test3").avro_bytes))
await self._insert_one(
Message("fooReply", 0,
FakeModel("test4").avro_bytes))
observed, _ = await gather(
self.handler.get_many(count=4, max_wait=0.1), _fn())
self.assertEqual(len(expected), len(observed))
for e, o in zip(expected, observed):
self._assert_equal_entries(e, o)
def test_constructor(self):
data_bytes = self.message.avro_bytes
entry = BrokerHandlerEntry(1, "AddOrder", 0, data_bytes, 1)
self.assertEqual(1, entry.id)
self.assertEqual("AddOrder", entry.topic)
self.assertEqual(0, entry.partition)
self.assertEqual(data_bytes, entry.data_bytes)
self.assertEqual(1, entry.retry)
def test_eq(self):
data_bytes = self.message.avro_bytes
now = current_datetime()
one = BrokerHandlerEntry(1,
"AddOrder",
0,
data_bytes,
1,
created_at=now,
updated_at=now)
two = BrokerHandlerEntry(1,
"AddOrder",
0,
data_bytes,
1,
created_at=now,
updated_at=now)
self.assertEqual(one, two)
async def test_get_one(self):
expected = BrokerHandlerEntry(1, "fooReply", 0,
FakeModel("test1").avro_bytes)
await self._insert_one(
Message("fooReply", 0,
FakeModel("test1").avro_bytes))
await self._insert_one(
Message("fooReply", 0,
FakeModel("test2").avro_bytes))
observed = await self.handler.get_one()
self._assert_equal_entries(expected, observed)
def test_constructor_extended(self):
data_bytes = self.message.avro_bytes
now = current_datetime()
entry = BrokerHandlerEntry(1,
"AddOrder",
0,
data_bytes,
1,
created_at=now,
updated_at=now)
self.assertEqual(1, entry.id)
self.assertEqual("AddOrder", entry.topic)
self.assertEqual(0, entry.partition)
self.assertEqual(data_bytes, entry.data_bytes)
self.assertEqual(1, entry.retry)
self.assertEqual(now, entry.created_at)
self.assertEqual(now, entry.updated_at)
async def test_dispatch_one(self):
callback_mock = AsyncMock()
lookup_mock = MagicMock(return_value=callback_mock)
topic = "TicketAdded"
event = BrokerMessage(topic, FakeModel("Foo"))
entry = BrokerHandlerEntry(1,
topic,
0,
event.avro_bytes,
1,
callback_lookup=lookup_mock)
await self.handler.dispatch_one(entry)
self.assertEqual(1, lookup_mock.call_count)
self.assertEqual(call("TicketAdded"), lookup_mock.call_args)
self.assertEqual(1, callback_mock.call_count)
self.assertEqual(call(BrokerRequest(event)), callback_mock.call_args)
async def test_consumers(self):
mock = AsyncMock()
consumer_concurrency = 3
async def _fn_no_wait(*args, **kwargs):
return
async def _fn(*args, **kwargs):
await sleep(60)
lookup_mock = MagicMock(
side_effect=[_fn_no_wait, _fn, _fn, _fn, _fn_no_wait])
async with BrokerHandler.from_config(
self.config,
publisher=self.publisher,
consumer_concurrency=consumer_concurrency) as handler:
self.assertEqual(consumer_concurrency, len(handler.consumers))
handler.submit_query = mock
for _ in range(consumer_concurrency + 2):
entry = BrokerHandlerEntry(1,
"AddOrder",
0,
self.message.avro_bytes,
1,
callback_lookup=lookup_mock)
await handler._queue.put(entry)
await sleep(0.5)
self.assertEqual(0, len(handler.consumers))
self.assertEqual(
[
call(handler._queries["delete_processed"], (1, )),
call(handler._queries["update_not_processed"], (1, )),
call(handler._queries["update_not_processed"], (1, )),
call(handler._queries["update_not_processed"], (1, )),
call(handler._queries["update_not_processed"], (1, )),
],
mock.call_args_list,
)
async def test_dispatch(self):
callback_mock = AsyncMock(return_value=Response("add_order"))
lookup_mock = MagicMock(return_value=callback_mock)
entry = BrokerHandlerEntry(1,
"AddOrder",
0,
self.message.avro_bytes,
1,
callback_lookup=lookup_mock)
send_mock = AsyncMock()
self.publisher.send = send_mock
await self.handler.dispatch_one(entry)
self.assertEqual(1, lookup_mock.call_count)
self.assertEqual(call("AddOrder"), lookup_mock.call_args)
self.assertEqual(
[
call(
"add_order",
topic="UpdateTicket",
identifier=self.message.identifier,
status=BrokerMessageStatus.SUCCESS,
user=self.user,
headers={"foo": "bar"},
)
],
send_mock.call_args_list,
)
self.assertEqual(1, callback_mock.call_count)
observed = callback_mock.call_args[0][0]
self.assertIsInstance(observed, BrokerRequest)
self.assertEqual(FakeModel("foo"), await observed.content())
def test_sort(self):
unsorted = [
BrokerHandlerEntry(1, "", 0,
BrokerMessage("", "foo").avro_bytes, 1),
BrokerHandlerEntry(1, "", 0,
BrokerMessage("", 4).avro_bytes, 1),
BrokerHandlerEntry(1, "", 0,
BrokerMessage("", 2).avro_bytes, 1),
BrokerHandlerEntry(1, "", 0,
BrokerMessage("", 3).avro_bytes, 1),
BrokerHandlerEntry(1, "", 0,
BrokerMessage("", 1).avro_bytes, 1),
BrokerHandlerEntry(1, "", 0,
BrokerMessage("", "bar").avro_bytes, 1),
]
expected = [
unsorted[0], unsorted[4], unsorted[2], unsorted[3], unsorted[1],
unsorted[5]
]
observed = sorted(unsorted)
self.assertEqual(expected, observed)