302 lines
10 KiB
Python
302 lines
10 KiB
Python
"""
|
|
Test suite for UserRepository with async/await support.
|
|
|
|
This module contains comprehensive tests for all UserRepository methods
|
|
using mongomock-motor for in-memory MongoDB testing.
|
|
"""
|
|
|
|
import pytest
|
|
from datetime import datetime
|
|
|
|
import pytest_asyncio
|
|
from bson import ObjectId
|
|
from pymongo.errors import DuplicateKeyError
|
|
from mongomock_motor import AsyncMongoMockClient
|
|
|
|
from app.database.repositories.user_repository import UserRepository
|
|
from app.models.user import UserCreate, UserUpdate, UserInDB
|
|
|
|
|
|
@pytest_asyncio.fixture
|
|
async def in_memory_repository():
|
|
"""Create an in-memory UserRepository for testing."""
|
|
client = AsyncMongoMockClient()
|
|
db = client.test_database
|
|
repo = UserRepository(db)
|
|
await repo.initialize()
|
|
return repo
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_user_create():
|
|
"""Sample UserCreate data for testing."""
|
|
return UserCreate(
|
|
username="testuser",
|
|
email="test@example.com",
|
|
password="#TestPassword123",
|
|
role="user"
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_user_update():
|
|
"""Sample UserUpdate data for testing."""
|
|
return UserUpdate(
|
|
username="updateduser",
|
|
email="updated@example.com",
|
|
role="admin"
|
|
)
|
|
|
|
|
|
class TestUserRepositoryCreation:
|
|
"""Tests for user creation functionality."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_create_user(self, in_memory_repository, sample_user_create):
|
|
"""Test successful user creation."""
|
|
# Act
|
|
created_user = await in_memory_repository.create_user(sample_user_create)
|
|
|
|
# Assert
|
|
assert created_user is not None
|
|
assert created_user.username == sample_user_create.username
|
|
assert created_user.email == sample_user_create.email
|
|
assert created_user.role == sample_user_create.role
|
|
assert created_user.is_active is True
|
|
assert created_user.id is not None
|
|
assert created_user.created_at is not None
|
|
assert created_user.updated_at is not None
|
|
assert created_user.hashed_password != sample_user_create.password # Should be hashed
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_cannot_create_user_with_duplicate_username(self, in_memory_repository, sample_user_create):
|
|
"""Test that creating user with duplicate username raises DuplicateKeyError."""
|
|
# Arrange
|
|
await in_memory_repository.create_user(sample_user_create)
|
|
|
|
# Act & Assert
|
|
with pytest.raises(DuplicateKeyError) as exc_info:
|
|
await in_memory_repository.create_user(sample_user_create)
|
|
|
|
assert "already exists" in str(exc_info.value)
|
|
|
|
|
|
class TestUserRepositoryFinding:
|
|
"""Tests for user finding functionality."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_find_user_by_id(self, in_memory_repository, sample_user_create):
|
|
"""Test finding user by valid ID."""
|
|
# Arrange
|
|
created_user = await in_memory_repository.create_user(sample_user_create)
|
|
|
|
# Act
|
|
found_user = await in_memory_repository.find_user_by_id(str(created_user.id))
|
|
|
|
# Assert
|
|
assert found_user is not None
|
|
assert found_user.id == created_user.id
|
|
assert found_user.username == created_user.username
|
|
assert found_user.email == created_user.email
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_cannot_find_user_by_invalid_id(self, in_memory_repository):
|
|
"""Test that invalid ObjectId returns None."""
|
|
# Act
|
|
found_user = await in_memory_repository.find_user_by_id("invalid_id")
|
|
|
|
# Assert
|
|
assert found_user is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_cannot_find_user_by_nonexistent_id(self, in_memory_repository):
|
|
"""Test that nonexistent but valid ObjectId returns None."""
|
|
# Arrange
|
|
nonexistent_id = str(ObjectId())
|
|
|
|
# Act
|
|
found_user = await in_memory_repository.find_user_by_id(nonexistent_id)
|
|
|
|
# Assert
|
|
assert found_user is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_find_user_by_username(self, in_memory_repository, sample_user_create):
|
|
"""Test finding user by username."""
|
|
# Arrange
|
|
created_user = await in_memory_repository.create_user(sample_user_create)
|
|
|
|
# Act
|
|
found_user = await in_memory_repository.find_user_by_username(sample_user_create.username)
|
|
|
|
# Assert
|
|
assert found_user is not None
|
|
assert found_user.username == created_user.username
|
|
assert found_user.id == created_user.id
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_cannot_find_user_by_nonexistent_username(self, in_memory_repository):
|
|
"""Test that nonexistent username returns None."""
|
|
# Act
|
|
found_user = await in_memory_repository.find_user_by_username("nonexistent")
|
|
|
|
# Assert
|
|
assert found_user is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_find_user_by_email(self, in_memory_repository, sample_user_create):
|
|
"""Test finding user by email."""
|
|
# Arrange
|
|
created_user = await in_memory_repository.create_user(sample_user_create)
|
|
|
|
# Act
|
|
found_user = await in_memory_repository.find_user_by_email(str(sample_user_create.email))
|
|
|
|
# Assert
|
|
assert found_user is not None
|
|
assert found_user.email == created_user.email
|
|
assert found_user.id == created_user.id
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_cannot_find_user_by_nonexistent_email(self, in_memory_repository):
|
|
"""Test that nonexistent email returns None."""
|
|
# Act
|
|
found_user = await in_memory_repository.find_user_by_email("nonexistent@example.com")
|
|
|
|
# Assert
|
|
assert found_user is None
|
|
|
|
|
|
class TestUserRepositoryUpdate:
|
|
"""Tests for user update functionality."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_update_user(self, in_memory_repository, sample_user_create, sample_user_update):
|
|
"""Test successful user update."""
|
|
# Arrange
|
|
created_user = await in_memory_repository.create_user(sample_user_create)
|
|
original_updated_at = created_user.updated_at
|
|
|
|
# Act
|
|
updated_user = await in_memory_repository.update_user(str(created_user.id), sample_user_update)
|
|
|
|
# Assert
|
|
assert updated_user is not None
|
|
assert updated_user.username == sample_user_update.username
|
|
assert updated_user.email == sample_user_update.email
|
|
assert updated_user.role == sample_user_update.role
|
|
assert updated_user.id == created_user.id
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_cannot_update_user_with_invalid_id(self, in_memory_repository, sample_user_update):
|
|
"""Test that updating with invalid ID returns None."""
|
|
# Act
|
|
result = await in_memory_repository.update_user("invalid_id", sample_user_update)
|
|
|
|
# Assert
|
|
assert result is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_update_user_with_partial_data(self, in_memory_repository, sample_user_create):
|
|
"""Test updating user with partial data."""
|
|
# Arrange
|
|
created_user = await in_memory_repository.create_user(sample_user_create)
|
|
partial_update = UserUpdate(username="newusername")
|
|
|
|
# Act
|
|
updated_user = await in_memory_repository.update_user(str(created_user.id), partial_update)
|
|
|
|
# Assert
|
|
assert updated_user is not None
|
|
assert updated_user.username == "newusername"
|
|
assert updated_user.email == created_user.email # Should remain unchanged
|
|
assert updated_user.role == created_user.role # Should remain unchanged
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_update_user_with_empty_data(self, in_memory_repository, sample_user_create):
|
|
"""Test updating user with empty data returns current user."""
|
|
# Arrange
|
|
created_user = await in_memory_repository.create_user(sample_user_create)
|
|
empty_update = UserUpdate()
|
|
|
|
# Act
|
|
result = await in_memory_repository.update_user(str(created_user.id), empty_update)
|
|
|
|
# Assert
|
|
assert result is not None
|
|
assert result.username == created_user.username
|
|
assert result.email == created_user.email
|
|
|
|
|
|
class TestUserRepositoryDeletion:
|
|
"""Tests for user deletion functionality."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_delete_user(self, in_memory_repository, sample_user_create):
|
|
"""Test successful user deletion."""
|
|
# Arrange
|
|
created_user = await in_memory_repository.create_user(sample_user_create)
|
|
|
|
# Act
|
|
deletion_result = await in_memory_repository.delete_user(str(created_user.id))
|
|
|
|
# Assert
|
|
assert deletion_result is True
|
|
|
|
# Verify user is actually deleted
|
|
found_user = await in_memory_repository.find_user_by_id(str(created_user.id))
|
|
assert found_user is None
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_cannot_delete_user_with_invalid_id(self, in_memory_repository):
|
|
"""Test that deleting with invalid ID returns False."""
|
|
# Act
|
|
result = await in_memory_repository.delete_user("invalid_id")
|
|
|
|
# Assert
|
|
assert result is False
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_cannot_delete_nonexistent_user(self, in_memory_repository):
|
|
"""Test that deleting nonexistent user returns False."""
|
|
# Arrange
|
|
nonexistent_id = str(ObjectId())
|
|
|
|
# Act
|
|
result = await in_memory_repository.delete_user(nonexistent_id)
|
|
|
|
# Assert
|
|
assert result is False
|
|
|
|
|
|
class TestUserRepositoryUtilities:
|
|
"""Tests for utility methods."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_count_users(self, in_memory_repository, sample_user_create):
|
|
"""Test counting users."""
|
|
# Arrange
|
|
initial_count = await in_memory_repository.count_users()
|
|
await in_memory_repository.create_user(sample_user_create)
|
|
|
|
# Act
|
|
final_count = await in_memory_repository.count_users()
|
|
|
|
# Assert
|
|
assert final_count == initial_count + 1
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_i_can_check_user_exists(self, in_memory_repository, sample_user_create):
|
|
"""Test checking if user exists."""
|
|
# Arrange
|
|
await in_memory_repository.create_user(sample_user_create)
|
|
|
|
# Act
|
|
exists = await in_memory_repository.user_exists(sample_user_create.username)
|
|
not_exists = await in_memory_repository.user_exists("nonexistent")
|
|
|
|
# Assert
|
|
assert exists is True
|
|
assert not_exists is False
|
|
|