karaoke-gen 0.103.1__py3-none-any.whl → 0.107.0__py3-none-any.whl

backend/tests/test_job_notification_service.py

@@ -3,7 +3,6 @@ Unit tests for job notification service.
 """
 import pytest
 from unittest.mock import Mock, patch, AsyncMock
-import urllib.parse
 
 from backend.services.job_notification_service import (
     JobNotificationService,
@@ -20,82 +19,55 @@ class TestURLBuilding:
         """Test basic review URL building."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
         url = service._build_review_url("job-123")
 
-        assert "gen.nomadkaraoke.com/lyrics/" in url
-        assert "baseApiUrl=" in url
-        # The API URL should be URL-encoded
-        assert urllib.parse.quote("https://api.nomadkaraoke.com/api/review/job-123", safe='') in url
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/job-123/review"
 
-    def test_build_review_url_with_audio_hash(self):
-        """Test review URL with audio hash parameter."""
+    def test_build_review_url_ignores_legacy_params(self):
+        """Test review URL ignores legacy audio_hash and review_token params."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
-        url = service._build_review_url("job-123", audio_hash="abc123")
+        # Legacy params are still accepted but not used in the URL
+        url = service._build_review_url("job-123", audio_hash="abc123", review_token="token456")
 
-        assert "audioHash=abc123" in url
+        # URL should be the simple consolidated route
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/job-123/review"
+        # No query params
+        assert "?" not in url
 
-    def test_build_review_url_with_review_token(self):
-        """Test review URL with review token parameter."""
+    def test_build_review_url_preserves_job_id_characters(self):
+        """Test that job ID is used directly in URL path."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
-        url = service._build_review_url("job-123", review_token="token456")
+        # Note: job IDs with slashes would be unusual in real usage
+        url = service._build_review_url("abc-def-123")
 
-        assert "reviewToken=token456" in url
-
-    def test_build_review_url_with_all_params(self):
-        """Test review URL with all parameters."""
-        service = JobNotificationService()
-        service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
-
-        url = service._build_review_url(
-            "job-123",
-            audio_hash="hash789",
-            review_token="token456"
-        )
-
-        assert "baseApiUrl=" in url
-        assert "audioHash=hash789" in url
-        assert "reviewToken=token456" in url
-
-    def test_build_review_url_encodes_special_chars(self):
-        """Test that special characters in job ID are encoded."""
-        service = JobNotificationService()
-        service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
-
-        url = service._build_review_url("job/with/slashes")
-
-        # The baseApiUrl parameter should have encoded slashes
-        assert "%2F" in url
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/abc-def-123/review"
 
     def test_build_instrumental_url_basic(self):
         """Test basic instrumental URL building."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
         url = service._build_instrumental_url("job-123")
 
-        assert "gen.nomadkaraoke.com/instrumental/" in url
-        assert "baseApiUrl=" in url
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/job-123/instrumental"
 
-    def test_build_instrumental_url_with_token(self):
-        """Test instrumental URL with token parameter."""
+    def test_build_instrumental_url_ignores_legacy_params(self):
+        """Test instrumental URL ignores legacy instrumental_token param."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
+        # Legacy param is still accepted but not used in the URL
         url = service._build_instrumental_url("job-123", instrumental_token="inst-token")
 
-        assert "instrumentalToken=inst-token" in url
+        # URL should be the simple consolidated route
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/job-123/instrumental"
+        # No query params
+        assert "?" not in url
 
 
 class TestCompletionEmail:
