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)