async def test_get_periodic_event(self):
handlers = self.builder.get_periodic_event()
self.assertEqual(1, len(handlers))
expected = {Response("_newsletter sent!_"), Response("_checked inactive users!_")}
# noinspection PyTypeChecker
observed = set(await handlers[PeriodicEventEnrouteDecorator("@daily")](self.request))
self.assertEqual(expected, observed)
async def test_get_rest_command_query(self):
handlers = self.builder.get_rest_command_query()
self.assertEqual(3, len(handlers))
expected = Response("_(Get Tickets: test)_")
observed = await handlers[RestQueryEnrouteDecorator("tickets/", "GET")](self.request)
self.assertEqual(expected, observed)
expected = Response("_Create Ticket_")
observed = await handlers[RestCommandEnrouteDecorator("orders/", "GET")](self.request)
self.assertEqual(expected, observed)
expected = None
observed = await handlers[RestCommandEnrouteDecorator("orders/", "DELETE")](self.request)
self.assertEqual(expected, observed)
async def test_get_broker_event(self):
handlers = self.builder.get_broker_event()
self.assertEqual(1, len(handlers))
expected = Response("_Ticket Added: [test]_")
observed = await handlers[BrokerEventEnrouteDecorator("TicketAdded")](self.request)
self.assertEqual(expected, observed)
async def fake_middleware(request: Request,
inner: Callable) -> Optional[Response]:
"""For testing purposes."""
response = await inner(request)
if response is not None:
return Response(f"_{await response.content()}_")
return response
async def test_get_broker_command_query(self):
handlers = self.builder.get_broker_command_query()
self.assertEqual(4, len(handlers))
expected = Response("_(Get Tickets: test)_")
observed = await handlers[BrokerQueryEnrouteDecorator("GetTickets")](self.request)
self.assertEqual(expected, observed)
expected = Response("_Create Ticket_")
observed = await handlers[BrokerCommandEnrouteDecorator("CreateTicket")](self.request)
self.assertEqual(expected, observed)
expected = Response("_Create Ticket_")
observed = await handlers[BrokerCommandEnrouteDecorator("AddTicket")](self.request)
self.assertEqual(expected, observed)
expected = None
observed = await handlers[BrokerCommandEnrouteDecorator("DeleteTicket")](self.request)
self.assertEqual(expected, observed)
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())
async def test_eq_false(self):
self.assertNotEqual(Response(self.data[0]), Response(self.data[1]))
async def test_async_function_call(self):
wrapper = self.decorator(_async_fn)
self.assertEqual(Response("Async Fn: test"), await
wrapper(self.request))
async def test_eq_true(self):
self.assertEqual(Response(self.data), Response(self.data))
async def _async_fn(request: Request) -> Response:
"""For testing purposes."""
return Response(f"Async Fn: {await request.content()}")
def _fn(request: Request) -> Response:
"""For testing purposes."""
return Response("Fn")
def test_function_call(self):
wrapper = self.decorator(_fn)
self.assertEqual(Response("Fn"), wrapper(self.request))
def test_wrapper_sync_call(self):
meta = HandlerMeta(_fn)
with patch("minos.networks.CheckerMeta.run_sync") as mock:
self.assertEqual(Response("Fn"), meta.wrapper(InMemoryRequest("foo")))
self.assertEqual([call(meta.decorators, InMemoryRequest("foo"))], mock.call_args_list)
async def test_content_simple(self):
response = Response(1234)
self.assertEqual(1234, await response.content())
async def test_raw_content_single(self):
response = Response(self.data[0])
self.assertEqual(self.data[0].avro_data, await response.raw_content())
async def test_repr(self):
response = Response(self.data)
self.assertEqual(f"Response({self.data!r})", repr(response))
async def test_content(self):
response = Response(self.data)
self.assertEqual(self.data, await response.content())
def bar(self, request: Request):
"""For testing purposes."""
return Response("bar")
async def check_inactive_users(self, request: Request):
"""For testing purposes."""
return Response("checked inactive users!")
async def send_newsletter(self, request: Request):
"""For testing purposes."""
return Response("newsletter sent!")
async def ticket_added(request: Request) -> Response:
"""For testing purposes."""
return Response(": ".join((
"Ticket Added",
await request.content(),
)))
async def get_tickets(self, request: Request) -> Response:
"""For testing purposes."""
return Response(": ".join((
"Get Tickets",
await request.content(),
)))
def test_hash(self):
self.assertIsInstance(hash(Response("test")), int)
async def _post_query_handle(response: Response) -> Response:
return Response(f"({await response.content()})")
async def test_content_single(self):
response = Response(self.data[0])
self.assertEqual(self.data[0], await response.content())
def create_ticket(self, request: Request) -> Response:
"""For testing purposes."""
return Response("Create Ticket")
async def test_raw_content(self):
response = Response(self.data)
self.assertEqual([item.avro_data for item in self.data], await
response.raw_content())
def add_ticket(self, request: Request) -> Response:
return Response("ticket_added")
def get_order_rest(self, request: Request) -> Response:
return Response("get_order")
def _fn2(self, request):
return Response("bar")
