497 lines
18 KiB
Python
497 lines
18 KiB
Python
"""
|
|
Test suite for JobRepository with async/support.
|
|
|
|
This module contains comprehensive tests for all JobRepository methods
|
|
using mongomock-motor for in-memory MongoDB testing.
|
|
"""
|
|
|
|
from datetime import datetime
|
|
|
|
import pytest
|
|
from bson import ObjectId
|
|
from mongomock.mongo_client import MongoClient
|
|
from mongomock_motor import AsyncMongoMockClient
|
|
from pymongo.errors import PyMongoError
|
|
|
|
from app.database.repositories.job_repository import JobRepository
|
|
from app.exceptions.job_exceptions import JobRepositoryError
|
|
from app.models.job import ProcessingJob, ProcessingStatus
|
|
from app.models.types import PyObjectId
|
|
|
|
|
|
@pytest.fixture
|
|
def in_memory_repository():
|
|
"""Create an in-memory JobRepository for testing."""
|
|
client = MongoClient()
|
|
db = client.test_database
|
|
repo = JobRepository(db)
|
|
repo.initialize()
|
|
return repo
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_document_id():
|
|
"""Sample document ObjectId for testing."""
|
|
return PyObjectId()
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_task_id():
|
|
"""Sample Celery task ID for testing."""
|
|
return "celery-task-12345-abcde"
|
|
|
|
|
|
@pytest.fixture
|
|
def multiple_sample_jobs():
|
|
"""Multiple ProcessingJob objects for testing."""
|
|
doc_id_1 = ObjectId()
|
|
doc_id_2 = ObjectId()
|
|
base_time = datetime.utcnow()
|
|
|
|
return [
|
|
ProcessingJob(
|
|
document_id=doc_id_1,
|
|
status=ProcessingStatus.PENDING,
|
|
task_id="task-1",
|
|
created_at=base_time,
|
|
started_at=None,
|
|
completed_at=None,
|
|
error_message=None
|
|
),
|
|
ProcessingJob(
|
|
document_id=doc_id_2,
|
|
status=ProcessingStatus.PROCESSING,
|
|
task_id="task-2",
|
|
created_at=base_time,
|
|
started_at=base_time,
|
|
completed_at=None,
|
|
error_message=None
|
|
),
|
|
ProcessingJob(
|
|
document_id=doc_id_1,
|
|
status=ProcessingStatus.COMPLETED,
|
|
task_id="task-3",
|
|
created_at=base_time,
|
|
started_at=base_time,
|
|
completed_at=base_time,
|
|
error_message=None
|
|
)
|
|
]
|
|
|
|
|
|
class TestJobRepositoryInitialization:
|
|
"""Tests for repository initialization."""
|
|
|
|
def test_i_can_initialize_repository(self):
|
|
"""Test repository initialization."""
|
|
# Arrange
|
|
client = AsyncMongoMockClient()
|
|
db = client.test_database
|
|
repo = JobRepository(db)
|
|
|
|
# Act
|
|
initialized_repo = repo.initialize()
|
|
|
|
# Assert
|
|
assert initialized_repo is repo
|
|
assert repo.db is not None
|
|
assert repo.collection is not None
|
|
|
|
|
|
class TestJobRepositoryCreation:
|
|
"""Tests for job creation functionality."""
|
|
|
|
def test_i_can_create_job_with_task_id(self, in_memory_repository, sample_document_id, sample_task_id):
|
|
"""Test successful job creation with task ID."""
|
|
# Act
|
|
created_job = in_memory_repository.create_job(sample_document_id, sample_task_id)
|
|
|
|
# Assert
|
|
assert created_job is not None
|
|
assert created_job.document_id == sample_document_id
|
|
assert created_job.task_id == sample_task_id
|
|
assert created_job.status == ProcessingStatus.PENDING
|
|
assert created_job.created_at is not None
|
|
assert created_job.started_at is None
|
|
assert created_job.completed_at is None
|
|
assert created_job.error_message is None
|
|
assert created_job.id is not None
|
|
assert isinstance(created_job.id, ObjectId)
|
|
|
|
def test_i_can_create_job_without_task_id(self, in_memory_repository, sample_document_id):
|
|
"""Test successful job creation without task ID."""
|
|
# Act
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
|
|
# Assert
|
|
assert created_job is not None
|
|
assert created_job.document_id == sample_document_id
|
|
assert created_job.task_id is None
|
|
assert created_job.status == ProcessingStatus.PENDING
|
|
assert created_job.created_at is not None
|
|
assert created_job.started_at is None
|
|
assert created_job.completed_at is None
|
|
assert created_job.error_message is None
|
|
assert created_job.id is not None
|
|
assert isinstance(created_job.id, ObjectId)
|
|
|
|
def test_i_cannot_create_duplicate_job_for_document(self, in_memory_repository, sample_document_id,
|
|
sample_task_id):
|
|
"""Test that creating job with duplicate document_id raises DuplicateKeyError."""
|
|
# Arrange
|
|
in_memory_repository.create_job(sample_document_id, sample_task_id)
|
|
|
|
# Act & Assert
|
|
with pytest.raises(JobRepositoryError) as exc_info:
|
|
in_memory_repository.create_job(sample_document_id, "different-task-id")
|
|
|
|
assert "create_job" in str(exc_info.value)
|
|
|
|
def test_i_cannot_create_job_with_pymongo_error(self, in_memory_repository, sample_document_id, mocker):
|
|
"""Test handling of PyMongo errors during job creation."""
|
|
# Arrange
|
|
mocker.patch.object(in_memory_repository.collection, 'insert_one', side_effect=PyMongoError("Database error"))
|
|
|
|
# Act & Assert
|
|
with pytest.raises(JobRepositoryError) as exc_info:
|
|
in_memory_repository.create_job(sample_document_id)
|
|
|
|
assert "create_job" in str(exc_info.value)
|
|
|
|
|
|
class TestJobRepositoryFinding:
|
|
"""Tests for job finding functionality."""
|
|
|
|
def test_i_can_find_job_by_valid_id(self, in_memory_repository, sample_document_id, sample_task_id):
|
|
"""Test finding job by valid ObjectId."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id, sample_task_id)
|
|
|
|
# Act
|
|
found_job = in_memory_repository.find_job_by_id(created_job.id)
|
|
|
|
# Assert
|
|
assert found_job is not None
|
|
assert found_job.id == created_job.id
|
|
assert found_job.document_id == created_job.document_id
|
|
assert found_job.task_id == created_job.task_id
|
|
assert found_job.status == created_job.status
|
|
|
|
def test_i_cannot_find_job_by_nonexistent_id(self, in_memory_repository):
|
|
"""Test that nonexistent ObjectId returns None."""
|
|
# Arrange
|
|
nonexistent_id = PyObjectId()
|
|
|
|
# Act
|
|
found_job = in_memory_repository.find_job_by_id(nonexistent_id)
|
|
|
|
# Assert
|
|
assert found_job is None
|
|
|
|
def test_i_cannot_find_job_with_pymongo_error(self, in_memory_repository, mocker):
|
|
"""Test handling of PyMongo errors during job finding."""
|
|
# Arrange
|
|
mocker.patch.object(in_memory_repository.collection, 'find_one', side_effect=PyMongoError("Database error"))
|
|
|
|
# Act & Assert
|
|
with pytest.raises(JobRepositoryError) as exc_info:
|
|
in_memory_repository.find_job_by_id(PyObjectId())
|
|
|
|
assert "get_job_by_id" in str(exc_info.value)
|
|
|
|
def test_i_can_find_jobs_by_document_id(self, in_memory_repository, sample_document_id, sample_task_id):
|
|
"""Test finding jobs by document ID."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id, sample_task_id)
|
|
|
|
# Act
|
|
found_jobs = in_memory_repository.find_jobs_by_document_id(sample_document_id)
|
|
|
|
# Assert
|
|
assert len(found_jobs) == 1
|
|
assert found_jobs[0].id == created_job.id
|
|
assert found_jobs[0].document_id == sample_document_id
|
|
|
|
def test_i_can_find_empty_jobs_list_for_nonexistent_document(self, in_memory_repository):
|
|
"""Test that nonexistent document ID returns empty list."""
|
|
# Arrange
|
|
nonexistent_id = ObjectId()
|
|
|
|
# Act
|
|
found_jobs = in_memory_repository.find_jobs_by_document_id(nonexistent_id)
|
|
|
|
# Assert
|
|
assert found_jobs == []
|
|
|
|
def test_i_cannot_find_jobs_by_document_with_pymongo_error(self, in_memory_repository, mocker):
|
|
"""Test handling of PyMongo errors during finding jobs by document ID."""
|
|
# Arrange
|
|
mocker.patch.object(in_memory_repository.collection, 'find', side_effect=PyMongoError("Database error"))
|
|
|
|
# Act & Assert
|
|
with pytest.raises(JobRepositoryError) as exc_info:
|
|
in_memory_repository.find_jobs_by_document_id(PyObjectId())
|
|
|
|
assert "get_jobs_by_file_id" in str(exc_info.value)
|
|
|
|
@pytest.mark.parametrize("status", [
|
|
ProcessingStatus.PENDING,
|
|
ProcessingStatus.PROCESSING,
|
|
ProcessingStatus.COMPLETED
|
|
])
|
|
def test_i_can_find_jobs_by_pending_status(self, in_memory_repository, sample_document_id, status):
|
|
"""Test finding jobs by PENDING status."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
in_memory_repository.update_job_status(created_job.id, status)
|
|
|
|
# Act
|
|
found_jobs = in_memory_repository.get_jobs_by_status(status)
|
|
|
|
# Assert
|
|
assert len(found_jobs) == 1
|
|
assert found_jobs[0].id == created_job.id
|
|
assert found_jobs[0].status == status
|
|
|
|
def test_i_can_find_jobs_by_failed_status(self, in_memory_repository, sample_document_id):
|
|
"""Test finding jobs by FAILED status."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
in_memory_repository.update_job_status(created_job.id, ProcessingStatus.FAILED, "Test error")
|
|
|
|
# Act
|
|
found_jobs = in_memory_repository.get_jobs_by_status(ProcessingStatus.FAILED)
|
|
|
|
# Assert
|
|
assert len(found_jobs) == 1
|
|
assert found_jobs[0].id == created_job.id
|
|
assert found_jobs[0].status == ProcessingStatus.FAILED
|
|
assert found_jobs[0].error_message == "Test error"
|
|
|
|
def test_i_can_find_empty_jobs_list_for_unused_status(self, in_memory_repository):
|
|
"""Test that unused status returns empty list."""
|
|
# Act
|
|
found_jobs = in_memory_repository.get_jobs_by_status(ProcessingStatus.COMPLETED)
|
|
|
|
# Assert
|
|
assert found_jobs == []
|
|
|
|
def test_i_cannot_find_jobs_by_status_with_pymongo_error(self, in_memory_repository, mocker):
|
|
"""Test handling of PyMongo errors during finding jobs by status."""
|
|
# Arrange
|
|
mocker.patch.object(in_memory_repository.collection, 'find', side_effect=PyMongoError("Database error"))
|
|
|
|
# Act & Assert
|
|
with pytest.raises(JobRepositoryError) as exc_info:
|
|
in_memory_repository.get_jobs_by_status(ProcessingStatus.PENDING)
|
|
|
|
assert "get_jobs_by_status" in str(exc_info.value)
|
|
|
|
|
|
class TestJobRepositoryStatusUpdate:
|
|
"""Tests for job status update functionality."""
|
|
|
|
def test_i_can_update_job_status_to_processing(self, in_memory_repository, sample_document_id):
|
|
"""Test updating job status to PROCESSING with started_at timestamp."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
|
|
# Act
|
|
updated_job = in_memory_repository.update_job_status(created_job.id, ProcessingStatus.PROCESSING)
|
|
|
|
# Assert
|
|
assert updated_job is not None
|
|
assert updated_job.id == created_job.id
|
|
assert updated_job.status == ProcessingStatus.PROCESSING
|
|
assert updated_job.started_at is not None
|
|
assert updated_job.completed_at is None
|
|
assert updated_job.error_message is None
|
|
|
|
def test_i_can_update_job_status_to_completed(self, in_memory_repository, sample_document_id):
|
|
"""Test updating job status to COMPLETED with completed_at timestamp."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
in_memory_repository.update_job_status(created_job.id, ProcessingStatus.PROCESSING)
|
|
|
|
# Act
|
|
updated_job = in_memory_repository.update_job_status(created_job.id, ProcessingStatus.COMPLETED)
|
|
|
|
# Assert
|
|
assert updated_job is not None
|
|
assert updated_job.id == created_job.id
|
|
assert updated_job.status == ProcessingStatus.COMPLETED
|
|
assert updated_job.started_at is not None
|
|
assert updated_job.completed_at is not None
|
|
assert updated_job.error_message is None
|
|
|
|
def test_i_can_update_job_status_to_failed_with_error(self, in_memory_repository, sample_document_id):
|
|
"""Test updating job status to FAILED with error message and completed_at timestamp."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
error_message = "Processing failed due to invalid format"
|
|
|
|
# Act
|
|
updated_job = in_memory_repository.update_job_status(
|
|
created_job.id, ProcessingStatus.FAILED, error_message
|
|
)
|
|
|
|
# Assert
|
|
assert updated_job is not None
|
|
assert updated_job.id == created_job.id
|
|
assert updated_job.status == ProcessingStatus.FAILED
|
|
assert updated_job.completed_at is not None
|
|
assert updated_job.error_message == error_message
|
|
|
|
def test_i_can_update_job_status_to_failed_without_error(self, in_memory_repository, sample_document_id):
|
|
"""Test updating job status to FAILED without error message."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
|
|
# Act
|
|
updated_job = in_memory_repository.update_job_status(created_job.id, ProcessingStatus.FAILED)
|
|
|
|
# Assert
|
|
assert updated_job is not None
|
|
assert updated_job.id == created_job.id
|
|
assert updated_job.status == ProcessingStatus.FAILED
|
|
assert updated_job.completed_at is not None
|
|
assert updated_job.error_message is None
|
|
|
|
def test_i_cannot_update_nonexistent_job_status(self, in_memory_repository):
|
|
"""Test that updating nonexistent job returns None."""
|
|
# Arrange
|
|
nonexistent_id = ObjectId()
|
|
|
|
# Act
|
|
result = in_memory_repository.update_job_status(nonexistent_id, ProcessingStatus.COMPLETED)
|
|
|
|
# Assert
|
|
assert result is None
|
|
|
|
def test_i_cannot_update_job_status_with_pymongo_error(self, in_memory_repository, sample_document_id, mocker):
|
|
"""Test handling of PyMongo errors during job status update."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
mocker.patch.object(in_memory_repository.collection, 'find_one_and_update',
|
|
side_effect=PyMongoError("Database error"))
|
|
|
|
# Act & Assert
|
|
with pytest.raises(JobRepositoryError) as exc_info:
|
|
in_memory_repository.update_job_status(created_job.id, ProcessingStatus.COMPLETED)
|
|
|
|
assert "update_job_status" in str(exc_info.value)
|
|
|
|
|
|
class TestJobRepositoryDeletion:
|
|
"""Tests for job deletion functionality."""
|
|
|
|
def test_i_can_delete_existing_job(self, in_memory_repository, sample_document_id):
|
|
"""Test successful job deletion."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
|
|
# Act
|
|
deletion_result = in_memory_repository.delete_job(created_job.id)
|
|
|
|
# Assert
|
|
assert deletion_result is True
|
|
|
|
# Verify job is actually deleted
|
|
found_job = in_memory_repository.find_job_by_id(created_job.id)
|
|
assert found_job is None
|
|
|
|
def test_i_cannot_delete_nonexistent_job(self, in_memory_repository):
|
|
"""Test that deleting nonexistent job returns False."""
|
|
# Arrange
|
|
nonexistent_id = ObjectId()
|
|
|
|
# Act
|
|
result = in_memory_repository.delete_job(nonexistent_id)
|
|
|
|
# Assert
|
|
assert result is False
|
|
|
|
def test_i_cannot_delete_job_with_pymongo_error(self, in_memory_repository, sample_document_id, mocker):
|
|
"""Test handling of PyMongo errors during job deletion."""
|
|
# Arrange
|
|
created_job = in_memory_repository.create_job(sample_document_id)
|
|
mocker.patch.object(in_memory_repository.collection, 'delete_one', side_effect=PyMongoError("Database error"))
|
|
|
|
# Act & Assert
|
|
with pytest.raises(JobRepositoryError) as exc_info:
|
|
in_memory_repository.delete_job(created_job.id)
|
|
|
|
assert "delete_job" in str(exc_info.value)
|
|
|
|
|
|
class TestJobRepositoryComplexScenarios:
|
|
"""Tests for complex job repository scenarios."""
|
|
|
|
def test_i_can_handle_complete_job_lifecycle(self, in_memory_repository, sample_document_id, sample_task_id):
|
|
"""Test complete job lifecycle from creation to completion."""
|
|
# Create job
|
|
job = in_memory_repository.create_job(sample_document_id, sample_task_id)
|
|
assert job.status == ProcessingStatus.PENDING
|
|
assert job.started_at is None
|
|
assert job.completed_at is None
|
|
|
|
# Start processing
|
|
job = in_memory_repository.update_job_status(job.id, ProcessingStatus.PROCESSING)
|
|
assert job.status == ProcessingStatus.PROCESSING
|
|
assert job.started_at is not None
|
|
assert job.completed_at is None
|
|
|
|
# Complete job
|
|
job = in_memory_repository.update_job_status(job.id, ProcessingStatus.COMPLETED)
|
|
assert job.status == ProcessingStatus.COMPLETED
|
|
assert job.started_at is not None
|
|
assert job.completed_at is not None
|
|
assert job.error_message is None
|
|
|
|
def test_i_can_handle_job_failure_scenario(self, in_memory_repository, sample_document_id, sample_task_id):
|
|
"""Test job failure scenario with error message."""
|
|
# Create and start job
|
|
job = in_memory_repository.create_job(sample_document_id, sample_task_id)
|
|
job = in_memory_repository.update_job_status(job.id, ProcessingStatus.PROCESSING)
|
|
|
|
# Fail job with error
|
|
error_msg = "File format not supported"
|
|
job = in_memory_repository.update_job_status(job.id, ProcessingStatus.FAILED, error_msg)
|
|
|
|
# Assert failure state
|
|
assert job.status == ProcessingStatus.FAILED
|
|
assert job.started_at is not None
|
|
assert job.completed_at is not None
|
|
assert job.error_message == error_msg
|
|
|
|
def test_i_can_handle_multiple_documents_with_different_statuses(self, in_memory_repository):
|
|
"""Test managing multiple jobs for different documents with various statuses."""
|
|
# Create jobs for different documents
|
|
doc1 = PyObjectId()
|
|
doc2 = PyObjectId()
|
|
doc3 = PyObjectId()
|
|
|
|
job1 = in_memory_repository.create_job(doc1, "task-1")
|
|
job2 = in_memory_repository.create_job(doc2, "task-2")
|
|
job3 = in_memory_repository.create_job(doc3, "task-3")
|
|
|
|
# Update to different statuses
|
|
in_memory_repository.update_job_status(job1.id, ProcessingStatus.PROCESSING)
|
|
in_memory_repository.update_job_status(job2.id, ProcessingStatus.COMPLETED)
|
|
in_memory_repository.update_job_status(job3.id, ProcessingStatus.FAILED, "Error occurred")
|
|
|
|
# Verify status queries
|
|
pending_jobs = in_memory_repository.get_jobs_by_status(ProcessingStatus.PENDING)
|
|
processing_jobs = in_memory_repository.get_jobs_by_status(ProcessingStatus.PROCESSING)
|
|
completed_jobs = in_memory_repository.get_jobs_by_status(ProcessingStatus.COMPLETED)
|
|
failed_jobs = in_memory_repository.get_jobs_by_status(ProcessingStatus.FAILED)
|
|
|
|
assert len(pending_jobs) == 0
|
|
assert len(processing_jobs) == 1
|
|
assert len(completed_jobs) == 1
|
|
assert len(failed_jobs) == 1
|
|
|
|
assert processing_jobs[0].id == job1.id
|
|
assert completed_jobs[0].id == job2.id
|
|
assert failed_jobs[0].id == job3.id
|