copilot-swe-agent[bot]
204000aabc
Resolve 3 merge conflicts and renumber the automation_hooks migration to follow main's migration chain (036_add_document_translation_fields). Conflicts resolved: - app/api/__init__.py: add automation_router alongside main's new routers - app/utils/settings_service.py: add automation_hooks_enabled alongside compliance_enabled - tests/conftest.py: add AutomationHook alongside AuditLog/ComplianceTemplate imports Migration renumbered: - 027_add_automation_hooks → 037_add_automation_hooks - down_revision: 026_add_scheduled_jobs → 036_add_document_translation_fields Co-authored-by: christianlouis <361235+christianlouis@users.noreply.github.com>
366 lines
14 KiB
Python
366 lines
14 KiB
Python
"""
|
|
Tests for app/celery_app.py
|
|
|
|
This module tests the Celery app configuration and task failure handler.
|
|
"""
|
|
|
|
import logging
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestCeleryAppConfig:
|
|
"""Test Celery app configuration."""
|
|
|
|
def test_celery_instance_exists(self):
|
|
"""Test that celery instance exists and is properly configured."""
|
|
from app.celery_app import celery
|
|
|
|
assert celery is not None
|
|
assert celery.main == "document_processor"
|
|
|
|
def test_celery_broker_configured(self):
|
|
"""Test that celery broker is configured."""
|
|
from app.celery_app import celery
|
|
|
|
assert celery.conf.broker_url is not None
|
|
assert celery.conf.result_backend is not None
|
|
|
|
def test_celery_default_queue(self):
|
|
"""Test that default queue is set to document_processor."""
|
|
from app.celery_app import celery
|
|
|
|
assert celery.conf.task_default_queue == "document_processor"
|
|
|
|
def test_celery_task_routes(self):
|
|
"""Test that task routes are configured."""
|
|
from app.celery_app import celery
|
|
|
|
assert celery.conf.task_routes is not None
|
|
assert "app.tasks.*" in celery.conf.task_routes
|
|
assert celery.conf.task_routes["app.tasks.*"]["queue"] == "document_processor"
|
|
|
|
def test_broker_connection_retry_on_startup(self):
|
|
"""Test that broker connection retry on startup is enabled."""
|
|
from app.celery_app import celery
|
|
|
|
assert celery.conf.broker_connection_retry_on_startup is True
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestTaskFailureHandler:
|
|
"""Test task failure handler signal."""
|
|
|
|
@patch("app.celery_app.settings")
|
|
@patch("app.utils.notification.notify_celery_failure")
|
|
def test_task_failure_handler_sends_notification(self, mock_notify, mock_settings):
|
|
"""Test that task failure handler sends notification when enabled."""
|
|
# Configure settings to enable notifications
|
|
mock_settings.notify_on_task_failure = True
|
|
|
|
# Import the handler
|
|
from app.celery_app import task_failure_handler
|
|
|
|
# Create mock sender with task name
|
|
mock_sender = MagicMock()
|
|
mock_sender.name = "test.task"
|
|
|
|
# Create exception instance
|
|
test_exception = ValueError("Test error")
|
|
|
|
# Call the handler
|
|
task_failure_handler(
|
|
sender=mock_sender,
|
|
task_id="test-task-id",
|
|
exception=test_exception,
|
|
args=[1, 2, 3],
|
|
kwargs={"key": "value"},
|
|
)
|
|
|
|
# Verify notification was sent with correct parameters
|
|
mock_notify.assert_called_once()
|
|
call_kwargs = mock_notify.call_args[1]
|
|
assert call_kwargs["task_name"] == "test.task"
|
|
assert call_kwargs["task_id"] == "test-task-id"
|
|
assert isinstance(call_kwargs["exc"], ValueError)
|
|
assert str(call_kwargs["exc"]) == "Test error"
|
|
assert call_kwargs["args"] == [1, 2, 3]
|
|
assert call_kwargs["kwargs"] == {"key": "value"}
|
|
|
|
@patch("app.celery_app.settings")
|
|
def test_task_failure_handler_disabled_notification(self, mock_settings):
|
|
"""Test that task failure handler does not send notification when disabled."""
|
|
# Configure settings to disable notifications
|
|
mock_settings.notify_on_task_failure = False
|
|
|
|
# Import the handler
|
|
from app.celery_app import task_failure_handler
|
|
|
|
with patch("app.utils.notification.notify_celery_failure") as mock_notify:
|
|
# Create mock sender
|
|
mock_sender = MagicMock()
|
|
mock_sender.name = "test.task"
|
|
|
|
# Call the handler
|
|
task_failure_handler(
|
|
sender=mock_sender,
|
|
task_id="test-task-id",
|
|
exception=ValueError("Test error"),
|
|
)
|
|
|
|
# Verify notification was NOT sent
|
|
mock_notify.assert_not_called()
|
|
|
|
@patch("app.celery_app.settings")
|
|
@patch("app.utils.notification.notify_celery_failure")
|
|
def test_task_failure_handler_with_no_sender(self, mock_notify, mock_settings):
|
|
"""Test task failure handler when sender is None."""
|
|
mock_settings.notify_on_task_failure = True
|
|
|
|
from app.celery_app import task_failure_handler
|
|
|
|
# Call with no sender
|
|
task_failure_handler(
|
|
sender=None,
|
|
task_id="test-task-id",
|
|
exception=ValueError("Test error"),
|
|
)
|
|
|
|
# Should use "Unknown" as task name
|
|
mock_notify.assert_called_once()
|
|
call_args = mock_notify.call_args[1]
|
|
assert call_args["task_name"] == "Unknown"
|
|
|
|
@patch("app.celery_app.settings")
|
|
@patch("app.utils.notification.notify_celery_failure")
|
|
def test_task_failure_handler_with_no_task_id(self, mock_notify, mock_settings):
|
|
"""Test task failure handler when task_id is None."""
|
|
mock_settings.notify_on_task_failure = True
|
|
|
|
from app.celery_app import task_failure_handler
|
|
|
|
mock_sender = MagicMock()
|
|
mock_sender.name = "test.task"
|
|
|
|
# Call with no task_id
|
|
task_failure_handler(
|
|
sender=mock_sender,
|
|
task_id=None,
|
|
exception=ValueError("Test error"),
|
|
)
|
|
|
|
# Should use "N/A" as task_id
|
|
mock_notify.assert_called_once()
|
|
call_args = mock_notify.call_args[1]
|
|
assert call_args["task_id"] == "N/A"
|
|
|
|
@patch("app.celery_app.settings")
|
|
@patch("app.utils.notification.notify_celery_failure")
|
|
def test_task_failure_handler_with_empty_args_kwargs(self, mock_notify, mock_settings):
|
|
"""Test task failure handler with no args or kwargs."""
|
|
mock_settings.notify_on_task_failure = True
|
|
|
|
from app.celery_app import task_failure_handler
|
|
|
|
mock_sender = MagicMock()
|
|
mock_sender.name = "test.task"
|
|
|
|
# Call with None args/kwargs
|
|
task_failure_handler(
|
|
sender=mock_sender,
|
|
task_id="test-task-id",
|
|
exception=ValueError("Test error"),
|
|
args=None,
|
|
kwargs=None,
|
|
)
|
|
|
|
# Should use empty list/dict as defaults
|
|
mock_notify.assert_called_once()
|
|
call_args = mock_notify.call_args[1]
|
|
assert call_args["args"] == []
|
|
assert call_args["kwargs"] == {}
|
|
|
|
@patch("app.celery_app.settings")
|
|
@patch("app.utils.notification.notify_celery_failure", side_effect=Exception("Notification failed"))
|
|
def test_task_failure_handler_exception_handling(self, mock_notify, mock_settings, caplog):
|
|
"""Test that exceptions in notification are caught and logged."""
|
|
mock_settings.notify_on_task_failure = True
|
|
|
|
from app.celery_app import task_failure_handler
|
|
|
|
mock_sender = MagicMock()
|
|
mock_sender.name = "test.task"
|
|
|
|
# Call the handler - should not raise exception
|
|
with caplog.at_level(logging.ERROR):
|
|
task_failure_handler(
|
|
sender=mock_sender,
|
|
task_id="test-task-id",
|
|
exception=ValueError("Test error"),
|
|
)
|
|
|
|
# Verify the exception was logged
|
|
assert any("Failed to send task failure notification" in record.message for record in caplog.records)
|
|
|
|
@patch("app.celery_app.settings")
|
|
@patch("app.utils.notification.notify_celery_failure")
|
|
def test_task_failure_handler_called_by_signal(self, mock_notify, mock_settings):
|
|
"""Test that the handler is properly connected to the task_failure signal."""
|
|
mock_settings.notify_on_task_failure = True
|
|
|
|
# Import to ensure signal is connected
|
|
# Import the signal
|
|
from celery.signals import task_failure
|
|
|
|
from app.celery_app import task_failure_handler
|
|
|
|
# The handler should be connected to the signal
|
|
# We can test this by verifying the signal has receivers
|
|
receivers = task_failure.receivers
|
|
assert len(receivers) > 0
|
|
|
|
# Simply verify that importing the handler doesn't cause errors
|
|
# The actual signal connection is tested implicitly by the other tests
|
|
assert callable(task_failure_handler)
|
|
|
|
|
|
@pytest.mark.unit
|
|
class TestDispatchUserFailureNotification:
|
|
"""Tests for _dispatch_user_failure_notification helper."""
|
|
|
|
@patch("app.celery_app._dispatch_user_failure_notification")
|
|
@patch("app.celery_app.settings")
|
|
@patch("app.utils.notification.notify_celery_failure")
|
|
def test_task_failure_handler_calls_user_failure_dispatch(self, mock_notify_sys, mock_settings, mock_dispatch):
|
|
"""task_failure_handler also calls _dispatch_user_failure_notification."""
|
|
mock_settings.notify_on_task_failure = True
|
|
|
|
from app.celery_app import task_failure_handler
|
|
|
|
mock_sender = MagicMock()
|
|
mock_sender.name = "app.tasks.process_document.process_document"
|
|
exc = ValueError("OCR timeout")
|
|
|
|
task_failure_handler(
|
|
sender=mock_sender,
|
|
task_id="tid",
|
|
exception=exc,
|
|
args=["/tmp/f.pdf"],
|
|
kwargs={"file_id": 42},
|
|
)
|
|
|
|
mock_dispatch.assert_called_once_with(mock_sender, exc, ["/tmp/f.pdf"], {"file_id": 42})
|
|
|
|
def test_dispatch_ignores_non_document_tasks(self):
|
|
"""Non app.tasks.* tasks should be silently ignored."""
|
|
from app.celery_app import _dispatch_user_failure_notification
|
|
|
|
sender = MagicMock()
|
|
sender.name = "celery.backend_cleanup"
|
|
|
|
# Should complete without error or DB access
|
|
_dispatch_user_failure_notification(sender, ValueError("x"), [], {})
|
|
|
|
def test_dispatch_ignores_when_no_file_id(self):
|
|
"""If file_id is not in args or kwargs, nothing happens."""
|
|
from app.celery_app import _dispatch_user_failure_notification
|
|
|
|
sender = MagicMock()
|
|
sender.name = "app.tasks.process_document.process_document"
|
|
|
|
# No file_id anywhere
|
|
_dispatch_user_failure_notification(sender, ValueError("x"), ["/tmp/f.pdf"], {})
|
|
|
|
@patch("app.database.SessionLocal")
|
|
def test_dispatch_extracts_file_id_from_kwargs(self, mock_session):
|
|
"""file_id should be extracted from kwargs when present."""
|
|
from app.celery_app import _dispatch_user_failure_notification
|
|
|
|
mock_db = MagicMock()
|
|
mock_record = MagicMock()
|
|
mock_record.owner_id = "alice@example.com"
|
|
mock_record.original_filename = "invoice.pdf"
|
|
mock_record.local_filename = "/tmp/invoice.pdf"
|
|
mock_db.query.return_value.filter.return_value.first.return_value = mock_record
|
|
mock_session.return_value.__enter__.return_value = mock_db
|
|
|
|
sender = MagicMock()
|
|
sender.name = "app.tasks.finalize_document_storage.finalize_document_storage"
|
|
exc = RuntimeError("Upload failed")
|
|
|
|
with patch("app.utils.user_notification.notify_user_document_failed") as mock_notify:
|
|
_dispatch_user_failure_notification(sender, exc, ["/tmp/f.pdf"], {"file_id": 10})
|
|
|
|
mock_notify.assert_called_once_with(
|
|
owner_id="alice@example.com",
|
|
filename="invoice.pdf",
|
|
error="RuntimeError: Upload failed",
|
|
file_id=10,
|
|
)
|
|
|
|
@patch("app.database.SessionLocal")
|
|
def test_dispatch_extracts_file_id_from_positional_args(self, mock_session):
|
|
"""file_id should be extracted from positional args for known tasks."""
|
|
from app.celery_app import _dispatch_user_failure_notification
|
|
|
|
mock_db = MagicMock()
|
|
mock_record = MagicMock()
|
|
mock_record.owner_id = "bob@test.com"
|
|
mock_record.original_filename = "scan.pdf"
|
|
mock_record.local_filename = "/tmp/scan.pdf"
|
|
mock_db.query.return_value.filter.return_value.first.return_value = mock_record
|
|
mock_session.return_value.__enter__.return_value = mock_db
|
|
|
|
sender = MagicMock()
|
|
sender.name = "app.tasks.process_with_ocr.process_with_ocr"
|
|
exc = ValueError("OCR error")
|
|
|
|
with patch("app.utils.user_notification.notify_user_document_failed") as mock_notify:
|
|
# process_with_ocr: file_id is args[1]
|
|
_dispatch_user_failure_notification(sender, exc, ["filename.pdf", 77], {})
|
|
|
|
mock_notify.assert_called_once_with(
|
|
owner_id="bob@test.com",
|
|
filename="scan.pdf",
|
|
error="ValueError: OCR error",
|
|
file_id=77,
|
|
)
|
|
|
|
@patch("app.database.SessionLocal")
|
|
def test_dispatch_skips_when_no_owner(self, mock_session):
|
|
"""When file record has no owner_id, no notification is sent."""
|
|
from app.celery_app import _dispatch_user_failure_notification
|
|
|
|
mock_db = MagicMock()
|
|
mock_record = MagicMock()
|
|
mock_record.owner_id = None
|
|
mock_db.query.return_value.filter.return_value.first.return_value = mock_record
|
|
mock_session.return_value.__enter__.return_value = mock_db
|
|
|
|
sender = MagicMock()
|
|
sender.name = "app.tasks.process_document.process_document"
|
|
|
|
with patch("app.utils.user_notification.notify_user_document_failed") as mock_notify:
|
|
_dispatch_user_failure_notification(sender, ValueError("x"), [], {"file_id": 5})
|
|
|
|
mock_notify.assert_not_called()
|
|
|
|
@patch("app.database.SessionLocal")
|
|
def test_dispatch_skips_when_record_not_found(self, mock_session):
|
|
"""When file record doesn't exist, no notification is sent."""
|
|
from app.celery_app import _dispatch_user_failure_notification
|
|
|
|
mock_db = MagicMock()
|
|
mock_db.query.return_value.filter.return_value.first.return_value = None
|
|
mock_session.return_value.__enter__.return_value = mock_db
|
|
|
|
sender = MagicMock()
|
|
sender.name = "app.tasks.process_document.process_document"
|
|
|
|
with patch("app.utils.user_notification.notify_user_document_failed") as mock_notify:
|
|
_dispatch_user_failure_notification(sender, ValueError("x"), [], {"file_id": 999})
|
|
|
|
mock_notify.assert_not_called()
|