Merge branch 'main' of https://github.com/phuochungus/SE113.O12_KCPM into DA1

.gitignore

@@ -7,4 +7,5 @@ demo
 **/*.mp4
 **/*.jpg
 .pytest_cache
-!demo.jpg
+!demo.jpg
+/htmlcov

app/routers/friend_request.py

@@ -8,6 +8,8 @@ from app.dependencies import get_current_user
 from app import db, logger
 from enum import Enum
 from app.graphdb.main import insert2PersonAndSetFriend
+from fastapi import status
+
 
 router = APIRouter(prefix="/friend_request", tags=["friend_request"])
 
@@ -66,29 +68,41 @@ async def acceptRequest(RequestId: str, user=Depends(get_current_user)):
     fr = fr_ref.get()
 
     if not fr.exists:
-        raise HTTPException(status_code=404, detail="Friend request not found")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Friend request not found"
+        )
 
     fr = fr.to_dict()
 
     if isRequestExpired(fr):
-        raise HTTPException(status_code=400, detail="Friend request expired")
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT, detail="Friend request expired"
+        )
 
     if isRequestDone(fr):
-        raise HTTPException(status_code=400, detail="Friend request already done")
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT, detail="Friend request already done"
+        )
 
     if isInviter(user, fr):
         if isInviteeEmpty(fr):
-            raise HTTPException(status_code=400, detail="Invitee is empty")
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT, detail="Invitee is empty"
+            )
         fr_ref.update({"status": RequestStatus.COMPLETE.value})
         await makeFriend(fr["invitee"], fr["inviter"])
         return {"status": "OK"}
-
-    if isInviteeEmpty(fr) and not isInviter(user, fr):
-        fr_ref.update(
-            {"invitee": user["sub"], "status": RequestStatus.WAITING_INVITER.value}
-        )
-        sendNotificationToInviter(fr["inviter"], user)
-        return {"status": "OK"}
+    else:
+        if isInviteeEmpty(fr):
+            fr_ref.update(
+                {"invitee": user["sub"], "status": RequestStatus.WAITING_INVITER.value}
+            )
+            sendNotificationToInviter(fr["inviter"], user)
+            return {"status": "OK"}
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_409_CONFLICT, detail="Invitee is not empty"
+            )
 
 
 def sendNotificationToInviter(inviterId: str, invitee):
@@ -101,20 +115,21 @@ async def makeFriend(inviteeId: str, inviterId: str):
 
 @router.delete("/{RequestId}")
 def deleteRequest(RequestId: str, user=Depends(get_current_user)):
-    if user.sub is None:
-        raise HTTPException(status_code=400, detail="User not found")
-
     Request_ref = db.collection(COLLECTION_NAME).document(RequestId)
-    Request = Request_ref.get().to_dict()
+    Request = Request_ref.get()
 
     if not Request.exists:
-        raise HTTPException(status_code=404, detail="Friend request not found")
-
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Friend request not found"
+        )
+    Request = Request.to_dict()
     if isInviter(user, Request):
         Request_ref.delete()
         return {"status": "OK"}
     else:
-        raise HTTPException(status_code=400, detail="You are not inviter")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN, detail="You are not inviter"
+        )
 
 
 def isRequestExpired(request):

app/routers/me.py

@@ -9,8 +9,3 @@ router = APIRouter(prefix="/me", tags=["Me"])
 @router.get("")
 def getProfile(current_user=Depends(get_current_user)):
     return current_user
-
-
-@router.get("/friends")
-def getFriends(current_user=Depends(get_current_user)):
-    raise NotImplementedError()

app/routers/video.py

@@ -12,6 +12,7 @@ from fastapi import (
     Depends,
     HTTPException,
     Request,
+    Request,
     UploadFile,
     BackgroundTasks,
     status,

tests/test_friend_request.py

@@ -141,11 +141,21 @@ class TestFriendRequest:
         assert result.shape[2] == 3
         # Write image for later read
         mmcv.imwrite(result, "qrcode.jpg")
+        request_id = read_qr_code("qrcode.jpg")
+        ## Send request again (accept friend request when no invitee)
+        payload = ""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + inviter["token"],
+        }
+        response = client.request(
+            "PATCH", "friend_request/" + request_id, headers=headers, data=payload
+        )
+        assert response.status_code == 409
         # Now test for the invitee aka the one that scan QR code
         # Delete invitee user (if existed)
         user_ref.document(invitee["id"]).delete()
         # Test when the invitee is unknow user (no user entity in database)
