karaoke-gen 0.90.1__py3-none-any.whl → 0.99.3__py3-none-any.whl

backend/tests/test_job_manager.py

@@ -0,0 +1,356 @@
+"""
+Unit tests for Job Manager service.
+
+Tests the job lifecycle management without requiring actual Firestore connection.
+Uses mocking to isolate the business logic.
+"""
+import pytest
+from unittest.mock import Mock, MagicMock, patch
+from datetime import datetime, UTC
+
+# Mock Firestore before importing JobManager
+import sys
+sys.modules['google.cloud.firestore'] = MagicMock()
+
+from backend.services.job_manager import JobManager
+from backend.models.job import Job, JobCreate, JobStatus
+
+
+@pytest.fixture
+def mock_firestore_service():
+    """Mock FirestoreService."""
+    with patch('backend.services.job_manager.FirestoreService') as mock:
+        service = Mock()
+        mock.return_value = service
+        yield service
+
+
+@pytest.fixture
+def job_manager(mock_firestore_service):
+    """Create JobManager with mocked dependencies."""
+    return JobManager()
+
+
+class TestJobCreation:
+    """Test job creation logic."""
+
+    def test_create_job_requires_theme_id(self, job_manager, mock_firestore_service):
+        """Test that jobs without theme_id are rejected."""
+        job_create = JobCreate(
+            artist="Test Artist",
+            title="Test Song"
+            # No theme_id - should fail
+        )
+
+        with pytest.raises(ValueError, match="theme_id is required"):
+            job_manager.create_job(job_create)
+
+        # Verify Firestore was NOT called
+        mock_firestore_service.create_job.assert_not_called()
+
+    def test_create_job_with_url(self, job_manager, mock_firestore_service):
+        """Test creating a job with YouTube URL."""
+        job_create = JobCreate(
+            url="https://youtube.com/watch?v=test",
+            artist="Test Artist",
+            title="Test Song",
+            theme_id="nomad"  # Required for all jobs
+        )
+        
+        # The actual create_job method creates the job and returns it
+        job = job_manager.create_job(job_create)
+        
+        assert job.job_id is not None
+        assert job.status == JobStatus.PENDING
+        assert job.url == "https://youtube.com/watch?v=test"
+        assert job.artist == "Test Artist"
+        assert job.title == "Test Song"
+        assert job.progress == 0
+        
+        # Verify Firestore was called
+        mock_firestore_service.create_job.assert_called_once()
+    
+    def test_create_job_without_url(self, job_manager, mock_firestore_service):
+        """Test creating a job without URL (for file upload)."""
+        job_create = JobCreate(
+            artist="Test Artist",
+            title="Test Song",
+            theme_id="nomad"  # Required for all jobs
+        )
+        
+        job = job_manager.create_job(job_create)
+        
+        assert job.artist == "Test Artist"
+        assert job.title == "Test Song"
+        assert job.url is None
+    
+    def test_create_job_generates_unique_id(self, job_manager, mock_firestore_service):
+        """Test that each job gets a unique ID."""
+        job_create = JobCreate(theme_id="nomad")  # Required for all jobs
+
+        # Create multiple jobs
+        ids = []
+        for i in range(5):
+            mock_firestore_service.create_job.return_value = Job(
+                job_id=f"test{i}",
+                status=JobStatus.PENDING,
+                created_at=datetime.now(UTC),
+                updated_at=datetime.now(UTC)
+            )
+            job = job_manager.create_job(job_create)
+            ids.append(job.job_id)
+        
+        # All IDs should be unique
+        assert len(ids) == len(set(ids))
+    
+    def test_create_job_sets_initial_status(self, job_manager, mock_firestore_service):
+        """Test that new jobs start with PENDING status."""
+        job_create = JobCreate(theme_id="nomad")  # Required for all jobs
+
+        mock_firestore_service.create_job.return_value = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC)
+        )
+        
+        job = job_manager.create_job(job_create)
+        
+        assert job.status == JobStatus.PENDING
+        assert job.progress == 0
+    
+    def test_create_job_with_distribution_settings(self, job_manager, mock_firestore_service):
+        """Test that distribution settings are passed from JobCreate to Job.
+
+        This was a bug where brand_prefix, dropbox_path, gdrive_folder_id, and
+        discord_webhook_url were NOT being passed to the Job constructor.
+        """
+        job_create = JobCreate(
+            artist="Test Artist",
+            title="Test Song",
+            theme_id="nomad",  # Required for all jobs
+            brand_prefix="NOMAD",
+            discord_webhook_url="https://discord.com/webhook/test",
+            dropbox_path="/Karaoke/Tracks-Organized",
+            gdrive_folder_id="1abc123xyz",
+            enable_youtube_upload=True,
+        )
+        
+        job = job_manager.create_job(job_create)
+        
+        # Verify distribution settings are passed through
+        assert job.brand_prefix == "NOMAD"
+        assert job.discord_webhook_url == "https://discord.com/webhook/test"
+        assert job.dropbox_path == "/Karaoke/Tracks-Organized"
+        assert job.gdrive_folder_id == "1abc123xyz"
+        assert job.enable_youtube_upload is True
+        
+        # Verify Firestore was called with job containing these fields
+        mock_firestore_service.create_job.assert_called_once()
+        created_job = mock_firestore_service.create_job.call_args[0][0]
+        assert created_job.brand_prefix == "NOMAD"
+        assert created_job.dropbox_path == "/Karaoke/Tracks-Organized"
+
+
+class TestJobRetrieval:
+    """Test job retrieval logic."""
+    
+    def test_get_existing_job(self, job_manager, mock_firestore_service):
+        """Test retrieving an existing job."""
+        expected_job = Job(
+            job_id="test123",
+            status=JobStatus.SEPARATING_STAGE1,
+            progress=25,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC)
+        )
+        
+        mock_firestore_service.get_job.return_value = expected_job
+        
+        job = job_manager.get_job("test123")
+        
+        assert job.job_id == "test123"
+        assert job.status == JobStatus.SEPARATING_STAGE1
+        assert job.progress == 25
+        
+        mock_firestore_service.get_job.assert_called_once_with("test123")
+    
+    def test_get_nonexistent_job(self, job_manager, mock_firestore_service):
+        """Test retrieving a nonexistent job returns None."""
+        mock_firestore_service.get_job.return_value = None
+        
+        job = job_manager.get_job("nonexistent")
+        
+        assert job is None
+
+
+class TestJobUpdate:
+    """Test job update logic."""
+    
+    def test_update_job_status(self, job_manager, mock_firestore_service):
+        """Test updating job status."""
+        # Setup: job exists
+        existing_job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            progress=0,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC)
+        )
+        mock_firestore_service.get_job.return_value = existing_job
+        
+        # Update status
+        updates = {"status": JobStatus.SEPARATING_STAGE1, "progress": 25}
+        job_manager.update_job("test123", updates)
+        
+        # Verify update was called
+        mock_firestore_service.update_job.assert_called_once()
+        call_args = mock_firestore_service.update_job.call_args
+        assert call_args[0][0] == "test123"  # job_id
+        assert "status" in call_args[0][1]  # updates dict
+    
+    def test_update_job_multiple_fields(self, job_manager, mock_firestore_service):
+        """Test updating multiple fields at once."""
+        existing_job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            progress=0,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            timeline=[]
+        )
+        mock_firestore_service.get_job.return_value = existing_job
+        
+        updates = {"status": JobStatus.SEPARATING_STAGE1, "progress": 25}
+        job_manager.update_job("test123", updates)
+        
+        # Verify update was called
+        call_args = mock_firestore_service.update_job.call_args
+        updates_dict = call_args[0][1]
+        assert "status" in updates_dict
+        assert "progress" in updates_dict
+    
+    def test_update_input_media_gcs_path(self, job_manager, mock_firestore_service):
+        """Test updating input_media_gcs_path field."""
+        existing_job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            progress=0,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC)
+        )
+        mock_firestore_service.get_job.return_value = existing_job
+        
+        updates = {"input_media_gcs_path": "uploads/test123/file.flac"}
+        job_manager.update_job("test123", updates)
+        
+        # Verify update was called with input_media_gcs_path
+        call_args = mock_firestore_service.update_job.call_args
+        updates_dict = call_args[0][1]
+        assert "input_media_gcs_path" in updates_dict
+        assert updates_dict["input_media_gcs_path"] == "uploads/test123/file.flac"
+
+
+class TestJobStatusTransitions:
+    """Test valid job status transitions."""
+    
+    def test_pending_to_downloading(self, job_manager, mock_firestore_service):
+        """Test transition from PENDING to DOWNLOADING."""
+        existing_job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            progress=0,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC)
+        )
+        mock_firestore_service.get_job.return_value = existing_job
+        
+        job_manager.update_job("test123", {"status": JobStatus.DOWNLOADING})
+        
+        # Should succeed (valid transition)
+        mock_firestore_service.update_job.assert_called_once()
+    
+    def test_downloading_to_separating(self, job_manager, mock_firestore_service):
+        """Test transition from DOWNLOADING to SEPARATING_STAGE1."""
+        existing_job = Job(
+            job_id="test123",
+            status=JobStatus.DOWNLOADING,
+            progress=0,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC)
+        )
+        mock_firestore_service.get_job.return_value = existing_job
+        
+        job_manager.update_job("test123", {"status": JobStatus.SEPARATING_STAGE1})
+        
+        mock_firestore_service.update_job.assert_called_once()
+
+
+class TestJobFailure:
+    """Test job failure handling."""
+    
+    def test_mark_job_as_failed(self, job_manager, mock_firestore_service):
+        """Test marking a job as failed."""
+        error_message = "Audio separation failed"
+        job_manager.mark_job_failed("test123", error_message)
+        
+        # mark_job_failed calls firestore.update_job_status
+        mock_firestore_service.update_job_status.assert_called_once()
+        call_args = mock_firestore_service.update_job_status.call_args
+        assert call_args[1]['job_id'] == "test123"
+        assert call_args[1]['status'] == JobStatus.FAILED
+        assert 'error_message' in call_args[1]
+    
+    def test_mark_job_error(self, job_manager, mock_firestore_service):
+        """Test marking a job with an error."""
+        error_message = "Test error"
+        job_manager.mark_job_error("test123", error_message)
+        
+        # mark_job_error calls firestore.update_job_status
+        mock_firestore_service.update_job_status.assert_called_once()
+        call_args = mock_firestore_service.update_job_status.call_args
+        assert call_args[1]['job_id'] == "test123"
+        assert call_args[1]['error_message'] == error_message
+
+
+class TestJobDeletion:
+    """Test job deletion logic."""
+    
+    def test_delete_job(self, job_manager, mock_firestore_service):
+        """Test deleting a job."""
+        existing_job = Job(
+            job_id="test123",
+            status=JobStatus.COMPLETE,
+            progress=100,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            output_files={}  # Empty dict so iteration works
+        )
+        mock_firestore_service.get_job.return_value = existing_job
+        
+        job_manager.delete_job("test123")
+        
+        # Verify delete was called
+        mock_firestore_service.delete_job.assert_called_once_with("test123")
+    
+    def test_delete_job_with_files(self, job_manager, mock_firestore_service):
+        """Test deleting a job and its files."""
+        existing_job = Job(
+            job_id="test123",
+            status=JobStatus.COMPLETE,
+            progress=100,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            output_files={}  # Empty dict so iteration works
+        )
+        mock_firestore_service.get_job.return_value = existing_job
+        
+        job_manager.delete_job("test123", delete_files=True)
+        
+        # Verify delete was called
+        mock_firestore_service.delete_job.assert_called_once_with("test123")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])
+

