Create group api tests

api/credential_api.py

@@ -97,3 +97,20 @@ def get_sensitive_fields_by_id_api(credential_id: str, user: User):
         raise ValueError("API response is not successful")
 
     return response.json()
+
+
+def get_credentials_by_folder_api(folder_id, user):
+    api_url = f"{settings.API_BASE_URL}/folder/{folder_id}/credential"
+
+    headers = {
+        "Authorization": f"Bearer{user.token}",
+    }
+
+    response = requests.get(api_url, headers=headers)
+    response.raise_for_status()
+
+    response_json = response.json()
+    if not check_api_success(response_json):
+        raise ValueError("API response is not successful")
+
+    return response.json()

api/folder_api.py

@@ -40,3 +40,20 @@ def get_users_with_folder_access_api(folder_id, user):
         raise ValueError("API response is not successful")
 
     return response.json()
+
+
+def fetch_all_folders_api(user):
+    api_url = f"{settings.API_BASE_URL}/folders"
+
+    headers = {
+        "Authorization": f"Bearer {user.token}",
+    }
+
+    response = requests.get(api_url, headers=headers)
+    response.raise_for_status()
+
+    response_json = response.json()
+    if not check_api_success(response_json):
+        raise ValueError("API response is not successful")
+
+    return response.json()

api/group_api.py

@@ -0,0 +1,60 @@
+import requests
+import settings
+from utils.api_validator import check_api_success
+
+
+def create_group_api(group_name, description, token):
+    api_url = f"{settings.API_BASE_URL}/group"
+
+    payload = {
+        "name": group_name,
+        "description": description,
+    }
+
+    headers = {
+        "Authorization": f"Bearer {token}",
+    }
+
+    response = requests.post(api_url, json=payload, headers=headers)
+    response.raise_for_status()
+
+    response_json = response.json()
+    if not check_api_success(response_json):
+        raise ValueError("API response is not successful")
+
+    return response.json()
+
+
+def fetch_all_group_users_api(group_id, user):
+    api_url = f"{settings.API_BASE_URL}/folder/{group_id}/users"
+
+    headers = {
+        "Authorization": f"Bearer {user.token}",
+    }
+
+    response = requests.get(api_url, headers=headers)
+    response.raise_for_status()
+
+    response_json = response.json()
+    if not check_api_success(response_json):
+        raise ValueError("API response is not successful")
+
+    return response.json()
+
+
+def fetch_all_user_groups_api(user):
+    api_url = f"{settings.API_BASE_URL}/groups"
+
+    headers = {
+        "Authorization": f"Bearer {user.token}",
+    }
+
+    response = requests.get(api_url, headers=headers)
+    response.raise_for_status()
+
+    response_json = response.json()
+    if not check_api_success(response_json):
+        raise ValueError("API response is not successful")
+
+    return response.json()
+

api/user_api.py

@@ -74,3 +74,20 @@ def verify_challenge_api(ecc_public_key, signature):
         raise ValueError("API response is not successful")
 
     return response.json()
+
+
+def fetch_all_users_api(token):
+    api_url = f"{settings.API_BASE_URL}/users"
+
+    headers = {
+        "Authorization": f"Bearer {token}",
+    }
+
+    response = requests.get(api_url, headers=headers)
+    response.raise_for_status()
+
+    response_json = response.json()
+    if not check_api_success(response_json):
+        raise ValueError("API response is not successful")
+
+    return response.json()

service/credential_service.py

@@ -10,6 +10,7 @@
     get_credential_data_api,
     get_credential_fields_by_ids_api,
     get_sensitive_fields_by_id_api,
+    get_credentials_by_folder_api,
 )
 from service.folder_service import get_users_with_folder_access
 
@@ -26,7 +27,6 @@ def encrypt_fields(fields: list[Field], public_key: str) -> list[Field]:
 
 
 def create_random_credential(folder_id: uuid.UUID, user: User) -> Credential:
-
     original_fields = [FieldFactory() for _ in range(5)]
 
     user_fields = UserFieldsFactory(user=user)
@@ -38,7 +38,6 @@ def create_random_credential(folder_id: uuid.UUID, user: User) -> Credential:
 
     encrypted_user_fields = []
     for folder_user in folder_users:
-
         user_encrypted_fields = encrypt_fields(
             original_fields, add_public_key_header(folder_user["publicKey"])
         )
@@ -58,7 +57,6 @@ def create_random_credential(folder_id: uuid.UUID, user: User) -> Credential:
 
 
 def get_credential_data(credential_id: uuid.UUID, user: User):