-        request_id = read_qr_code("qrcode.jpg")
         payload = ""
         headers = {
             "Content-Type": "application/json",
@@ -159,6 +169,28 @@ class TestFriendRequest:
         # Create invitee user
         user_ref.document(invitee["id"]).set({"deviceId": deviceId})
         # Send request
+        ## Send request with false token 
+        payload = ""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + "xxxxxx",
+        }
+        response = client.request(
+            "PATCH", "friend_request/" + request_id, headers=headers, data=payload
+        )
+        assert response.status_code == 401
+        ## Send request
+        request_id = read_qr_code("qrcode.jpg")
+        payload = ""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + invitee["token"],
+        }
+        response = client.request(
+            "PATCH", "friend_request/" + request_id, headers=headers, data=payload
+        )
+        assert response.status_code == 200
+        ## Send request again (false)
         request_id = read_qr_code("qrcode.jpg")
         payload = ""
         headers = {
@@ -168,7 +200,95 @@ class TestFriendRequest:
         response = client.request(
             "PATCH", "friend_request/" + request_id, headers=headers, data=payload
         )
+        assert response.status_code == 409
+        ## Send request again (accept friend request from invitee)
+        request_id = read_qr_code("qrcode.jpg")
+        payload = ""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + inviter["token"],
+        }
+        response = client.request(
+            "PATCH", "friend_request/" + request_id, headers=headers, data=payload
+        )
         assert response.status_code == 200
         # Delete entity for next time test
         user_ref.document(inviter["id"]).delete()
         user_ref.document(invitee["id"]).delete()
+    def test_delete_requestF(self, client, inviter, invitee):
+        # Call the firebase database
+        friend_request_ref = db.collection("friend_request")
+        # Remove all the friend_request use for testing in the past
+        query = friend_request_ref.where(
+            filter=FieldFilter("inviter", "==", inviter["id"])
+        )
+        docs = query.stream()
+        for doc in docs:
+            doc.reference.delete()
+        # Delete the user for safety-check
+        user_ref = db.collection("user")
+        user_ref.document(inviter["id"]).delete()
+        # Create request and re-send
+        user_ref.document(inviter["id"]).set({"deviceId": deviceId})
+        payload = ""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + inviter["token"],
+        }
+        response = client.request(
+            "POST", "friend_request", headers=headers, data=payload
+        )
+        assert response.status_code == 200
+        result = mmcv.imfrombytes(response.read())
+        # Check returned QR image
+        assert result.shape[2] == 3
+        # Write image for later read
+        mmcv.imwrite(result, "qrcode.jpg")
+        request_id = read_qr_code("qrcode.jpg")
+        #Check with unknowed invitee
+        payload = ""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + invitee["token"],
+        }
+        response = client.request(
+            "DELETE", "friend_request/" + request_id, headers=headers, data=payload
+        )
+        assert response.status_code == 403
+        #Delete invitee for safety check
+        user_ref.document(invitee["id"]).delete()
+        # Create invitee user
+        user_ref.document(invitee["id"]).set({"deviceId": deviceId})
+        # check DELETE route
+        payload = ""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + inviter["token"],
+        }
+        response = client.request(
+            "DELETE", "friend_request/" + "xxxx", headers=headers, data=payload
+        )
+        assert response.status_code == 404
+        payload = ""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + invitee["token"],
+        }
+        response = client.request(
+            "DELETE", "friend_request/" + request_id, headers=headers, data=payload
+        )
+        assert response.status_code == 403
+        #Correct Request
+        payload = ""
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + inviter["token"],
+        }
+        response = client.request(
+            "DELETE", "friend_request/" + request_id, headers=headers, data=payload
+        )
+        assert response.status_code == 200
+
+        # Delete entity for next time test
+        user_ref.document(inviter["id"]).delete()
+        user_ref.document(invitee["id"]).delete()