backend/tests/test_job_manager_notifications.py

@@ -0,0 +1,329 @@
+"""
+Unit tests for job manager notification methods.
+
+Tests the state transition triggers for email notifications.
+"""
+import pytest
+from unittest.mock import Mock, patch, MagicMock, AsyncMock
+from datetime import datetime
+
+from backend.services.job_manager import JobManager
+from backend.models.job import Job, JobStatus
+
+
+class TestTriggerStateNotifications:
+    """Tests for _trigger_state_notifications method."""
+
+    def test_triggers_completion_email_on_complete(self):
+        """Test that completion email is triggered when job completes."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {"youtube_url": "https://youtube.com/123"}
+        manager.get_job = Mock(return_value=mock_job)
+
+        with patch.object(manager, '_schedule_completion_email') as mock_schedule:
+            manager._trigger_state_notifications("job-123", JobStatus.COMPLETE)
+
+            mock_schedule.assert_called_once_with(mock_job)
+
+    def test_triggers_idle_reminder_on_awaiting_review(self):
+        """Test that idle reminder is triggered when job enters awaiting review."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {}
+        manager.get_job = Mock(return_value=mock_job)
+
+        with patch.object(manager, '_schedule_idle_reminder') as mock_schedule:
+            manager._trigger_state_notifications("job-123", JobStatus.AWAITING_REVIEW)
+
+            mock_schedule.assert_called_once_with(mock_job, JobStatus.AWAITING_REVIEW)
+
+    def test_triggers_idle_reminder_on_awaiting_instrumental(self):
+        """Test that idle reminder is triggered when job enters awaiting instrumental."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {}
+        manager.get_job = Mock(return_value=mock_job)
+
+        with patch.object(manager, '_schedule_idle_reminder') as mock_schedule:
+            manager._trigger_state_notifications(
+                "job-123",
+                JobStatus.AWAITING_INSTRUMENTAL_SELECTION
+            )
+
+            mock_schedule.assert_called_once_with(
+                mock_job,
+                JobStatus.AWAITING_INSTRUMENTAL_SELECTION
+            )
+
+    def test_skips_notification_when_no_job(self):
+        """Test that notification is skipped when job not found."""
+        manager = JobManager()
+        manager.firestore = Mock()
+        manager.get_job = Mock(return_value=None)
+
+        with patch.object(manager, '_schedule_completion_email') as mock_schedule:
+            manager._trigger_state_notifications("job-123", JobStatus.COMPLETE)
+
+            mock_schedule.assert_not_called()
+
+    def test_skips_notification_when_no_user_email(self):
+        """Test that notification is skipped when job has no user email."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = None
+        manager.get_job = Mock(return_value=mock_job)
+
+        with patch.object(manager, '_schedule_completion_email') as mock_schedule:
+            manager._trigger_state_notifications("job-123", JobStatus.COMPLETE)
+
+            mock_schedule.assert_not_called()
+
+    def test_does_not_trigger_on_other_states(self):
+        """Test that no notification is triggered for non-notification states."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {}
+        manager.get_job = Mock(return_value=mock_job)
+
+        with patch.object(manager, '_schedule_completion_email') as mock_complete, \
+             patch.object(manager, '_schedule_idle_reminder') as mock_idle:
+
+            # Test various non-notification states
+            for status in [JobStatus.PENDING, JobStatus.DOWNLOADING, JobStatus.TRANSCRIBING,
+                          JobStatus.RENDERING_VIDEO, JobStatus.FAILED]:
+                manager._trigger_state_notifications("job-123", status)
+
+            mock_complete.assert_not_called()
+            mock_idle.assert_not_called()
+
+    def test_handles_exception_gracefully(self):
+        """Test that exceptions don't propagate from notifications."""
+        manager = JobManager()
+        manager.firestore = Mock()
+        manager.get_job = Mock(side_effect=Exception("Database error"))
+
+        # Should not raise
+        manager._trigger_state_notifications("job-123", JobStatus.COMPLETE)
+
+
+class TestScheduleCompletionEmail:
+    """Tests for _schedule_completion_email method."""
+
+    def test_extracts_urls_from_state_data(self):
+        """Test that YouTube and Dropbox URLs are extracted from state_data."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.artist = "Test Artist"
+        mock_job.title = "Test Song"
+        mock_job.state_data = {
+            "youtube_url": "https://youtube.com/watch?v=123",
+            "dropbox_link": "https://dropbox.com/folder/abc",
+        }
+
+        with patch('backend.services.job_notification_service.get_job_notification_service') as mock_get_service:
+            mock_service = Mock()
+            mock_service.send_job_completion_email = AsyncMock(return_value=True)
+            mock_get_service.return_value = mock_service
+
+            # Run in sync context - this will start a daemon thread
+            manager._schedule_completion_email(mock_job)
+
+            # Give the thread a moment to execute
+            import time
+            time.sleep(0.1)
+
+    def test_handles_none_state_data(self):
+        """Test that None state_data is handled gracefully."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.artist = None
+        mock_job.title = None
+        mock_job.state_data = None  # None state_data
+
+        with patch('backend.services.job_notification_service.get_job_notification_service') as mock_get_service:
+            mock_service = Mock()
+            mock_service.send_job_completion_email = AsyncMock(return_value=True)
+            mock_get_service.return_value = mock_service
+
+            # Should not raise
+            manager._schedule_completion_email(mock_job)
+
+    def test_handles_exception_gracefully(self):
+        """Test that exceptions don't propagate."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {}
+
+        with patch('backend.services.job_notification_service.get_job_notification_service') as mock_get_service:
+            mock_get_service.side_effect = Exception("Service error")
+
+            # Should not raise
+            manager._schedule_completion_email(mock_job)
+
+
+class TestScheduleIdleReminder:
+    """Tests for _schedule_idle_reminder method."""
+
+    def test_updates_state_data_for_lyrics_review(self):
+        """Test that state_data is updated with blocking state info for lyrics."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {"existing_key": "value"}
+
+        with patch('backend.services.worker_service.get_worker_service') as mock_get_service:
+            mock_service = Mock()
+            mock_service.schedule_idle_reminder = AsyncMock(return_value=True)
+            mock_get_service.return_value = mock_service
+
+            manager._schedule_idle_reminder(mock_job, JobStatus.AWAITING_REVIEW)
+
+            # Verify state_data was updated
+            update_call = manager.firestore.update_job.call_args
+            assert update_call is not None
+            updated_data = update_call[0][1]  # Second positional arg
+            state_data = updated_data.get('state_data', {})
+
+            assert state_data.get('blocking_action_type') == 'lyrics'
+            assert state_data.get('reminder_sent') is False
+            assert 'blocking_state_entered_at' in state_data
+            assert state_data.get('existing_key') == 'value'  # Preserved
+
+    def test_updates_state_data_for_instrumental_selection(self):
+        """Test that state_data is updated with blocking state info for instrumental."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {}
+
+        with patch('backend.services.worker_service.get_worker_service') as mock_get_service:
+            mock_service = Mock()
+            mock_service.schedule_idle_reminder = AsyncMock(return_value=True)
+            mock_get_service.return_value = mock_service
+
+            manager._schedule_idle_reminder(
+                mock_job,
+                JobStatus.AWAITING_INSTRUMENTAL_SELECTION
+            )
+
+            # Verify state_data was updated
+            update_call = manager.firestore.update_job.call_args
+            updated_data = update_call[0][1]
+            state_data = updated_data.get('state_data', {})
+
+            assert state_data.get('blocking_action_type') == 'instrumental'
+
+    def test_handles_none_state_data(self):
+        """Test that None state_data is handled gracefully."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = None
+
+        with patch('backend.services.worker_service.get_worker_service') as mock_get_service:
+            mock_service = Mock()
+            mock_service.schedule_idle_reminder = AsyncMock(return_value=True)
+            mock_get_service.return_value = mock_service
+
+            # Should not raise
+            manager._schedule_idle_reminder(mock_job, JobStatus.AWAITING_REVIEW)
+
+            # Verify update was still called
+            manager.firestore.update_job.assert_called_once()
+
+    def test_handles_exception_gracefully(self):
+        """Test that exceptions don't propagate."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {}
+
+        # Make firestore raise an exception
+        manager.firestore.update_job.side_effect = Exception("Database error")
+
+        # Should not raise
+        manager._schedule_idle_reminder(mock_job, JobStatus.AWAITING_REVIEW)
+
+
+class TestTransitionTriggersNotifications:
+    """Integration tests for transition_to_state triggering notifications."""
+
+    def test_transition_to_complete_triggers_notification(self):
+        """Test that transitioning to COMPLETE triggers notification."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        # Use ENCODING as the starting state since ENCODING -> COMPLETE is valid
+        mock_job.status = JobStatus.ENCODING
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {}
+        manager.get_job = Mock(return_value=mock_job)
+
+        with patch.object(manager, '_trigger_state_notifications') as mock_trigger:
+            manager.transition_to_state("job-123", JobStatus.COMPLETE)
+
+            mock_trigger.assert_called_once_with("job-123", JobStatus.COMPLETE)
+
+    def test_transition_to_awaiting_review_triggers_notification(self):
+        """Test that transitioning to AWAITING_REVIEW triggers notification."""
+        manager = JobManager()
+        manager.firestore = Mock()
+
+        mock_job = Mock(spec=Job)
+        mock_job.job_id = "job-123"
+        # Use APPLYING_PADDING as the starting state since APPLYING_PADDING -> AWAITING_REVIEW is valid
+        mock_job.status = JobStatus.APPLYING_PADDING
+        mock_job.user_email = "user@example.com"
+        mock_job.state_data = {}
+        manager.get_job = Mock(return_value=mock_job)
+
+        with patch.object(manager, '_trigger_state_notifications') as mock_trigger:
+            manager.transition_to_state("job-123", JobStatus.AWAITING_REVIEW)
+
+            mock_trigger.assert_called_once_with("job-123", JobStatus.AWAITING_REVIEW)