async def test_handler_logger(self):
mock = Mock()
record = {"request": None, "response": None}
class App(jj.App):
resolver = self.resolver
@LoggerMiddleware(self.resolver, mock)
@MethodMatcher(resolver, "*")
async def handler(request):
record["request"] = request
response = Response(status=200)
record["response"] = response
return response
async with run(App()) as client:
response = await client.get("/")
self.assertEqual(response.status, 200)
mock.assert_has_calls([
call.info(record["request"], extra={
"jj_request": record["request"],
}),
call.info(record["response"], extra={
"jj_request": record["request"],
"jj_response": record["response"],
}),
])
self.assertEqual(mock.info.call_count, 2)
async def test_get_categorie_by_id(
self,
get_repository_mock,
verify_if_exists_and_is_not_deleted_mock,
categorie_response_mock,
):
# Arrange
repository_mock = Mock()
repository_mock.get_by_id.return_value = 'categorie'
get_repository_mock.side_effect = [repository_mock]
verify_if_exists_and_is_not_deleted_mock.return_value = True
categorie_response_mock.from_domain.return_value = 'response'
# Action
response = await get_categorie_by_id('1')
# Asserts
self.assertEqual(response, 'response')
get_repository_mock_calls = get_repository_mock.mock_calls
self.assertEqual(len(get_repository_mock_calls), 1)
get_repository_mock.assert_has_calls([call()])
repository_mock_calls = repository_mock.mock_calls
self.assertEqual(len(repository_mock_calls), 1)
repository_mock.assert_has_calls([call.get_by_id(Categorie, '1')])
verify_if_exists_and_is_not_deleted_mock_calls = verify_if_exists_and_is_not_deleted_mock.mock_calls
self.assertEqual(len(verify_if_exists_and_is_not_deleted_mock_calls),
1)
verify_if_exists_and_is_not_deleted_mock.assert_has_calls(
[call('categorie')])
async def test_delete_categorie(self, get_repository_mock,
verify_if_exists_and_is_not_deleted_mock):
# Arrange
categorie_mock = Mock()
repository_mock = Mock()
repository_mock.get_by_id.side_effect = [categorie_mock]
get_repository_mock.side_effect = [repository_mock]
verify_if_exists_and_is_not_deleted_mock.return_value = True
# Action
await delete_categorie('1')
# Asserts
get_repository_mock_calls = get_repository_mock.mock_calls
self.assertEqual(len(get_repository_mock_calls), 1)
get_repository_mock.assert_has_calls([call()])
repository_mock_calls = repository_mock.mock_calls
self.assertEqual(len(repository_mock_calls), 2)
repository_mock.assert_has_calls(
[call.get_by_id(Categorie, '1'),
call.save(categorie_mock)])
categorie_mock_calls = categorie_mock.mock_calls
self.assertEqual(len(categorie_mock_calls), 1)
categorie_mock.assert_has_calls([call.delete()])
verify_if_exists_and_is_not_deleted_mock_calls = verify_if_exists_and_is_not_deleted_mock.mock_calls
self.assertEqual(len(verify_if_exists_and_is_not_deleted_mock_calls),
1)
verify_if_exists_and_is_not_deleted_mock.assert_has_calls(
[call(categorie_mock)])
async def test_root_and_app_and_handler_middlewares_priority(self):
mock = Mock()
class Do:
async def do(self, request, handler, app):
mock(self.__class__.__name__, sentinel.BEFORE)
response = await handler(request)
mock(self.__class__.__name__, sentinel.AFTER)
return response
class Middleware(Do, RootMiddleware):
resolver = self.resolver
class AppMiddleware(Do, BaseMiddleware):
resolver = self.resolver
class HandlerMiddleware(Do, BaseMiddleware):
resolver = self.resolver
@AppMiddleware()
class App(jj.App):
resolver = self.resolver
@MethodMatcher(resolver, "*")
@HandlerMiddleware()
async def handler(request):
mock(App.__name__, sentinel.BEFORE)
response = Response(status=200)
mock(App.__name__, sentinel.AFTER)
return response
async with run(App(), middlewares=[Middleware()]) as client:
response = await client.get("/")
self.assertEqual(response.status, 200)
mock.assert_has_calls([
call(AppMiddleware.__name__, sentinel.BEFORE),
call(HandlerMiddleware.__name__, sentinel.BEFORE),
call(Middleware.__name__, sentinel.BEFORE),
call(App.__name__, sentinel.BEFORE),
call(App.__name__, sentinel.AFTER),
call(Middleware.__name__, sentinel.AFTER),
call(HandlerMiddleware.__name__, sentinel.AFTER),
call(AppMiddleware.__name__, sentinel.AFTER),
])
self.assertEqual(mock.call_count, 8)
async def test_get_categorie(self, get_repository_mock):
# Arrange
respository_mock = Mock()
response_mock = Mock()
respository_mock.get.side_effect = [response_mock]
get_repository_mock.side_effect = [respository_mock]
# Action
response = await get_categorie()
# Asserts
response_mock_calls = response_mock.mock_calls
self.assertEqual(len(response_mock_calls), 1)
response_mock.assert_has_calls([call.all()])
self.assertEqual(response, response_mock.all())
get_repository_mock_calls = get_repository_mock.mock_calls
self.assertEqual(len(get_repository_mock_calls), 1)
get_repository_mock.assert_has_calls([call()])
repository_mock_calls = respository_mock.mock_calls
self.assertEqual(len(repository_mock_calls), 1)
respository_mock.assert_has_calls([call.get(Categorie)])
async def test_handler_with_matcher_and_decorators(self):
mock = Mock()
def decorator_before(fn):
async def before_handler(request):
mock(sentinel.BEFORE)
return await fn(request)
return before_handler
def decorator_after(fn):
async def after_handler(request):
mock(sentinel.AFTER)
return await fn(request)
return after_handler
path, status, text = "/route", 201, "text"
class App(jj.App):
resolver = self.resolver
@decorator_after
@PathMatcher(resolver, path)
@decorator_before
async def handler(request):
mock(sentinel.HANDLE)
return Response(status=status, text=text)
async with run(App()) as client:
response = await client.get(path)
self.assertEqual(response.status, status)
self.assertEqual(await response.text(), text)
response2 = await client.get("/")
self.assertEqual(response2.status, 404)
mock.assert_has_calls([
call(sentinel.AFTER),
call(sentinel.BEFORE),
call(sentinel.HANDLE)
])
self.assertEqual(mock.call_count, 3)
async def test_app_and_handler_middlewares_priority(self):
mock = Mock()
class Middleware1(BaseMiddleware):
async def do(self, request, handler, app):
mock(self.__class__.__name__, sentinel.BEFORE)
response = await handler(request)
mock(self.__class__.__name__, sentinel.AFTER)
return response
class Middleware2(Middleware1):
pass
@Middleware1(self.resolver)
class App(jj.App):
resolver = self.resolver
@MethodMatcher(resolver, "*")
@Middleware2(resolver)
async def handler(request):
mock(App.__name__, sentinel.BEFORE)
response = Response(status=200)
mock(App.__name__, sentinel.AFTER)
return response
async with run(App()) as client:
response = await client.get("/")
self.assertEqual(response.status, 200)
mock.assert_has_calls([
call(Middleware1.__name__, sentinel.BEFORE),
call(Middleware2.__name__, sentinel.BEFORE),
call(App.__name__, sentinel.BEFORE),
call(App.__name__, sentinel.AFTER),
call(Middleware2.__name__, sentinel.AFTER),
call(Middleware1.__name__, sentinel.AFTER),
])
self.assertEqual(mock.call_count, 6)
