diff --git a/api/credential_api.py b/api/credential_api.py index c940704..49d4c32 100644 --- a/api/credential_api.py +++ b/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() diff --git a/api/folder_api.py b/api/folder_api.py index 3bf0025..4d2d609 100644 --- a/api/folder_api.py +++ b/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() diff --git a/api/group_api.py b/api/group_api.py new file mode 100644 index 0000000..d86eb21 --- /dev/null +++ b/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() + diff --git a/api/user_api.py b/api/user_api.py index 06d0b3c..a0ab583 100644 --- a/api/user_api.py +++ b/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() diff --git a/service/credential_service.py b/service/credential_service.py index 675eb37..1164b35 100644 --- a/service/credential_service.py +++ b/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"] diff --git a/service/folder_service.py b/service/folder_service.py index 74bce9e..727da7d 100644 --- a/service/folder_service.py +++ b/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"] diff --git a/service/group_services.py b/service/group_services.py new file mode 100644 index 0000000..e4f3eaf --- /dev/null +++ b/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"] + diff --git a/service/user_services.py b/service/user_services.py index 7eebfd3..be4074d 100644 --- a/service/user_services.py +++ b/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) diff --git a/tests/credential_tests.py b/tests/credential_tests.py index 3237db8..7b8a9c2 100644 --- a/tests/credential_tests.py +++ b/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) diff --git a/tests/folder_tests.py b/tests/folder_tests.py index 591e197..b28064b 100644 --- a/tests/folder_tests.py +++ b/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 = diff --git a/tests/group_tests.py b/tests/group_tests.py new file mode 100644 index 0000000..820a403 --- /dev/null +++ b/tests/group_tests.py @@ -0,0 +1,52 @@ +import unittest + +from faker import Faker +from service.group_services import ( + create_group_service, + create_random_group, + fetch_all_group_users_service, + fetch_all_user_groups_service, +) +from service.user_services import ( + create_random_user, + register_user, login, + fetch_all_users, + create_and_login_random_user, +) +from utils.test_utils import is_valid_uuid + +fake = Faker() + + +class TestFolder(unittest.TestCase): + + def setUp(self): + self.user, temp_password = create_random_user() + register_user(self.user, temp_password) + login(self.user) + + def test_create_group(self): + group_name = fake.file_name() + description = fake.text() + group_id = create_group_service(self.user, group_name, description) + + self.assertTrue(is_valid_uuid(group_id)) + + # def test_add_users_to_group(self): + # group_owner = create_and_login_random_user() + # new_member = create_and_login_random_user() + # group_id = create_random_group(group_owner) + # users_list = fetch_all_users(self.user) + # result=users_list[1]['name'] + # add_user_to_group_service(group_id=group_id,user=self.user) + + def test_fetch_all_group_users(self): + group_owner = create_and_login_random_user() + group_id = create_random_group(group_owner) + group_members = fetch_all_group_users_service(group_id=group_id, user=group_owner) + + def test_fetch_all_user_groups(self): + user = create_and_login_random_user() + group_id_1 = create_random_group(user) + group_id_2 = create_random_group(user) + user_groups = fetch_all_user_groups_service(user) diff --git a/tests/share_credential_tests.py b/tests/share_credential_tests.py index 9fb3f6c..673a68b 100644 --- a/tests/share_credential_tests.py +++ b/tests/share_credential_tests.py @@ -75,3 +75,14 @@ def test_share_credentials_to_single_user(self): "fieldValue": field.field_value, } self.assertIn(expected_dict, fetched_field_values) + + def setUp(self): + + self.share_from_user = create_and_login_random_user() + self.share_to_group = create_and_login_random_user() + + self.folder_id = create_random_folder(self.share_from_user) + + def test_share_credentials_to_groups(self): + credentials = [] + for _ in range(3) \ No newline at end of file diff --git a/tests/user_tests.py b/tests/user_tests.py index 684dd9c..863d4ec 100644 --- a/tests/user_tests.py +++ b/tests/user_tests.py @@ -1,4 +1,4 @@ -from service.user_services import create_random_user, register_user, login +from service.user_services import create_random_user, register_user, login, fetch_all_users import unittest from utils.test_utils import is_valid_uuid @@ -21,3 +21,20 @@ def test_login_user(self): login(user) self.assertTrue(user.token) + + def test_create_folder(self): + + user, temp_password = create_random_user() + user, response_bool = register_user(user, temp_password) + login(user) + + self.assertTrue(user.token) + + def test_fetch_all_users(self): + + user, temp_password = create_random_user() + user, response_bool = register_user(user, temp_password) + login(user) + result = fetch_all_users(user) + self.assertTrue(user.token) +