feat: add exception handling code and tests to api gateway views

backend/api_gateway/carpool_request_endpoint/tests/test_carpool_request_controller.py

@@ -1,12 +1,73 @@
 from django.test import TestCase, Client
+from unittest.mock import patch
+from backend.common.rpc.infra.adapter.redis.redis_rpc_client \
+    import RedisRpcClient
+from backend.common.rpc.rpc_response import RpcResponse
+from backend.common.command.carpool_request_create_command \
+    import CARPOOL_REQUEST_CREATE_COMMAND
+from backend.common.command.carpool_request_delete_command \
+    import CARPOOL_REQUEST_DELETE_COMMAND
+from backend.carpool_request_service.carpool_request.domain.carpool_request \
+    import CarpoolRequest
 
 
 class CarpoolRequestControllerTestCase(TestCase):
 
     def setUp(self):
         self.client = Client()
 
-    def test_create_when_method_is_not_post_response_with_405(self):
+
+    def test_create_carpool_request_wrong_api(self):
         response = self.client.get('/api/v1/carpool_request/',
                                    content_type='application/json')
         self.assertEqual(response.status_code, 405)
+
+
+    @patch.object(RedisRpcClient, 'call')
+    def test_create_carpool_request_success(self, call_fn):
+        request = {
+            'from_location': 'here',
+            'to_location': 'there',
+            'minimum_passenger': 4,
+            'rider_id': 1
+        }
+        call_fn.return_value = RpcResponse(
+            result={
+                'from_location': 'here',
+                'to_location': 'there',
+                'minimum_passenger': 4,
+                'rider_id': 1
+            },
+            id=1,
+        )
+        response = self.client.post(
+            '/api/v1/carpool_request/',
+            request,
+            content_type='application/json'
+        )
+
+        args, kwargs = call_fn.call_args
+        self.assertEqual(args[0], CARPOOL_REQUEST_CREATE_COMMAND)
+        self.assertEqual(response.status_code, 204)
+
+        @patch.object(RedisRpcClient, 'call')
+        def test_delete_carpool_request_success(self, call_fn):
+            mock_carpool_request = CarpoolRequest.objects.create(id=1)
+            request = {
+                'request_id': 1
+            }
+            call_fn.return_value = RpcResponse(
+                result={
+                    'request_id': 1
+                },
+                id=1,
+            )
+            response = self.client.delete(
+                '/api/v1/carpool_request/1',
+                request,
+                content_type='application/json'
+            )
+
+            args, kwargs = call_fn.call_args
+            self.assertEqual(args[0], CARPOOL_REQUEST_DELETE_COMMAND)
+            self.assertEqual(response.status_code, 204)

backend/api_gateway/carpool_request_endpoint/views.py

@@ -1,6 +1,6 @@
 import json
 from django.http \
-    import HttpResponseNotAllowed, JsonResponse
+    import HttpResponseNotAllowed, HttpResponseBadRequest, JsonResponse
 from backend.common.command.carpool_request_create_command \
     import CarpoolRequestCreateCommand, CARPOOL_REQUEST_CREATE_COMMAND
 from backend.common.command.carpool_request_delete_command \
@@ -9,15 +9,6 @@
     import RedisRpcClient
 
 
-"""
-TODO: add exception controller
-"""
-
-
-def with_json_response(status, data):
-    return JsonResponse(data=json.dumps(data), status=status, safe=False)
-
-
 def carpool_request(request):
     if request.method == 'POST':
         return __create_carpool_request(request)
@@ -28,30 +19,27 @@ def carpool_request(request):
 
 
 def __create_carpool_request(request):
-    body = json.loads(request.body.decode())
-    # TODO: check KeyError
-    command = CarpoolRequestCreateCommand(
-        from_location=body['from_location'],
-        to_location=body['to_location'],
-        minimum_passenger=body['minimum_passenger'],
-        rider_id=body['rider_id'],
-    )
-
-    result = RedisRpcClient().call(CARPOOL_REQUEST_CREATE_COMMAND, command)
-    data = {'jsonrpc': result.jsonrpc,
-            'id': result.id, 'result': result.result}
+    try:
+        body = json.loads(request.body.decode())
+        command = CarpoolRequestCreateCommand(
+            from_location=body['from_location'],
+            to_location=body['to_location'],
+            minimum_passenger=body['minimum_passenger'],
+            rider_id=body['rider_id'],
+        )
+    except(KeyError, JSONDecodeError) as e:
+        return HttpResponseBadRequest(e)
 
