519 lines
17 KiB
Python
519 lines
17 KiB
Python
"""
|
|
Unit tests for JobService using in-memory MongoDB.
|
|
|
|
Tests the business logic operations with real MongoDB operations
|
|
using mongomock for better integration testing.
|
|
"""
|
|
|
|
import pytest
|
|
from bson import ObjectId
|
|
from mongomock.mongo_client import MongoClient
|
|
|
|
from app.exceptions.job_exceptions import InvalidStatusTransitionError
|
|
from app.models.job import ProcessingStatus
|
|
from app.models.types import PyObjectId
|
|
from app.services.job_service import JobService
|
|
|
|
|
|
@pytest.fixture
|
|
def in_memory_database():
|
|
"""Create an in-memory database for testing."""
|
|
client = MongoClient()
|
|
return client.test_database
|
|
|
|
|
|
@pytest.fixture
|
|
def job_service(in_memory_database):
|
|
"""Create JobService with in-memory repositories."""
|
|
service = JobService(in_memory_database).initialize()
|
|
return service
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_document_id():
|
|
"""Sample file ObjectId."""
|
|
return PyObjectId()
|
|
|
|
|
|
@pytest.fixture
|
|
def sample_task_id():
|
|
"""Sample Celery task UUID."""
|
|
return "550e8400-e29b-41d4-a716-446655440000"
|
|
|
|
|
|
class TestCreateJob:
|
|
"""Tests for create_job method."""
|
|
|
|
def test_i_can_create_job_with_task_id(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test creating job with task ID."""
|
|
# Execute
|
|
result = job_service.create_job(sample_document_id, sample_task_id)
|
|
|
|
# Verify job creation
|
|
assert result is not None
|
|
assert result.document_id == sample_document_id
|
|
assert result.task_id == sample_task_id
|
|
assert result.status == ProcessingStatus.PENDING
|
|
assert result.created_at is not None
|
|
assert result.started_at is None
|
|
assert result.error_message is None
|
|
|
|
# Verify job exists in database
|
|
job_in_db = job_service.get_job_by_id(result.id)
|
|
assert job_in_db is not None
|
|
assert job_in_db.id == result.id
|
|
assert job_in_db.document_id == sample_document_id
|
|
assert job_in_db.task_id == sample_task_id
|
|
assert job_in_db.status == ProcessingStatus.PENDING
|
|
|
|
def test_i_can_create_job_without_task_id(
|
|
self,
|
|
job_service,
|
|
sample_document_id
|
|
):
|
|
"""Test creating job without task ID."""
|
|
# Execute
|
|
result = job_service.create_job(sample_document_id)
|
|
|
|
# Verify job creation
|
|
assert result is not None
|
|
assert result.document_id == sample_document_id
|
|
assert result.task_id is None
|
|
assert result.status == ProcessingStatus.PENDING
|
|
assert result.created_at is not None
|
|
assert result.started_at is None
|
|
assert result.error_message is None
|
|
|
|
|
|
class TestGetJobMethods:
|
|
"""Tests for job retrieval methods."""
|
|
|
|
def test_i_can_get_job_by_id(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test retrieving job by ID."""
|
|
# Create a job first
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
|
|
# Execute
|
|
result = job_service.get_job_by_id(created_job.id)
|
|
|
|
# Verify
|
|
assert result is not None
|
|
assert result.id == created_job.id
|
|
assert result.document_id == created_job.document_id
|
|
assert result.task_id == created_job.task_id
|
|
assert result.status == created_job.status
|
|
|
|
def test_i_can_get_jobs_by_status(
|
|
self,
|
|
job_service,
|
|
sample_document_id
|
|
):
|
|
"""Test retrieving jobs by status."""
|
|
# Create jobs with different statuses
|
|
pending_job = job_service.create_job(sample_document_id, "pending-task")
|
|
|
|
processing_job = job_service.create_job(ObjectId(), "processing-task")
|
|
job_service.mark_job_as_started(processing_job.id)
|
|
|
|
completed_job = job_service.create_job(ObjectId(), "completed-task")
|
|
job_service.mark_job_as_started(completed_job.id)
|
|
job_service.mark_job_as_completed(completed_job.id)
|
|
|
|
# Execute - get pending jobs
|
|
pending_results = job_service.get_jobs_by_status(ProcessingStatus.PENDING)
|
|
|
|
# Verify
|
|
assert len(pending_results) == 1
|
|
assert pending_results[0].id == pending_job.id
|
|
assert pending_results[0].status == ProcessingStatus.PENDING
|
|
|
|
# Execute - get processing jobs
|
|
processing_results = job_service.get_jobs_by_status(ProcessingStatus.PROCESSING)
|
|
assert len(processing_results) == 1
|
|
assert processing_results[0].status == ProcessingStatus.PROCESSING
|
|
|
|
# Execute - get completed jobs
|
|
completed_results = job_service.get_jobs_by_status(ProcessingStatus.COMPLETED)
|
|
assert len(completed_results) == 1
|
|
assert completed_results[0].status == ProcessingStatus.COMPLETED
|
|
|
|
|
|
class TestUpdateStatus:
|
|
"""Tests for mark_job_as_started method."""
|
|
|
|
def test_i_can_mark_pending_job_as_started(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test marking pending job as started (PENDING → PROCESSING)."""
|
|
# Create a pending job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
assert created_job.status == ProcessingStatus.PENDING
|
|
|
|
# Execute
|
|
result = job_service.mark_job_as_started(created_job.id)
|
|
|
|
# Verify status transition
|
|
assert result is not None
|
|
assert result.id == created_job.id
|
|
assert result.status == ProcessingStatus.PROCESSING
|
|
|
|
# Verify in database
|
|
updated_job = job_service.get_job_by_id(created_job.id)
|
|
assert updated_job.status == ProcessingStatus.PROCESSING
|
|
|
|
def test_i_cannot_mark_processing_job_as_started(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test that processing job cannot be marked as started."""
|
|
# Create and start a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
job_service.mark_job_as_started(created_job.id)
|
|
|
|
# Try to start it again
|
|
with pytest.raises(InvalidStatusTransitionError) as exc_info:
|
|
job_service.mark_job_as_started(created_job.id)
|
|
|
|
# Verify exception details
|
|
assert exc_info.value.current_status == ProcessingStatus.PROCESSING
|
|
assert exc_info.value.target_status == ProcessingStatus.PROCESSING
|
|
|
|
def test_i_cannot_mark_completed_job_as_started(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test that completed job cannot be marked as started."""
|
|
# Create, start, and complete a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
job_service.mark_job_as_started(created_job.id)
|
|
job_service.mark_job_as_completed(created_job.id)
|
|
|
|
# Try to start it again
|
|
with pytest.raises(InvalidStatusTransitionError) as exc_info:
|
|
job_service.mark_job_as_started(created_job.id)
|
|
|
|
# Verify exception details
|
|
assert exc_info.value.current_status == ProcessingStatus.COMPLETED
|
|
assert exc_info.value.target_status == ProcessingStatus.PROCESSING
|
|
|
|
def test_i_cannot_mark_failed_job_as_started(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test that failed job cannot be marked as started."""
|
|
# Create, start, and fail a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
job_service.mark_job_as_started(created_job.id)
|
|
job_service.mark_job_as_failed(created_job.id, "Test error")
|
|
|
|
# Try to start it again
|
|
with pytest.raises(InvalidStatusTransitionError) as exc_info:
|
|
job_service.mark_job_as_started(created_job.id)
|
|
|
|
# Verify exception details
|
|
assert exc_info.value.current_status == ProcessingStatus.FAILED
|
|
assert exc_info.value.target_status == ProcessingStatus.PROCESSING
|
|
|
|
def test_i_can_mark_processing_job_as_completed(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test marking processing job as completed (PROCESSING → COMPLETED)."""
|
|
# Create and start a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
started_job = job_service.mark_job_as_started(created_job.id)
|
|
|
|
# Execute
|
|
result = job_service.mark_job_as_completed(created_job.id)
|
|
|
|
# Verify status transition
|
|
assert result is not None
|
|
assert result.id == created_job.id
|
|
assert result.status == ProcessingStatus.COMPLETED
|
|
|
|
# Verify in database
|
|
updated_job = job_service.get_job_by_id(created_job.id)
|
|
assert updated_job.status == ProcessingStatus.COMPLETED
|
|
|
|
def test_i_cannot_mark_pending_job_as_completed(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test that pending job cannot be marked as completed."""
|
|
# Create a pending job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
|
|
# Try to complete it directly
|
|
with pytest.raises(InvalidStatusTransitionError) as exc_info:
|
|
job_service.mark_job_as_completed(created_job.id)
|
|
|
|
# Verify exception details
|
|
assert exc_info.value.current_status == ProcessingStatus.PENDING
|
|
assert exc_info.value.target_status == ProcessingStatus.COMPLETED
|
|
|
|
def test_i_cannot_mark_completed_job_as_completed(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test that completed job cannot be marked as completed again."""
|
|
# Create, start, and complete a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
job_service.mark_job_as_started(created_job.id)
|
|
job_service.mark_job_as_completed(created_job.id)
|
|
|
|
# Try to complete it again
|
|
with pytest.raises(InvalidStatusTransitionError) as exc_info:
|
|
job_service.mark_job_as_completed(created_job.id)
|
|
|
|
# Verify exception details
|
|
assert exc_info.value.current_status == ProcessingStatus.COMPLETED
|
|
assert exc_info.value.target_status == ProcessingStatus.COMPLETED
|
|
|
|
def test_i_cannot_mark_failed_job_as_completed(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test that failed job cannot be marked as completed."""
|
|
# Create, start, and fail a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
job_service.mark_job_as_started(created_job.id)
|
|
job_service.mark_job_as_failed(created_job.id, "Test error")
|
|
|
|
# Try to complete it
|
|
with pytest.raises(InvalidStatusTransitionError) as exc_info:
|
|
job_service.mark_job_as_completed(created_job.id)
|
|
|
|
# Verify exception details
|
|
assert exc_info.value.current_status == ProcessingStatus.FAILED
|
|
assert exc_info.value.target_status == ProcessingStatus.COMPLETED
|
|
|
|
def test_i_can_mark_processing_job_as_failed_with_error_message(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test marking processing job as failed with error message."""
|
|
# Create and start a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
started_job = job_service.mark_job_as_started(created_job.id)
|
|
|
|
error_message = "Processing failed due to invalid file format"
|
|
|
|
# Execute
|
|
result = job_service.mark_job_as_failed(created_job.id, error_message)
|
|
|
|
# Verify status transition
|
|
assert result is not None
|
|
assert result.id == created_job.id
|
|
assert result.status == ProcessingStatus.FAILED
|
|
assert result.error_message == error_message
|
|
|
|
# Verify in database
|
|
updated_job = job_service.get_job_by_id(created_job.id)
|
|
assert updated_job.status == ProcessingStatus.FAILED
|
|
assert updated_job.error_message == error_message
|
|
|
|
def test_i_can_mark_processing_job_as_failed_without_error_message(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test marking processing job as failed without error message."""
|
|
# Create and start a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
job_service.mark_job_as_started(created_job.id)
|
|
|
|
# Execute without error message
|
|
result = job_service.mark_job_as_failed(created_job.id)
|
|
|
|
# Verify status transition
|
|
assert result is not None
|
|
assert result.status == ProcessingStatus.FAILED
|
|
assert result.error_message is None
|
|
|
|
def test_i_cannot_mark_pending_job_as_failed(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test that pending job cannot be marked as failed."""
|
|
# Create a pending job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
|
|
# Try to fail it directly
|
|
with pytest.raises(InvalidStatusTransitionError) as exc_info:
|
|
job_service.mark_job_as_failed(created_job.id, "Test error")
|
|
|
|
# Verify exception details
|
|
assert exc_info.value.current_status == ProcessingStatus.PENDING
|
|
assert exc_info.value.target_status == ProcessingStatus.FAILED
|
|
|
|
def test_i_cannot_mark_completed_job_as_failed(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test that completed job cannot be marked as failed."""
|
|
# Create, start, and complete a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
job_service.mark_job_as_started(created_job.id)
|
|
job_service.mark_job_as_completed(created_job.id)
|
|
|
|
# Try to fail it
|
|
with pytest.raises(InvalidStatusTransitionError) as exc_info:
|
|
job_service.mark_job_as_failed(created_job.id, "Test error")
|
|
|
|
# Verify exception details
|
|
assert exc_info.value.current_status == ProcessingStatus.COMPLETED
|
|
assert exc_info.value.target_status == ProcessingStatus.FAILED
|
|
|
|
def test_i_cannot_mark_failed_job_as_failed(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test that failed job cannot be marked as failed again."""
|
|
# Create, start, and fail a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
job_service.mark_job_as_started(created_job.id)
|
|
job_service.mark_job_as_failed(created_job.id, "First error")
|
|
|
|
# Try to fail it again
|
|
with pytest.raises(InvalidStatusTransitionError) as exc_info:
|
|
job_service.mark_job_as_failed(created_job.id, "Second error")
|
|
|
|
# Verify exception details
|
|
assert exc_info.value.current_status == ProcessingStatus.FAILED
|
|
assert exc_info.value.target_status == ProcessingStatus.FAILED
|
|
|
|
|
|
class TestDeleteJob:
|
|
"""Tests for delete_job method."""
|
|
|
|
def test_i_can_delete_existing_job(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test deleting an existing job."""
|
|
# Create a job
|
|
created_job = job_service.create_job(sample_document_id, sample_task_id)
|
|
|
|
# Verify job exists
|
|
job_before_delete = job_service.get_job_by_id(created_job.id)
|
|
assert job_before_delete is not None
|
|
|
|
# Execute deletion
|
|
result = job_service.delete_job(created_job.id)
|
|
|
|
# Verify deletion
|
|
assert result is True
|
|
|
|
# Verify job no longer exists
|
|
deleted_job = job_service.get_job_by_id(created_job.id)
|
|
assert deleted_job is None
|
|
|
|
def test_i_cannot_delete_nonexistent_job(
|
|
self,
|
|
job_service
|
|
):
|
|
"""Test deleting a nonexistent job returns False."""
|
|
# Execute deletion with random ObjectId
|
|
result = job_service.delete_job(ObjectId())
|
|
|
|
# Verify
|
|
assert result is False
|
|
|
|
|
|
class TestStatusTransitionValidation:
|
|
"""Tests for status transition validation across different scenarios."""
|
|
|
|
def test_valid_job_lifecycle_flow(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test complete valid job lifecycle: PENDING → PROCESSING → COMPLETED."""
|
|
# Create job (PENDING)
|
|
job = job_service.create_job(sample_document_id, sample_task_id)
|
|
assert job.status == ProcessingStatus.PENDING
|
|
|
|
# Start job (PENDING → PROCESSING)
|
|
started_job = job_service.mark_job_as_started(job.id)
|
|
assert started_job.status == ProcessingStatus.PROCESSING
|
|
|
|
# Complete job (PROCESSING → COMPLETED)
|
|
completed_job = job_service.mark_job_as_completed(job.id)
|
|
assert completed_job.status == ProcessingStatus.COMPLETED
|
|
|
|
def test_valid_job_failure_flow(
|
|
self,
|
|
job_service,
|
|
sample_document_id,
|
|
sample_task_id
|
|
):
|
|
"""Test valid job failure: PENDING → PROCESSING → FAILED."""
|
|
# Create job (PENDING)
|
|
job = job_service.create_job(sample_document_id, sample_task_id)
|
|
assert job.status == ProcessingStatus.PENDING
|
|
|
|
# Start job (PENDING → PROCESSING)
|
|
started_job = job_service.mark_job_as_started(job.id)
|
|
assert started_job.status == ProcessingStatus.PROCESSING
|
|
|
|
# Fail job (PROCESSING → FAILED)
|
|
failed_job = job_service.mark_job_as_failed(job.id, "Test failure")
|
|
assert failed_job.status == ProcessingStatus.FAILED
|
|
assert failed_job.error_message == "Test failure"
|
|
|
|
def test_job_operations_with_empty_database(
|
|
self,
|
|
job_service
|
|
):
|
|
"""Test job operations when database is empty."""
|
|
# Try to get nonexistent job
|
|
result = job_service.get_job_by_id(ObjectId())
|
|
assert result is None
|
|
|
|
# Try to get jobs by status when none exist
|
|
pending_jobs = job_service.get_jobs_by_status(ProcessingStatus.PENDING)
|
|
assert pending_jobs == []
|
|
|
|
# Try to delete nonexistent job
|
|
delete_result = job_service.delete_job(ObjectId())
|
|
assert delete_result is False
|