@@ -325,7 +297,6 @@ class TestActionReminderEmail:
         """Test that lyrics reminder includes correct review URL."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
         service.email_service = Mock()
         service.email_service.send_action_reminder.return_value = True
         service.template_service = Mock()
@@ -336,22 +307,18 @@ class TestActionReminderEmail:
                 job_id="job-123",
                 user_email="user@example.com",
                 action_type="lyrics",
-                audio_hash="hash123",
-                review_token="token456",
             )
 
         # Verify the review URL was passed to template
         call_kwargs = service.template_service.render_action_needed_lyrics.call_args.kwargs
         review_url = call_kwargs.get('review_url')
-        assert "audioHash=hash123" in review_url
-        assert "reviewToken=token456" in review_url
+        assert review_url == "https://gen.nomadkaraoke.com/app/jobs/job-123/review"
 
     @pytest.mark.asyncio
     async def test_send_instrumental_reminder_includes_url(self):
         """Test that instrumental reminder includes correct URL."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
         service.email_service = Mock()
         service.email_service.send_action_reminder.return_value = True
         service.template_service = Mock()
@@ -362,13 +329,12 @@ class TestActionReminderEmail:
                 job_id="job-123",
                 user_email="user@example.com",
                 action_type="instrumental",
-                instrumental_token="inst-token",
             )
 
         # Verify the instrumental URL was passed to template
         call_kwargs = service.template_service.render_action_needed_instrumental.call_args.kwargs
         instrumental_url = call_kwargs.get('instrumental_url')
-        assert "instrumentalToken=inst-token" in instrumental_url
+        assert instrumental_url == "https://gen.nomadkaraoke.com/app/jobs/job-123/instrumental"
 
 
 class TestGetCompletionMessage:

backend/tests/test_push_notification_service.py

