Buckets:
AnonymousSpottedToad/human_verified_bucket / codebase /python /inteliver_inteliver /tests /test_user_router.py
| from uuid import uuid4 | |
| import pytest | |
| from fastapi import status | |
| from httpx import AsyncClient | |
| from inteliver.auth.schemas import Token | |
| from inteliver.auth.service import AuthService | |
| from inteliver.config import settings | |
| from inteliver.users.exceptions import ( | |
| DatabaseException, | |
| UserAlreadyExistsException, | |
| UserNotFoundException, | |
| ) | |
| from inteliver.users.models import User | |
| from inteliver.users.schemas import UserCreate, UserPatch, UserPut | |
| # Test scenarios for create user | |
| # Endpoint POST /users/ | |
| async def test_create_new_user_success( | |
| test_client: AsyncClient, auth_token_admin: Token, pre_existing_admin: User | |
| ): | |
| new_user_data = UserCreate( | |
| email_username="newuser@example.com", | |
| password="newpassword123", | |
| name="New User", | |
| cloudname="newuser", | |
| ) | |
| response = await test_client.post( | |
| f"{settings.api_prefix}/users/", | |
| json=new_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_201_CREATED | |
| created_user = response.json() | |
| assert created_user["email_username"] == new_user_data.email_username | |
| assert created_user["name"] == new_user_data.name | |
| assert created_user["cloudname"] == new_user_data.cloudname | |
| assert "uid" in created_user | |
| async def test_create_new_user_already_exists( | |
| test_client: AsyncClient, auth_token_admin: Token, pre_existing_admin: User, mocker | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.create_user", | |
| side_effect=UserAlreadyExistsException("User already exists"), | |
| ) | |
| new_user_data = UserCreate( | |
| email_username="existing@example.com", | |
| password="password123", | |
| name="Existing User", | |
| cloudname="existinguser", | |
| ) | |
| response = await test_client.post( | |
| f"{settings.api_prefix}/users/", | |
| json=new_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_409_CONFLICT | |
| async def test_create_new_user_unauthorized(test_client: AsyncClient): | |
| new_user_data = UserCreate( | |
| email_username="newuser@example.com", | |
| password="newpassword123", | |
| name="New User", | |
| cloudname="newuser", | |
| ) | |
| response = await test_client.post( | |
| f"{settings.api_prefix}/users/", json=new_user_data.model_dump() | |
| ) | |
| assert response.status_code == status.HTTP_401_UNAUTHORIZED | |
| async def test_create_new_user_insufficient_role( | |
| test_client: AsyncClient, auth_token: Token | |
| ): | |
| new_user_data = UserCreate( | |
| email_username="newuser@example.com", | |
| password="newpassword123", | |
| name="New User", | |
| cloudname="newuser", | |
| ) | |
| response = await test_client.post( | |
| f"{settings.api_prefix}/users/", | |
| json=new_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_403_FORBIDDEN | |
| async def test_create_new_user_database_exception( | |
| test_client: AsyncClient, auth_token_admin: Token, mocker | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.create_user", | |
| side_effect=DatabaseException("Database error"), | |
| ) | |
| new_user_data = UserCreate( | |
| email_username="newuser@example.com", | |
| password="newpassword123", | |
| name="New User", | |
| cloudname="newuser", | |
| ) | |
| response = await test_client.post( | |
| f"{settings.api_prefix}/users/", | |
| json=new_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| async def test_create_new_user_general_exception( | |
| test_client: AsyncClient, auth_token_admin: Token, mocker | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.create_user", | |
| side_effect=Exception("Unexpected error"), | |
| ) | |
| new_user_data = UserCreate( | |
| email_username="newuser@example.com", | |
| password="newpassword123", | |
| name="New User", | |
| cloudname="newuser", | |
| ) | |
| response = await test_client.post( | |
| f"{settings.api_prefix}/users/", | |
| json=new_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| # Test scenarios for get user by id | |
| # Endpoint GET /users/{user_id} | |
| async def test_get_user_by_id_success( | |
| test_client: AsyncClient, auth_token_admin: Token, pre_existing_user: User | |
| ): | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_200_OK | |
| user_data = response.json() | |
| assert user_data["uid"] == str(pre_existing_user.uid) | |
| assert user_data["email_username"] == pre_existing_user.email_username | |
| assert user_data["name"] == pre_existing_user.name | |
| assert user_data["cloudname"] == pre_existing_user.cloudname | |
| async def test_get_user_by_id_not_found( | |
| test_client: AsyncClient, auth_token_admin: Token, pre_existing_user: User, mocker | |
| ): | |
| non_existent_id = uuid4() | |
| mocker.patch( | |
| "inteliver.users.service.UserService.get_user_by_id", | |
| side_effect=UserNotFoundException("User not found"), | |
| ) | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/{non_existent_id}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_404_NOT_FOUND | |
| async def test_get_user_by_id_unauthorized(test_client: AsyncClient): | |
| random_id = uuid4() | |
| response = await test_client.get(f"{settings.api_prefix}/users/{random_id}") | |
| assert response.status_code == status.HTTP_401_UNAUTHORIZED | |
| async def test_get_user_by_id_insufficient_permission( | |
| test_client: AsyncClient, | |
| auth_token: Token, | |
| pre_existing_user: User, | |
| pre_existing_user_second: User, | |
| ): | |
| """Test a scenario that a user would request another user info""" | |
| # accessing second user using the credentials of the first user | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/{pre_existing_user_second.uid}", | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_403_FORBIDDEN | |
| async def test_get_user_by_id_database_exception( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| pre_existing_user: User, | |
| mocker, | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.get_user_by_id", | |
| side_effect=DatabaseException("Database error"), | |
| ) | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| async def test_get_user_by_id_general_exception( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| pre_existing_user: User, | |
| mocker, | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.get_user_by_id", | |
| side_effect=Exception("Unexpected error"), | |
| ) | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| # Test scenarios for get user by email | |
| # Endpoint GET /users/by-email/?email=email@example.com | |
| async def test_get_user_by_email_success( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| pre_existing_user: User, | |
| ): | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/by-email/?email={pre_existing_user.email_username}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_200_OK | |
| user_data = response.json() | |
| assert user_data["email_username"] == pre_existing_user.email_username | |
| assert user_data["name"] == pre_existing_user.name | |
| assert user_data["cloudname"] == pre_existing_user.cloudname | |
| async def test_get_user_by_email_not_found( | |
| test_client: AsyncClient, auth_token_admin: Token, mocker | |
| ): | |
| non_existent_email = "nonexistent@example.com" | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/by-email/?email={non_existent_email}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_404_NOT_FOUND | |
| async def test_get_user_by_email_unauthorized(test_client: AsyncClient): | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/by-email/?email=test@example.com" | |
| ) | |
| assert response.status_code == status.HTTP_401_UNAUTHORIZED | |
| async def test_get_user_by_email_insufficient_permission( | |
| test_client: AsyncClient, auth_token: Token, mocker | |
| ): | |
| not_current_user_email = "not_current_user_email@example.com" | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/by-email/?email={not_current_user_email}", | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_403_FORBIDDEN | |
| async def test_get_user_by_email_database_exception( | |
| test_client: AsyncClient, | |
| auth_token: Token, | |
| pre_existing_user: User, | |
| mocker, | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.get_user_by_email", | |
| side_effect=DatabaseException("Database error"), | |
| ) | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/by-email/?email={pre_existing_user.email_username}", | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| async def test_get_user_by_email_general_exception( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| pre_existing_user: User, | |
| mocker, | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.get_user_by_email", | |
| side_effect=Exception("Unexpected error"), | |
| ) | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/by-email/?email={pre_existing_user.email_username}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| async def test_get_user_by_email_invalid_email( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| ): | |
| invalid_email = "invalid_email" | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/by-email/?email={invalid_email}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY | |
| # Test scenarios for get all users | |
| # Endpoint GET /users/ | |
| async def test_get_all_users_success( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| pre_existing_user: User, | |
| ): | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_200_OK | |
| users_data = response.json() | |
| assert isinstance(users_data, list) | |
| assert len(users_data) > 0 | |
| async def test_get_all_users_unauthorized(test_client: AsyncClient): | |
| response = await test_client.get(f"{settings.api_prefix}/users/") | |
| assert response.status_code == status.HTTP_401_UNAUTHORIZED | |
| async def test_get_all_users_insufficient_permission( | |
| test_client: AsyncClient, auth_token: Token | |
| ): | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/", | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_403_FORBIDDEN | |
| async def test_get_all_users_database_exception( | |
| test_client: AsyncClient, auth_token_admin: Token, mocker | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.get_all_users", | |
| side_effect=DatabaseException("Database error"), | |
| ) | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| async def test_get_all_users_general_exception( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| mocker, | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.get_all_users", | |
| side_effect=Exception("Unexpected error"), | |
| ) | |
| response = await test_client.get( | |
| f"{settings.api_prefix}/users/", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| # Test scenarios for update user by id | |
| # Endpoint put /users/ | |
| async def test_update_user_by_id_success( | |
| test_client: AsyncClient, auth_token: Token, pre_existing_user: User | |
| ): | |
| updated_user_data = UserPut( | |
| name="Updated Name", | |
| ) | |
| response = await test_client.put( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| json=updated_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_200_OK | |
| updated_user = response.json() | |
| assert updated_user["name"] == updated_user_data.name | |
| assert updated_user["email_username"] == pre_existing_user.email_username | |
| assert updated_user["cloudname"] == pre_existing_user.cloudname | |
| async def test_update_user_by_id_not_found( | |
| test_client: AsyncClient, auth_token_admin: Token, mocker | |
| ): | |
| non_existent_id = uuid4() | |
| updated_user_data = UserPut( | |
| name="Updated Name", | |
| ) | |
| response = await test_client.put( | |
| f"{settings.api_prefix}/users/{non_existent_id}", | |
| json=updated_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_404_NOT_FOUND | |
| async def test_update_user_by_id_unauthorized(test_client: AsyncClient): | |
| random_id = uuid4() | |
| updated_user_data = UserPut( | |
| name="Updated Name", | |
| ) | |
| response = await test_client.put( | |
| f"{settings.api_prefix}/users/{random_id}", json=updated_user_data.model_dump() | |
| ) | |
| assert response.status_code == status.HTTP_401_UNAUTHORIZED | |
| async def test_update_user_by_id_insufficient_permission( | |
| test_client: AsyncClient, | |
| auth_token: Token, | |
| pre_existing_user: User, | |
| mocker, | |
| ): | |
| random_id = uuid4() | |
| updated_user_data = UserPut( | |
| name="Updated Name", | |
| ) | |
| response = await test_client.put( | |
| f"{settings.api_prefix}/users/{random_id}", | |
| json=updated_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_403_FORBIDDEN | |
| async def test_update_user_by_id_database_exception( | |
| test_client: AsyncClient, | |
| auth_token: Token, | |
| pre_existing_user: User, | |
| mocker, | |
| ): | |
| updated_user_data = UserPut( | |
| name="Updated Name", | |
| ) | |
| mocker.patch( | |
| "inteliver.users.service.UserService.update_user", | |
| side_effect=DatabaseException("Database error"), | |
| ) | |
| response = await test_client.put( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| json=updated_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| async def test_update_user_by_id_general_exception( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| pre_existing_user: User, | |
| mocker, | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.update_user", | |
| side_effect=Exception("Unexpected error"), | |
| ) | |
| updated_user_data = UserPut( | |
| name="Updated Name", | |
| ) | |
| response = await test_client.put( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| json=updated_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| # Test scenarios for patch user by id | |
| # Endpoint patch /users/ | |
| async def test_patch_user_by_id_success( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| pre_existing_user: User, | |
| ): | |
| patch_data = UserPatch(name="Updated Name") | |
| response = await test_client.patch( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| json=patch_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_200_OK | |
| updated_user = response.json() | |
| assert updated_user["name"] == patch_data.name | |
| assert updated_user["email_username"] == pre_existing_user.email_username | |
| assert updated_user["cloudname"] == pre_existing_user.cloudname | |
| async def test_patch_user_by_id_not_found( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| mocker, | |
| ): | |
| non_existent_id = uuid4() | |
| patch_data = UserPatch(name="Updated Name") | |
| response = await test_client.patch( | |
| f"{settings.api_prefix}/users/{non_existent_id}", | |
| json=patch_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_404_NOT_FOUND | |
| async def test_patch_user_by_id_unauthorized(test_client: AsyncClient): | |
| random_id = uuid4() | |
| patch_data = UserPatch(name="Updated Name") | |
| response = await test_client.patch( | |
| f"{settings.api_prefix}/users/{random_id}", json=patch_data.model_dump() | |
| ) | |
| assert response.status_code == status.HTTP_401_UNAUTHORIZED | |
| async def test_patch_user_by_id_insufficient_permission( | |
| test_client: AsyncClient, | |
| auth_token: Token, | |
| ): | |
| random_id = uuid4() | |
| patch_data = UserPatch(name="Updated Name") | |
| response = await test_client.patch( | |
| f"{settings.api_prefix}/users/{random_id}", | |
| json=patch_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_403_FORBIDDEN | |
| async def test_patch_user_by_id_general_exception( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| pre_existing_user: User, | |
| mocker, | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.patch_user", | |
| side_effect=Exception("Unexpected error"), | |
| ) | |
| updated_user_data = UserPatch( | |
| name="Updated Name", | |
| ) | |
| response = await test_client.patch( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| json=updated_user_data.model_dump(), | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| # Test scenarios for delete user by id | |
| # Endpoint delete /users/ | |
| async def test_delete_user_by_id_success( | |
| test_client: AsyncClient, auth_token: Token, pre_existing_user: User | |
| ): | |
| response = await test_client.delete( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_200_OK | |
| deleted_user = response.json() | |
| assert deleted_user["uid"] == str(pre_existing_user.uid) | |
| assert deleted_user["email_username"] == pre_existing_user.email_username | |
| async def test_delete_user_by_id_not_found( | |
| test_client: AsyncClient, auth_token_admin: Token | |
| ): | |
| non_existent_id = uuid4() | |
| response = await test_client.delete( | |
| f"{settings.api_prefix}/users/{non_existent_id}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_404_NOT_FOUND | |
| async def test_delete_user_by_id_unauthorized(test_client: AsyncClient): | |
| random_id = uuid4() | |
| response = await test_client.delete(f"{settings.api_prefix}/users/{random_id}") | |
| assert response.status_code == status.HTTP_401_UNAUTHORIZED | |
| async def test_delete_user_by_id_insufficient_permission( | |
| test_client: AsyncClient, auth_token: Token | |
| ): | |
| random_id = uuid4() | |
| response = await test_client.delete( | |
| f"{settings.api_prefix}/users/{random_id}", | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_403_FORBIDDEN | |
| async def test_delete_user_by_id_database_exception( | |
| test_client: AsyncClient, auth_token: Token, pre_existing_user: User, mocker | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.delete_user", | |
| side_effect=DatabaseException("Database error"), | |
| ) | |
| response = await test_client.delete( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| headers={"Authorization": f"Bearer {auth_token.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
| async def test_delete_user_by_id_general_exception( | |
| test_client: AsyncClient, | |
| auth_token_admin: Token, | |
| pre_existing_user: User, | |
| mocker, | |
| ): | |
| mocker.patch( | |
| "inteliver.users.service.UserService.delete_user", | |
| side_effect=Exception("Unexpected error"), | |
| ) | |
| response = await test_client.delete( | |
| f"{settings.api_prefix}/users/{pre_existing_user.uid}", | |
| headers={"Authorization": f"Bearer {auth_token_admin.access_token}"}, | |
| ) | |
| assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR | |
Xet Storage Details
- Size:
- 22.9 kB
- Xet hash:
- 70e3619315145806369703b09ee35feddfa1cfcf65a058a668f850dbd16f8146
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.