resolve test

app/routers/friend_request.py

@@ -68,15 +68,21 @@ 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=409, 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):
@@ -113,13 +119,17 @@ def deleteRequest(RequestId: str, user=Depends(get_current_user)):
     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=403, 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

@@ -11,6 +11,7 @@ from fastapi import (
     APIRouter,
     Depends,
     HTTPException,
+    Request,
     UploadFile,
     BackgroundTasks,
     status,
@@ -26,12 +27,11 @@ from app import logger
 router = APIRouter(prefix="/video", tags=["Video"])
 
 
-@router.post("")
+@router.post("", dependencies=[Depends(get_current_user)])
 async def handleVideoRequest(
     file: UploadFile,
     background_tasks: BackgroundTasks,
     threshold: float = 0.3,
-    user=Depends(get_current_user),
 ):
     if re.search("^video\/", file.content_type) is None:
         raise HTTPException(
@@ -46,7 +46,7 @@ async def handleVideoRequest(
         )
         os.mkdir(id)
         async with aiofiles.open(os.path.join(id, "input.mp4"), "wb") as out_file:
-            while content := await file.read(1024):
+            while content := await file.read(102400):
                 await out_file.write(content)
         background_tasks.add_task(inferenceVideo, artifact_ref.id, id, threshold)
         return id + ".mp4"
@@ -66,7 +66,7 @@ def createThumbnail(thumbnail, inputDir):
     cv2.imwrite(os.path.join(inputDir, "thumbnail.jpg"), thumbnail)
 
 
-def inference_frame(inputDir, threshold: float = 0.3):
+def inferenceFrame(inputDir, threshold: float = 0.3):
     cap = cv2.VideoCapture(
         filename=os.path.join(inputDir, "input.mp4"), apiPreference=cv2.CAP_FFMPEG
     )
@@ -103,9 +103,10 @@ def inference_frame(inputDir, threshold: float = 0.3):
 
 
 async def inferenceVideo(artifactId: str, inputDir: str, threshold: float):
+    logger.info("Start inference video")
     try:
         Process(updateArtifact(artifactId, {"status": "processing"})).start()
-        thumbnail = inference_frame(inputDir, threshold=threshold)
+        thumbnail = inferenceFrame(inputDir, threshold=threshold)
         createThumbnail(thumbnail, inputDir)
 
         async def uploadVideo():

tests/test_video.py

@@ -1,10 +1,9 @@
 from fastapi.testclient import TestClient
 from fastapi.routing import APIRoute
-from app.routers.video import updateArtifact, 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
-        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
+        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)