-    # TODO: handling exception
-    return with_json_response(status=204, data=data)
+    rpc_response = RedisRpcClient().call(CARPOOL_REQUEST_CREATE_COMMAND, command)
+    return JsonResponse(data=rpc_response.result, status=204, safe=False)
 
 
 def __delete_carpool_request(request):
-    body = json.loads(request.body.decode())
-    # TODO: check KeyError
-    command = CarpoolRequestDeleteCommand(request_id=body['request_id'])
-    result = RedisRpcClient().call(CARPOOL_REQUEST_DELETE_COMMAND, command)
-    data = {'jsonrpc': result.jsonrpc,
-            'id': result.id, 'result': result.result}
-
-    # TODO: handling exception
-    return with_json_response(status=204, data=data)
+    try:
+        body = json.loads(request.body.decode())
+        command = CarpoolRequestDeleteCommand(request_id=body['request_id'])
+    except(KeyError, JSONDecodeError) as e:
+        return HttpResponseBadRequest(e)
+
+    rpc_response = RedisRpcClient().call(CARPOOL_REQUEST_DELETE_COMMAND, command)
+    return JsonResponse(data=rpc_response.result, status=204, safe=False)

backend/api_gateway/group_endpoint/tests/test_group_controller.py

@@ -1,15 +1,73 @@
 from django.test import TestCase, Client
-
-# Needs editing
+from unittest.mock import patch
+from backend.common.rpc.infra.adapter.redis.redis_rpc_client \
+    import RedisRpcClient
+from backend.common.rpc.rpc_response import RpcResponse
+from backend.common.command.group_create_command import GROUP_CREATE_COMMAND
+from backend.common.command.group_update_command import GROUP_UPDATE_COMMAND
+from backend.group_service.group.domain.group import Group
 
 
 class GroupControllerTestCase(TestCase):
 
     def setUp(self):
         self.client = Client()
 
-    def test_group(self):
-        response = self.client.get(
-            '/api/v1/group/', content_type='application/json')
 
+    def test_create_group_wrong_api(self):
+        response = self.client.get(
+            '/api/v1/group/',
+            content_type='application/json'
+        )
         self.assertEqual(response.status_code, 405)
+
+
+    @patch.object(RedisRpcClient, 'call')
+    def test_create_group_success(self, call_fn):
+        request = {
+            'rider_id_list': [1,2,3,4],
+            'from_location': 'here',
+            'to_location': 'there'
+        }
+        call_fn.return_value = RpcResponse(
+            result={
+                'rider_id_list': [1,2,3,4],
+                'from_location': 'here',
+                'to_location': 'there'
+            },
+            id=1,
+        )
+        response = self.client.post(
+            '/api/v1/group/', 
+            request,
+            content_type='application/json'
+        )
+
+        args, kwargs = call_fn.call_args
+        self.assertEqual(args[0], GROUP_CREATE_COMMAND)
+        self.assertEqual(response.status_code, 204)
+
+
+    @patch.object(RedisRpcClient, 'call')
+    def test_update_group_sucess(self, call_fn):
+        mock_group = Group.objects.create(id=1)
+        request = {
+            'driverId': 1,
+            'groupId': 2,
+        }
+        call_fn.return_value = RpcResponse(
+            result={
+                'driver_id': 1,
+                'group_id': 2,
+            },
+            id=1,
+        )
+        response = self.client.put(
+            '/api/v1/group/1',
+            request,
+            content_type='application/json'
+        )
+
+        args, kwargs = call_fn.call_args
+        self.assertEqual(args[0], GROUP_UPDATE_COMMAND)
+        self.assertEqual(response.status_code, 204)

backend/api_gateway/group_endpoint/views.py

@@ -1,4 +1,5 @@
 import json
+from json import JSONDecodeError
 from django.http \
     import HttpResponseNotAllowed, JsonResponse
 
@@ -11,14 +12,6 @@
 from backend.common.rpc.infra.adapter.redis.redis_rpc_client \
     import RedisRpcClient
 
-"""
-TODO: add exception controller
-"""
-
-
-def with_json_response(status, data):
-    return JsonResponse(data=json.dumps(data), status=status, safe=False)
-
 
 def group(request):
     if request.method == 'POST':
@@ -28,18 +21,18 @@ def group(request):
 
 
 def __create_group(request):