tests/test_video.py

@@ -1,10 +1,9 @@
 from fastapi.testclient import TestClient
 from fastapi.routing import APIRoute
-from app.routers.video import update_artifact, createThumbnail, inference_frame
+from app.routers.video import updateArtifact, createThumbnail, inferenceFrame
 from app.main import app
 from app.constants import deviceId
 from app import db
-import platform
 import mmcv
 import os
 import pytest
@@ -14,120 +13,137 @@ import cv2
 import shutil
 from google.cloud.firestore_v1.base_query import FieldFilter
 
+
 def endpoints():
     endpoints = []
     for route in app.routes:
         if isinstance(route, APIRoute):
             endpoints.append(route.path)
     return endpoints
+
+
 @pytest.fixture
 def client():
     client = TestClient(app, "http://0.0.0.0:3000")
     yield client
+
+
 @pytest.fixture
 def user():
-    url = "https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=" + os.environ.get("FIREBASE_API_KEY")
-    
-    payload = json.dumps({
-    "email": "test_video@gmail.com",
-    "password": "testing",
-    "returnSecureToken": True
-    })
-    headers = {
-    'Content-Type': 'application/json'
-    }
+    url = (
+        "https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key="
+        + os.environ.get("FIREBASE_API_KEY")
+    )
+
+    payload = json.dumps(
+        {
+            "email": "test_video@gmail.com",
+            "password": "testing",
+            "returnSecureToken": True,
+        }
+    )
+    headers = {"Content-Type": "application/json"}
     response = requests.request("POST", url, headers=headers, data=payload)
     data = response.json()
-    user = {"id": data['localId'], "token": data["idToken"]}
-    db.collection("user").document(user['id']).set({"deviceId": deviceId})
+    user = {"id": data["localId"], "token": data["idToken"]}
+    db.collection("user").document(user["id"]).set({"deviceId": deviceId})
     yield user
-    db.collection("user").document(user['id']).delete()
+    db.collection("user").document(user["id"]).delete()
+
+
 class TestVideoAPI:
-    @pytest.mark.skipif("/video" not in endpoints(),reason="Route not defined")
+    @pytest.mark.skipif("/video" not in endpoints(), reason="Route not defined")
     def test_video_API(self, user, client):
         # Test when no token is pass to route
         payload = {}
-        files=[
-        ('file',('demo.mp4',open('demo.mp4','rb'),'video/mp4'))
-        ]
-        headers = {
-        }
-        response = client.request("POST", 'video', headers=headers, data=payload, files=files)
+        files = [("file", ("demo.mp4", open("demo.mp4", "rb"), "video/mp4"))]
+        headers = {}
+        response = client.request(
+            "POST", "video", headers=headers, data=payload, files=files
+        )
         assert response.status_code == 403
         # Test when a dummy (not valid) token passed
         payload = {}
-        files=[
-        ('file',('demo.mp4',open('demo.mp4','rb'),'video/mp4'))
-        ]
-        headers = {
-        'Authorization': "Bearer saikoljncaskljnfckjnasckjna"
-        }
-        response = client.request("POST", 'video', headers=headers, data=payload, files=files)
+        files = [("file", ("demo.mp4", open("demo.mp4", "rb"), "video/mp4"))]
+        headers = {"Authorization": "Bearer saikoljncaskljnfckjnasckjna"}
+        response = client.request(
+            "POST", "video", headers=headers, data=payload, files=files
+        )
         assert response.status_code == 401
         # Test when sent file is not a video
         payload = {}