@@ -0,0 +1,460 @@
+"""
+Tests for PushNotificationService.
+
+Tests the Web Push notification sending and subscription management.
+"""
+import pytest
+from unittest.mock import Mock, patch, AsyncMock, MagicMock
+from datetime import datetime, timezone
+
+from backend.services.push_notification_service import (
+    PushNotificationService,
+    get_push_notification_service,
+    SubscriptionGoneError,
+)
+
+
+@pytest.fixture
+def mock_settings():
+    """Mock settings with push notifications enabled."""
+    settings = Mock()
+    settings.enable_push_notifications = True
+    settings.max_push_subscriptions_per_user = 5
+    settings.vapid_subject = "mailto:test@example.com"
+    settings.get_secret = Mock(side_effect=lambda x: {
+        "vapid-public-key": "test-public-key",
+        "vapid-private-key": "test-private-key"
+    }.get(x))
+    return settings
+
+
+@pytest.fixture
+def mock_db():
+    """Mock Firestore client."""
+    return Mock()
+
+
+@pytest.fixture
+def push_service(mock_settings, mock_db):
+    """Create PushNotificationService with mocked dependencies."""
+    with patch('backend.services.push_notification_service.get_settings', return_value=mock_settings):
+        service = PushNotificationService(db=mock_db)
+        return service
+
+
+class TestPushNotificationServiceInit:
+    """Tests for service initialization and configuration."""
+
+    def test_is_enabled_when_configured(self, push_service):
+        """Service reports enabled when all config present."""
+        assert push_service.is_enabled() is True
+
+    def test_is_disabled_when_feature_flag_off(self, mock_db):
+        """Service reports disabled when feature flag off."""
+        settings = Mock()
+        settings.enable_push_notifications = False
+        settings.get_secret = Mock(return_value="key")
+
+        with patch('backend.services.push_notification_service.get_settings', return_value=settings):
+            service = PushNotificationService(db=mock_db)
+            assert service.is_enabled() is False
+
+    def test_is_disabled_when_vapid_keys_missing(self, mock_db):
+        """Service reports disabled when VAPID keys missing."""
+        settings = Mock()
+        settings.enable_push_notifications = True
+        settings.get_secret = Mock(return_value=None)
+
+        with patch('backend.services.push_notification_service.get_settings', return_value=settings):
+            service = PushNotificationService(db=mock_db)
+            assert service.is_enabled() is False
+
+    def test_get_public_key(self, push_service):
+        """Service returns public key when enabled."""
+        assert push_service.get_public_key() == "test-public-key"
+
+    def test_get_public_key_returns_none_when_disabled(self, mock_db):
+        """Service returns None for public key when disabled."""
+        settings = Mock()
+        settings.enable_push_notifications = False
+        settings.get_secret = Mock(return_value="key")
+
+        with patch('backend.services.push_notification_service.get_settings', return_value=settings):
+            service = PushNotificationService(db=mock_db)
+            assert service.get_public_key() is None
+
+
+class TestSendPush:
+    """Tests for sending push notifications."""
+
+    @pytest.mark.asyncio
+    async def test_send_push_skips_when_disabled(self, mock_db):
+        """send_push returns 0 when push notifications disabled."""
+        settings = Mock()
+        settings.enable_push_notifications = False
+        settings.get_secret = Mock(return_value=None)
+
+        with patch('backend.services.push_notification_service.get_settings', return_value=settings):
+            service = PushNotificationService(db=mock_db)
+            result = await service.send_push("test@example.com", "Title", "Body")
+            assert result == 0
+
+    @pytest.mark.asyncio
+    async def test_send_push_no_user(self, push_service):
+        """send_push returns 0 when user not found."""
+        # Mock user not existing
+        push_service.db.collection.return_value.document.return_value.get.return_value.exists = False
+
+        result = await push_service.send_push("unknown@example.com", "Title", "Body")
+        assert result == 0
+
+    @pytest.mark.asyncio
+    async def test_send_push_no_subscriptions(self, push_service):
+        """send_push returns 0 when user has no subscriptions."""
+        # Mock user with no subscriptions
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"push_subscriptions": []}
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        result = await push_service.send_push("test@example.com", "Title", "Body")
+        assert result == 0
+
+    @pytest.mark.asyncio
+    async def test_send_push_success(self, push_service):
+        """send_push successfully sends to subscription."""
+        # Mock user with subscription
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "push_subscriptions": [{
+                "endpoint": "https://push.example.com/endpoint",
+                "keys": {"p256dh": "key1", "auth": "key2"},
+                "device_name": "Test Device"
+            }]
+        }
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.push_notification_service.webpush') as mock_webpush:
+            result = await push_service.send_push("test@example.com", "Title", "Body")
+
+            assert result == 1
+            mock_webpush.assert_called_once()
+            call_args = mock_webpush.call_args
+            assert call_args[1]["subscription_info"]["endpoint"] == "https://push.example.com/endpoint"
+
+    @pytest.mark.asyncio
+    async def test_send_push_removes_gone_subscription(self, push_service):
+        """send_push removes subscription when 410 Gone returned."""
+        from pywebpush import WebPushException
+
+        # Mock user with subscription
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "push_subscriptions": [{
+                "endpoint": "https://push.example.com/endpoint",
+                "keys": {"p256dh": "key1", "auth": "key2"},
+                "device_name": "Test Device"
+            }]
+        }
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        # Mock webpush to raise 410 error
+        mock_response = Mock()
+        mock_response.status_code = 410
+        error = WebPushException("Gone", response=mock_response)
+
+        with patch('backend.services.push_notification_service.webpush', side_effect=error):
+            result = await push_service.send_push("test@example.com", "Title", "Body")
+
+            assert result == 0
+            # Verify invalid subscription was cleaned up
+            push_service.db.collection.return_value.document.return_value.update.assert_called()
+
+
+class TestSubscriptionManagement:
+    """Tests for adding, removing, and listing subscriptions."""
+
+    @pytest.mark.asyncio
+    async def test_add_subscription_new_user(self, push_service):
+        """add_subscription returns False for non-existent user."""
+        push_service.db.collection.return_value.document.return_value.get.return_value.exists = False
+
+        result = await push_service.add_subscription(
+            "unknown@example.com",
+            "https://push.example.com/endpoint",
+            {"p256dh": "key1", "auth": "key2"},
+            "Test Device"
+        )
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_add_subscription_success(self, push_service):
+        """add_subscription adds new subscription."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"push_subscriptions": []}
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        result = await push_service.add_subscription(
+            "test@example.com",
+            "https://push.example.com/endpoint",
+            {"p256dh": "key1", "auth": "key2"},
+            "Test Device"
+        )
+
+        assert result is True
+        push_service.db.collection.return_value.document.return_value.update.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_add_subscription_updates_existing(self, push_service):
+        """add_subscription updates existing subscription with same endpoint."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "push_subscriptions": [{
+                "endpoint": "https://push.example.com/endpoint",
+                "keys": {"p256dh": "old-key", "auth": "old-auth"},
+                "device_name": "Old Device"
+            }]
+        }
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        result = await push_service.add_subscription(
+            "test@example.com",
+            "https://push.example.com/endpoint",
+            {"p256dh": "new-key", "auth": "new-auth"},
+            "New Device"
+        )
+
+        assert result is True
+        # Verify update was called (subscription replaced, not added)
+        update_call = push_service.db.collection.return_value.document.return_value.update.call_args
+        subs = update_call[0][0]["push_subscriptions"]
+        assert len(subs) == 1
+        assert subs[0]["device_name"] == "New Device"
+
+    @pytest.mark.asyncio
+    async def test_add_subscription_enforces_max_limit(self, push_service):
+        """add_subscription removes oldest when max exceeded."""
+        # Create 5 existing subscriptions
+        existing_subs = [
+            {
+                "endpoint": f"https://push.example.com/endpoint{i}",
+                "keys": {"p256dh": "key", "auth": "auth"},
+                "device_name": f"Device {i}",
+                "created_at": f"2024-01-0{i+1}T00:00:00Z"
+            }
+            for i in range(5)
+        ]
+
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"push_subscriptions": existing_subs}
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        result = await push_service.add_subscription(
+            "test@example.com",
+            "https://push.example.com/new-endpoint",
+            {"p256dh": "new-key", "auth": "new-auth"},
+            "New Device"
+        )
+
+        assert result is True
+        # Verify oldest was removed (max 5 subscriptions)
+        update_call = push_service.db.collection.return_value.document.return_value.update.call_args
+        subs = update_call[0][0]["push_subscriptions"]
+        assert len(subs) == 5
+
+    @pytest.mark.asyncio
+    async def test_remove_subscription_success(self, push_service):
+        """remove_subscription removes existing subscription."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "push_subscriptions": [{
+                "endpoint": "https://push.example.com/endpoint",
+                "keys": {"p256dh": "key", "auth": "auth"},
+                "device_name": "Test Device"
+            }]
+        }
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        result = await push_service.remove_subscription(
+            "test@example.com",
+            "https://push.example.com/endpoint"
+        )
+
+        assert result is True
+        update_call = push_service.db.collection.return_value.document.return_value.update.call_args
+        subs = update_call[0][0]["push_subscriptions"]
+        assert len(subs) == 0
+
+    @pytest.mark.asyncio
+    async def test_remove_subscription_not_found(self, push_service):
+        """remove_subscription returns False when subscription not found."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"push_subscriptions": []}
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        result = await push_service.remove_subscription(
+            "test@example.com",
+            "https://push.example.com/unknown-endpoint"
+        )
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_list_subscriptions_success(self, push_service):
+        """list_subscriptions returns user's subscriptions."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "push_subscriptions": [
+                {
+                    "endpoint": "https://push.example.com/endpoint1",
+                    "keys": {"p256dh": "key", "auth": "auth"},
+                    "device_name": "Device 1",
+                    "created_at": "2024-01-01T00:00:00Z",
+                    "last_used_at": None
+                },
+                {
+                    "endpoint": "https://push.example.com/endpoint2",
+                    "keys": {"p256dh": "key", "auth": "auth"},
+                    "device_name": "Device 2",
+                    "created_at": "2024-01-02T00:00:00Z",
+                    "last_used_at": "2024-01-03T00:00:00Z"
+                }
+            ]
+        }
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        result = await push_service.list_subscriptions("test@example.com")
+
+        assert len(result) == 2
+        assert result[0]["device_name"] == "Device 1"
+        assert result[1]["device_name"] == "Device 2"
+        # Verify keys are NOT included in response (security)
+        assert "keys" not in result[0]
+
+
+class TestNotificationFormatting:
+    """Tests for blocking and completion notification formatting."""
+
+    @pytest.mark.asyncio
+    async def test_send_blocking_notification_lyrics(self, push_service):
+        """send_blocking_notification formats lyrics review notification."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "push_subscriptions": [{
+                "endpoint": "https://push.example.com/endpoint",
+                "keys": {"p256dh": "key", "auth": "auth"}
+            }]
+        }
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        job = {
+            "job_id": "test-job-123",
+            "user_email": "test@example.com",
+            "artist": "Test Artist",
+            "title": "Test Song"
+        }
+
+        with patch('backend.services.push_notification_service.webpush') as mock_webpush:
+            await push_service.send_blocking_notification(job, "lyrics")
+
+            call_args = mock_webpush.call_args
+            import json
+            payload = json.loads(call_args[1]["data"])
+            assert payload["title"] == "Review Lyrics"
+            assert "Test Song" in payload["body"]
+            assert "Test Artist" in payload["body"]
+            assert "/review/test-job-123" in payload["url"]
+
+    @pytest.mark.asyncio
+    async def test_send_blocking_notification_instrumental(self, push_service):
+        """send_blocking_notification formats instrumental selection notification."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "push_subscriptions": [{
+                "endpoint": "https://push.example.com/endpoint",
+                "keys": {"p256dh": "key", "auth": "auth"}
+            }]
+        }
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        job = {
+            "job_id": "test-job-123",
+            "user_email": "test@example.com",
+            "artist": "Test Artist",
+            "title": "Test Song"
+        }
+
+        with patch('backend.services.push_notification_service.webpush') as mock_webpush:
+            await push_service.send_blocking_notification(job, "instrumental")
+
+            call_args = mock_webpush.call_args
+            import json
+            payload = json.loads(call_args[1]["data"])
+            assert payload["title"] == "Select Instrumental"
+            assert "/instrumental/test-job-123" in payload["url"]
+
+    @pytest.mark.asyncio
+    async def test_send_completion_notification(self, push_service):
+        """send_completion_notification formats completion notification."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "push_subscriptions": [{
+                "endpoint": "https://push.example.com/endpoint",
+                "keys": {"p256dh": "key", "auth": "auth"}
+            }]
+        }
+        push_service.db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        job = {
+            "job_id": "test-job-123",
+            "user_email": "test@example.com",
+            "artist": "Test Artist",
+            "title": "Test Song"
+        }
+
+        with patch('backend.services.push_notification_service.webpush') as mock_webpush:
+            await push_service.send_completion_notification(job)
+
+            call_args = mock_webpush.call_args
+            import json
+            payload = json.loads(call_args[1]["data"])
+            assert payload["title"] == "Video Ready!"
+            assert "Test Song" in payload["body"]
+            assert "Test Artist" in payload["body"]
+            assert "download" in payload["body"].lower()
+
+
+class TestSingleton:
+    """Tests for singleton pattern."""
+
+    def test_get_push_notification_service_returns_singleton(self):
+        """get_push_notification_service returns same instance."""
+        # Reset singleton for test
+        import backend.services.push_notification_service as module
+        module._push_service = None
+
+        with patch('backend.services.push_notification_service.get_settings') as mock_get_settings:
+            mock_settings = Mock()
+            mock_settings.enable_push_notifications = False
+            mock_settings.get_secret = Mock(return_value=None)
+            mock_get_settings.return_value = mock_settings
+
+            service1 = get_push_notification_service()
+            service2 = get_push_notification_service()
+
+            assert service1 is service2
+
+        # Clean up
+        module._push_service = None