-    body = json.loads(request.body.decode())
-    # TODO: check KeyError
-    command = GroupCreateCommand(
-        from_location=body['from_location'],
-        to_location=body['to_location'])
-
-    result = RedisRpcClient().call(GROUP_CREATE_COMMAND, command)
-    data = {'jsonrpc': result.jsonrpc,
-            'id': result.id, 'result': result.result}
-
-    # TODO: handling exception
-    return with_json_response(status=204, data=data)
+    try:
+        body = json.loads(request.body.decode())
+        command = GroupCreateCommand(
+            rider_id_list=body['rider_id_list'],
+            from_location=body['from_location'],
+            to_location=body['to_location']
+        )
+    except (KeyError, JSONDecodeError) as e:
+        return HttpResponseBadRequest(e)
+
+    rpc_response = RedisRpcClient().call(GROUP_CREATE_COMMAND, command)
+    return JsonResponse(data=rpc_response.result, status=204, safe=False)
 
 
 def update_driver(request, group_id):

backend/api_gateway/user_endpoint/tests/test_user_controller.py

@@ -1,29 +1,115 @@
 from django.test import TestCase, Client
+from unittest.mock import patch
+from backend.common.rpc.infra.adapter.redis.redis_rpc_client \
+    import RedisRpcClient
+from backend.common.rpc.rpc_response import RpcResponse
+from backend.common.command.user_create_command \
+    import USER_CREATE_COMMAND
+from backend.common.event.user_login_event \
+    import USER_LOGIN_EVENT
+from django.contrib.auth import get_user_model
 
 
 class UserControllerTestCase(TestCase):
 
     def setUp(self):
         self.client = Client()
 
-    def test_register_user_when_method_is_not_post_response_with_405(self):
+    def test_register_user_wrong_api(self):
         response = self.client.get('/api/v1/user/register',
                                    content_type='application/json')
 
         self.assertEqual(response.status_code, 405)
 
+
+    @patch.object(RedisRpcClient, 'call')
+    def test_register_user_rider_success(self, call_fn):
+        request = {
+            'email': 'swpp@swpp.com',
+            'password': 'pleaseNotC',
+            'userType': 'rider',
+            'carType': '',
+            'plateNo': ''
+        }
+        call_fn.return_value = RpcResponse(
+            result={
+                'email': 'swpp@swpp.com',
+                'password': 'pleaseNotC',
+                'user_type': 'rider',
+                'car_type': '',
+                'plate_no': ''
+            },
+            id=1,
+        )
+        response = self.client.post(
+            '/api/v1/user/register',
+            request,
+            content_type='application/json'
+        )
+
+        args, kwargs = call_fn.call_args
+        self.assertEqual(args[0], USER_CREATE_COMMAND)
+        self.assertEqual(response.status_code, 200)
+
+
+    @patch.object(RedisRpcClient, 'call')
+    def test_register_user_driver_success(self, call_fn):
+        request = {
+            'email': 'swpp@swpp.com',
+            'password': 'pleaseNotC',
+            'userType': 'driver',
+            'carType': 'BMW',
+            'plateNo': '01a 1234'
+        }
+        call_fn.return_value = RpcResponse(
+            result={
+                'email': 'swpp@swpp.com',
+                'password': 'pleaseNotC',
+                'user_type': 'driver',
+                'car_type': 'BMW',
+                'plate_no': '01a 1234'
+            },
+            id=1,
+        )
+        response = self.client.post(
+            '/api/v1/user/register',
+            request,
+            content_type='application/json'
+        )
+
+        args, kwargs = call_fn.call_args
+        self.assertEqual(args[0], USER_CREATE_COMMAND)
+        self.assertEqual(response.status_code, 200)
+
+
+    @patch.object(RedisRpcClient, 'call')
+    def test_check_user_success(self, call_fn):
+        mock_user = get_user_model().objects.create(id=1)
+        call_fn.return_value = RpcResponse(
+            result={},
+            id=1,
+        )
+        response = self.client.get(
+            '/api/v1/user/1',
+            content_type='application/json'
+        )
+        self.assertEqual(response.status_code, 200)
+
+
     def test_login_user_when_method_is_not_post_response_with_405(self):
         response = self.client.get('/api/v1/user/login',
                                    content_type='application/json')
 
         self.assertEqual(response.status_code, 405)
 
+
     def test_logout_user_when_method_is_not_post_response_with_405(self):
         response = self.client.get('/api/v1/user/logout',
                                    content_type='application/json')
 
         self.assertEqual(response.status_code, 401)
 
+
     def test_check_when_not_get(self):
         response = self.client.post('/api/v1/user/1',
                                     content_type='application/json')