-        files=[
-        ('file',('demo.jpg',open('demo.jpg','rb'),'application/octet-stream'))
+        files = [
+            ("file", ("demo.jpg", open("demo.jpg", "rb"), "application/octet-stream"))
         ]
-        headers = {
-        'Authorization': "Bearer " + user['token']
-        }
+        headers = {"Authorization": "Bearer " + user["token"]}
         while True:
-            response = client.request("POST", 'video', headers=headers, data=payload, files=files)
+            response = client.request(
+                "POST", "video", headers=headers, data=payload, files=files
+            )
             if response.status_code != 401:
                 break
         assert response.status_code == 400
         # Test when all requirements have been fulfilled
         payload = {}
-        files=[
-        ('file',('demo.mp4',open('demo.mp4','rb'),'video/mp4'))
-        ]
-        headers = {
-        'Authorization': "Bearer " + user['token']
-        }
-        response = client.request("POST", 'video', headers=headers, data=payload, files=files)
+        files = [("file", ("demo.mp4", open("demo.mp4", "rb"), "video/mp4"))]
+        headers = {"Authorization": "Bearer " + user["token"]}
+        response = client.request(
+            "POST", "video", headers=headers, data=payload, files=files
+        )
         assert response.status_code == 200
         artifactName = response.text
-        docs = db.collection("artifacts").where(filter = FieldFilter("name", '==', artifactName)).stream()
+        docs = (
+            db.collection("artifacts")
+            .where(filter=FieldFilter("name", "==", artifactName))
+            .stream()
+        )
         index = 0
         for doc in docs:
             # For each document in docs. Verify name and status of the artifact
             index += 1
             data = doc.get().to_dict()
-            assert data['name'] == artifactName
-            assert data['status'] == 'pending'
+            assert data["name"] == artifactName
+            assert data["status"] == "pending"
             assert index == 1
             doc.delete()
+
     def test_update_artifact(self):
         # Check and preprocess test data before testing
-        test_artifact = db.collection("artifacts").document('test')
+        test_artifact = db.collection("artifacts").document("test")
         if not test_artifact.get().exists:
-            db.collection("artifacts").document('test').set({"name": "test", "path": "", "status": "testing", "thumbnailURL":""})
-            test_artifact = db.collection("artifacts").document('test')
+            db.collection("artifacts").document("test").set(
+                {"name": "test", "path": "", "status": "testing", "thumbnailURL": ""}
+            )
+            test_artifact = db.collection("artifacts").document("test")
         else:
-            test_artifact.update({"status": "testing", 'path': '', "thumbnailURL":""})
+            test_artifact.update({"status": "testing", "path": "", "thumbnailURL": ""})
         # Testing update on each field
-        update_artifact(test_artifact.id,{"status": "test_done"})
-        assert db.collection("artifacts").document('test').get().to_dict()['status'] == 'test_done'
-        #Delete data for next time test
+        updateArtifact(test_artifact.id, {"status": "test_done"})
+        assert (
+            db.collection("artifacts").document("test").get().to_dict()["status"]
+            == "test_done"
+        )
+        # Delete data for next time test
         test_artifact.delete()
+
     def test_inference_frame(self):
-        if not os.path.exists('test_vid'):
-            os.mkdir('test_vid')
-        shutil.copyfile('demo.mp4', 'test_vid/input.mp4')
-        thumbnail = inference_frame('test_vid')
-        assert os.path.exists("test_vid/out.mp4") and os.path.isfile('test_vid/out.mp4')
-        vidcap = cv2.VideoCapture('test_vid/input.mp4')
+        if not os.path.exists("test_vid"):
+            os.mkdir("test_vid")
+        shutil.copyfile("demo.mp4", "test_vid/input.mp4")
+        thumbnail = inferenceFrame("test_vid")
+        assert os.path.exists("test_vid/out.mp4") and os.path.isfile("test_vid/out.mp4")
+        vidcap = cv2.VideoCapture("test_vid/input.mp4")
         success, image = vidcap.read()
         if success:
-            assert (image.shape == thumbnail.shape)
+            assert image.shape == thumbnail.shape
         vidcap.release()
         del vidcap
-        shutil.rmtree('test_vid')
+        shutil.rmtree("test_vid")
+
     def test_create_thumbnal(self):
-        vidcap = cv2.VideoCapture('demo.mp4')
+        vidcap = cv2.VideoCapture("demo.mp4")
         success, image = vidcap.read()
         if success:
             createThumbnail(image, "")
-            result = mmcv.imread('thumbnail.jpg', channel_order='rgb')
-            assert (result.shape == (160, 160, 3))
+            result = mmcv.imread("thumbnail.jpg", channel_order="rgb")
+            assert result.shape == (160, 160, 3)