-
     response = get_credential_data_api(
         credential_id=credential_id,
         user=user,
@@ -68,7 +66,6 @@ def get_credential_data(credential_id: uuid.UUID, user: User):
 
 
 def get_credential_data_with_sensitive_fields(credential_id: uuid.UUID, user: User):
-
     credential_data = get_credential_data_api(
         credential_id=credential_id,
         user=user,
@@ -85,7 +82,11 @@ def get_credential_data_with_sensitive_fields(credential_id: uuid.UUID, user: Us
 
 
 def get_credential_fields_by_ids(credential_ids: list[int], user: User):
-
     return get_credential_fields_by_ids_api(credential_ids=credential_ids, user=user)[
         "data"
     ]
+
+
+def get_credentials_by_folder_service(folder_id: uuid.UUID, user: User):
+    response = get_credentials_by_folder_api(folder_id=folder_id, user=user)
+    return response["data"]

service/folder_service.py

@@ -1,4 +1,8 @@
-from api.folder_api import create_folder_api, get_users_with_folder_access_api
+from api.folder_api import (
+    create_folder_api,
+    get_users_with_folder_access_api,
+    fetch_all_folders_api,
+)
 
 from faker import Faker
 
@@ -26,6 +30,13 @@ def get_users_with_folder_access(folder_id, user):
 def create_random_folder(user):
     folder_name = fake.name()
     description = fake.text()
+    user = user
     folder_id = create_folder_service(user, folder_name, description)
 
     return folder_id
+
+
+def fetch_all_folders_service(user):
+    token = user.token
+    response = fetch_all_folders_api(user)
+    return response["data"]

service/group_services.py

@@ -0,0 +1,36 @@
+from api.group_api import create_group_api, fetch_all_group_users_api, fetch_all_user_groups_api
+
+from faker import Faker
+
+fake = Faker()
+
+
+def create_group_service(user, group_name, description):
+    token = user.token
+    response = create_group_api(
+        group_name=group_name,
+        description=description,
+        token=token,
+    )
+    return response["data"]["groupId"]
+
+
+def create_random_group(user):
+    group_name = fake.name()
+    description = fake.text()
+    group_id = create_group_service(user, group_name, description)
+
+    return group_id
+
+
+# def add_users_to_group_service()
+
+def fetch_all_group_users_service(group_id, user):
+    response = fetch_all_group_users_api(group_id=group_id, user=user)
+    return response["data"]
+
+
+def fetch_all_user_groups_service(user):
+    response = fetch_all_user_groups_api(user)
+    return response["data"]
+

service/user_services.py

@@ -5,6 +5,7 @@
     register_user_api,
     get_challenge_api,
     verify_challenge_api,
+    fetch_all_users_api,
 )
 from model.user import User
 from utils.crypto import (
@@ -63,6 +64,12 @@ def login(user):
     user.token = token
 
 
+def fetch_all_users(user):
+    token = user.token
+    response = fetch_all_users_api(token)
+    return response["data"]
+
+
 def create_and_login_random_user():
     user, temp_password = create_random_user()
     user, token = register_user(user, temp_password)

tests/credential_tests.py

@@ -1,9 +1,9 @@
 import unittest
 
-from factories.credential import FieldFactory
+# from factories.credential import FieldFactory
 from service.folder_service import create_random_folder
-from service.user_services import create_random_user, register_user, login
-from service.credential_service import create_random_credential, get_credential_data
+from service.user_services import create_random_user, register_user, login, create_and_login_random_user
+from service.credential_service import create_random_credential, get_credential_data, get_credentials_by_folder_service
 from utils.test_utils import is_valid_uuid, is_valid_timestamp
 
 from faker import Faker
@@ -71,3 +71,47 @@ def test_get_credential_data_by_id(self):
                 "fieldValue": field.field_value,
             }
             self.assertIn(expected_dict, fetched_field_values)
+
+    def test_get_credentials_by_folder(self):
+        user = create_and_login_random_user()
+        folder_id = create_random_folder(user)
+        created_credential = create_random_credential(folder_id, user=user)
+
+        fetched_credential = get_credentials_by_folder_service(
+            folder_id=folder_id, user=user
+        )
+        self.assertEqual(
+            created_credential.credential_id, fetched_credential["credentialId"]
+        )
+        self.assertEqual(created_credential.folder_id, fetched_credential["folderId"])
+        self.assertEqual(
+            created_credential.description, fetched_credential["description"]
+        )
+        self.assertEqual(created_credential.name, fetched_credential["name"])
+        self.assertEqual(
+            created_credential.credential_type, fetched_credential["credentialType"]
+        )
+        self.assertEqual("owner", fetched_credential["accessType"])
+        self.assertEqual(self.user.user_id, fetched_credential["createdBy"])
+        self.assertTrue(is_valid_timestamp(fetched_credential["createdAt"]))
+        self.assertTrue(is_valid_timestamp(fetched_credential["updatedAt"]))
+
+        fetched_field_values = [
+            {
+                "fieldName": field["fieldName"],
+                "fieldValue": field["fieldValue"],
+                "fieldType": field["fieldType"],
+            }
+            for field in fetched_credential["fields"]
+        ]
+
+        for field in created_credential.user_fields[0].field:
+            if field.field_type == "sensitive":
+                continue
+
+            expected_dict = {
+                "fieldType": field.field_type,
+                "fieldName": field.field_name,
+                "fieldValue": field.field_value,
+            }
+            self.assertIn(expected_dict, fetched_field_values)

tests/folder_tests.py

@@ -1,11 +1,17 @@
 import unittest
 
-from service.folder_service import create_folder_service, get_users_with_folder_access
+from service.folder_service import (
+    create_folder_service,
+    get_users_with_folder_access,
+    create_random_folder,
+    fetch_all_folders_service
+)
 from service.user_services import (
     create_random_user,
     register_user,
-    login,
+    login, create_and_login_random_user
 )
+from service.group_services import  create_random_group
 from utils.test_utils import is_valid_uuid
 
 from faker import Faker
@@ -34,3 +40,15 @@ def test_get_users_with_folder_access(self):
         users = get_users_with_folder_access(folder_id, self.user)
 
         self.assertEqual(users[0]["id"], self.user.user_id)
+
+    def test_fetch_all_folders(self):
+        user = create_and_login_random_user()
+        folder_id = create_random_folder(user)
+        folders = fetch_all_folders_service(user)
+
+
+    # def test_fetch_all_folder_groups(self):
+    #     user = create_and_login_random_user()
+    #     folder_id = create_random_folder(user)
+    #     group_id = create_random_group(user)
+    #     folders =