updated tests

frontend/src/views/Chat.vue

@@ -43,7 +43,7 @@ onMounted(() => {
   msg.requestMessages()
   msgTimer.value = setInterval(() => {
     msg.requestMessages(msg.lastMsg()?.timestamp)
-  }, 3000) // 3s
+  }, 1000) // 1s
 })
 
 // Clean up polling

simple_chat_api/db_handler/user_manager.py

@@ -1,6 +1,6 @@
 
 from simple_chat_api.db_handler.db_handler import DbConnector
-from simple_chat_api.config import JWT_SECRET, hash_context
+from simple_chat_api.config import hash_context
 
 class UserManager:
     """

simple_chat_api/endpoints/messages.py

@@ -21,6 +21,7 @@ def recive_msg(user: User, room: str):
         response.status = 400
         return {"error": "Missing 'content' in request body"}
     new_msg = request.db_connector.add_msg_to_room(room, msg["content"], user.name)
+
     return serialize_message([new_msg])
 
 @app.route('/<room>', method=['GET'])

simple_chat_api/tests/user_manager_unittest.py

@@ -21,26 +21,94 @@ class TestUserManagmentWrapper(unittest.TestCase):
         os.remove(DB_PATH)
 
     def test_create_user(self):
-        user = ("someone", "some_pass")
+        users = [("someone", "pass"), ("someone", "fail")]
-        ret = self.user_mgr.create_user(*user)
+        for user in users:
-        self.assertTrue(ret, f"user {user} faild to be created")
+            with self.subTest(user):
+                ret = self.user_mgr.create_user(*user)
+                if user[1] == "fail":
+                    self.assertFalse(ret, f"user {user} was created but should not")
+                else:
+                    self.assertTrue(ret, f"user {user} faild to be created")
 
     def test_authenticate(self):
-        self.assertTrue(self.user_mgr.authenticate(*EXISTING_USER), 
+        test_cases = [
-                         f"Existing user {EXISTING_USER} could not be authenticated")
+            {
-        self.assertFalse(self.user_mgr.authenticate(EXISTING_USER[0], "unknown_pass"), 
+                "username": EXISTING_USER[0],
-                         f"Existing user {EXISTING_USER[0]} could be authenticated with wrong password")
+                "password": EXISTING_USER[1],
-        self.assertFalse(self.user_mgr.authenticate("unknown_user", "unknown_pass"), 
+                "expected": True,
-                         f"An unknown User was authenticated")
+                "msg": f"Existing user {EXISTING_USER} could not be authenticated"
-        
+            },
+            {
+                "username": EXISTING_USER[0],
+                "password": "unknown_pass",
+                "expected": False,
+                "msg": f"Existing user {EXISTING_USER[0]} could be authenticated with wrong password"
+            },
+            {
+                "username": "unknown_user",
+                "password": "unknown_pass",
+                "expected": False,
+                "msg": "An unknown user was authenticated"
+            },
+        ]
+
+        for case in test_cases:
+            with self.subTest(username=case["username"], password=case["password"]):
+                result = self.user_mgr.authenticate(case["username"], case["password"])
+                self.assertEqual(result, case["expected"], case["msg"])
+
     def test_delete_user(self):
-        self.assertTrue(self.user_mgr.delete_user(EXISTING_USER[0]), f"The existing user {EXISTING_USER[0]} could not be removed")
+        test_cases = [
-        self.assertFalse(self.user_mgr.delete_user("unknown_user"), "an unknown user could be deleted")
+            {
+                "username": EXISTING_USER[0],
+                "expected": True,
+                "msg": f"The existing user {EXISTING_USER[0]} could not be removed"
+            },
+            {
+                "username": "unknown_user",
+                "expected": False,
+                "msg": "an unknown user could be deleted"
+            },
+        ]
+        for case in test_cases:
+            with self.subTest(username=case["username"]):
+                result = self.user_mgr.delete_user(case["username"])
+                self.assertEqual(result, case["expected"], case["msg"])
 
     def test_change_password(self):
-        self.assertTrue(self.user_mgr.change_user_password(EXISTING_USER[0], "new_pass"), f"Could not change password for existing user")
+        test_cases = [
-        self.assertFalse(self.user_mgr.change_user_password("unknown_user", "new_pass"), "The password for an unknown user was changed")
+            {
+                "username": EXISTING_USER[0],
+                "new_password": "new_pass",
+                "expected": True,
+                "msg": f"Could not change password for existing user {EXISTING_USER[0]}"
+            },
+            {
+                "username": "unknown_user",
+                "new_password": "new_pass",
+                "expected": False,
+                "msg": "The password for an unknown user was changed"
+            },
+        ]
+        for case in test_cases:
+            with self.subTest(username=case["username"]):
+                result = self.user_mgr.change_user_password(case["username"], case["new_password"])
+                self.assertEqual(result, case["expected"], case["msg"])
 
     def test_check_user_exists(self):
-        self.assertTrue(self.user_mgr.check_user_exists(EXISTING_USER[0]), f"The {EXISTING_USER[0]} could not be found")
+        test_cases = [
-        self.assertFalse(self.user_mgr.check_user_exists("unknown_user"), "An unknown user was found")
+            {
+                "username": EXISTING_USER[0],
+                "expected": True,
+                "msg": f"The existing user {EXISTING_USER[0]} could not be found"
+            },
+            {
+                "username": "unknown_user",
+                "expected": False,
+                "msg": "An unknown user was found"
+            },
+        ]
+        for case in test_cases:
+            with self.subTest(username=case["username"]):
+                result = self.user_mgr.check_user_exists(case["username"])
+                self.assertEqual(result, case["expected"], case["msg"])