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

backend/tests/test_models.py

@@ -913,6 +913,145 @@ class TestJobWithFullTwoPhaseConfig:
         assert "title" in job.file_urls["screens"]
 
 
+class TestMadeForYouFields:
+    """Tests for made-for-you order tracking fields."""
+
+    def test_job_has_made_for_you_field(self):
+        """Test Job model has made_for_you field with default False."""
+        job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        )
+        assert hasattr(job, 'made_for_you')
+        assert job.made_for_you is False
+
+    def test_job_made_for_you_true(self):
+        """Test Job model can set made_for_you to True."""
+        job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            made_for_you=True,
+        )
+        assert job.made_for_you is True
+
+    def test_job_has_customer_email_field(self):
+        """Test Job model has customer_email field with default None."""
+        job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        )
+        assert hasattr(job, 'customer_email')
+        assert job.customer_email is None
+
+    def test_job_customer_email_set(self):
+        """Test Job model can set customer_email."""
+        job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            customer_email="customer@example.com",
+        )
+        assert job.customer_email == "customer@example.com"
+
+    def test_job_has_customer_notes_field(self):
+        """Test Job model has customer_notes field with default None."""
+        job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+        )
+        assert hasattr(job, 'customer_notes')
+        assert job.customer_notes is None
+
+    def test_job_customer_notes_set(self):
+        """Test Job model can set customer_notes."""
+        job = Job(
+            job_id="test123",
+            status=JobStatus.PENDING,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            customer_notes="Please make it extra special!",
+        )
+        assert job.customer_notes == "Please make it extra special!"
+
+    def test_job_create_has_made_for_you_fields(self):
+        """Test JobCreate model has all made-for-you fields."""
+        job_create = JobCreate(
+            artist="Test Artist",
+            title="Test Song",
+        )
+        assert hasattr(job_create, 'made_for_you')
+        assert hasattr(job_create, 'customer_email')
+        assert hasattr(job_create, 'customer_notes')
+        assert job_create.made_for_you is False
+        assert job_create.customer_email is None
+        assert job_create.customer_notes is None
+
+    def test_job_create_with_made_for_you_config(self):
+        """Test JobCreate with full made-for-you configuration."""
+        job_create = JobCreate(
+            artist="Seether",
+            title="Tonight",
+            user_email="admin@nomadkaraoke.com",
+            made_for_you=True,
+            customer_email="customer@example.com",
+            customer_notes="Wedding anniversary!",
+        )
+        assert job_create.made_for_you is True
+        assert job_create.customer_email == "customer@example.com"
+        assert job_create.customer_notes == "Wedding anniversary!"
+        assert job_create.user_email == "admin@nomadkaraoke.com"
+
+    def test_made_for_you_serialization_roundtrip(self):
+        """Test made-for-you fields survive dict serialization."""
+        job = Job(
+            job_id="test123",
+            status=JobStatus.AWAITING_AUDIO_SELECTION,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            made_for_you=True,
+            customer_email="customer@example.com",
+            customer_notes="Test notes",
+            user_email="admin@nomadkaraoke.com",
+        )
+
+        job_dict = job.model_dump()
+
+        assert job_dict['made_for_you'] is True
+        assert job_dict['customer_email'] == "customer@example.com"
+        assert job_dict['customer_notes'] == "Test notes"
+
+    def test_made_for_you_job_with_distribution_settings(self):
+        """Test made-for-you job with distribution settings."""
+        job = Job(
+            job_id="test123",
+            status=JobStatus.AWAITING_AUDIO_SELECTION,
+            created_at=datetime.now(UTC),
+            updated_at=datetime.now(UTC),
+            made_for_you=True,
+            customer_email="customer@example.com",
+            user_email="admin@nomadkaraoke.com",
+            enable_youtube_upload=True,
+            dropbox_path="/Production/Ready To Upload",
+            gdrive_folder_id="1ABC123",
+            brand_prefix="NOMAD",
+        )
+
+        assert job.made_for_you is True
+        assert job.enable_youtube_upload is True
+        assert job.dropbox_path == "/Production/Ready To Upload"
+        assert job.gdrive_folder_id == "1ABC123"
+        assert job.brand_prefix == "NOMAD"
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])
 

backend/tests/test_rate_limit_service.py

@@ -0,0 +1,396 @@
+"""
+Unit tests for RateLimitService.
+
+Tests rate limiting logic for jobs, YouTube uploads, and beta enrollments.
+"""
+
+import pytest
+from unittest.mock import Mock, MagicMock, patch
+from datetime import datetime, timezone
+
+# Mock Google Cloud before imports
+import sys
+sys.modules['google.cloud.firestore'] = MagicMock()
+sys.modules['google.cloud.storage'] = MagicMock()
+
+
+class TestRateLimitService:
+    """Test RateLimitService functionality."""
+
+    @pytest.fixture
+    def mock_db(self):
+        """Create a mock Firestore client."""
+        mock = MagicMock()
+        return mock
+
+    @pytest.fixture
+    def mock_settings(self):
+        """Create mock settings."""
+        settings = Mock()
+        settings.enable_rate_limiting = True
+        settings.rate_limit_jobs_per_day = 5
+        settings.rate_limit_youtube_uploads_per_day = 10
+        settings.rate_limit_beta_ip_per_day = 1
+        return settings
+
+    @pytest.fixture
+    def rate_limit_service(self, mock_db, mock_settings):
+        """Create RateLimitService instance with mocks."""
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            from backend.services.rate_limit_service import RateLimitService
+            service = RateLimitService(db=mock_db)
+            return service
+
+    # =========================================================================
+    # User Job Rate Limiting Tests
+    # =========================================================================
+
+    def test_check_user_job_limit_under_limit(self, rate_limit_service, mock_db, mock_settings):
+        """Test that user under limit is allowed."""
+        # Mock: user has 2 jobs today
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"count": 2}
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_user_job_limit("user@example.com")
+
+        assert allowed is True
+        assert remaining == 3  # 5 - 2
+        assert "3 jobs remaining" in message
+
+    def test_check_user_job_limit_at_limit(self, rate_limit_service, mock_db, mock_settings):
+        """Test that user at limit is blocked."""
+        # Mock: user has 5 jobs today (at limit)
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"count": 5}
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_user_job_limit("user@example.com")
+
+        assert allowed is False
+        assert remaining == 0
+        assert "Daily job limit reached" in message
+
+    def test_check_user_job_limit_over_limit(self, rate_limit_service, mock_db, mock_settings):
+        """Test that user over limit is blocked."""
+        # Mock: user somehow has 7 jobs (over limit)
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"count": 7}
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_user_job_limit("user@example.com")
+
+        assert allowed is False
+        assert remaining == 0
+
+    def test_check_user_job_limit_no_jobs_yet(self, rate_limit_service, mock_db, mock_settings):
+        """Test user with no jobs today is allowed."""
+        # Mock: no document exists
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_user_job_limit("newuser@example.com")
+
+        assert allowed is True
+        assert remaining == 5
+
+    def test_check_user_job_limit_with_admin_bypass(self, rate_limit_service, mock_db, mock_settings):
+        """Test that admins bypass job limits."""
+        # Mock: user at limit
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"count": 10}
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_user_job_limit(
+                "admin@example.com", is_admin=True
+            )
+
+        assert allowed is True
+        assert remaining == -1  # Unlimited for admins
+
+    def test_check_user_job_limit_with_override_bypass(self, rate_limit_service, mock_db, mock_settings):
+        """Test that users with bypass override are allowed."""
+        # Mock: user at limit
+        mock_job_doc = Mock()
+        mock_job_doc.exists = True
+        mock_job_doc.to_dict.return_value = {"count": 10}
+
+        # Mock: user has bypass override
+        mock_override_doc = Mock()
+        mock_override_doc.exists = True
+        mock_override_doc.to_dict.return_value = {"bypass_job_limit": True}
+
+        def mock_get(*args, **kwargs):
+            # Return different docs based on collection
+            return mock_override_doc if "overrides" in str(mock_db.collection.call_args) else mock_job_doc
+
+        mock_db.collection.return_value.document.return_value.get.side_effect = [mock_override_doc, mock_job_doc]
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_user_job_limit("vip@example.com")
+
+        assert allowed is True
+
+    def test_check_user_job_limit_with_custom_limit(self, rate_limit_service, mock_db, mock_settings):
+        """Test that custom limit from override is respected."""
+        # Mock: user has 8 jobs
+        mock_job_doc = Mock()
+        mock_job_doc.exists = True
+        mock_job_doc.to_dict.return_value = {"count": 8}
+
+        # Mock: user has custom limit of 20
+        mock_override_doc = Mock()
+        mock_override_doc.exists = True
+        mock_override_doc.to_dict.return_value = {"bypass_job_limit": False, "custom_daily_job_limit": 20}
+
+        mock_db.collection.return_value.document.return_value.get.side_effect = [mock_override_doc, mock_job_doc]
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_user_job_limit("custom@example.com")
+
+        assert allowed is True
+        assert remaining == 12  # 20 - 8
+
+    def test_check_user_job_limit_rate_limiting_disabled(self, rate_limit_service, mock_settings):
+        """Test that rate limiting can be disabled."""
+        mock_settings.enable_rate_limiting = False
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_user_job_limit("user@example.com")
+
+        assert allowed is True
+        assert remaining == -1
+        assert "Rate limiting disabled" in message
+
+    # =========================================================================
+    # YouTube Upload Rate Limiting Tests
+    # =========================================================================
+
+    def test_check_youtube_limit_under_limit(self, rate_limit_service, mock_db, mock_settings):
+        """Test YouTube upload under limit is allowed."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"count": 3}
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_youtube_upload_limit()
+
+        assert allowed is True
+        assert remaining == 7  # 10 - 3
+
+    def test_check_youtube_limit_at_limit(self, rate_limit_service, mock_db, mock_settings):
+        """Test YouTube upload at limit is blocked."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"count": 10}
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_youtube_upload_limit()
+
+        assert allowed is False
+        assert remaining == 0
+        assert "Daily YouTube upload limit reached" in message
+
+    def test_check_youtube_limit_no_uploads_yet(self, rate_limit_service, mock_db, mock_settings):
+        """Test YouTube upload with no uploads today is allowed."""
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_youtube_upload_limit()
+
+        assert allowed is True
+        assert remaining == 10
+
+    def test_check_youtube_limit_zero_configured(self, rate_limit_service, mock_db, mock_settings):
+        """Test that zero limit means unlimited YouTube uploads."""
+        mock_settings.rate_limit_youtube_uploads_per_day = 0
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_youtube_upload_limit()
+
+        assert allowed is True
+        assert remaining == -1
+        assert "No YouTube upload limit" in message
+
+    # =========================================================================
+    # Beta Enrollment IP Rate Limiting Tests
+    # =========================================================================
+
+    def test_check_beta_ip_limit_first_enrollment(self, rate_limit_service, mock_db, mock_settings):
+        """Test first enrollment from IP is allowed."""
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_beta_ip_limit("192.168.1.1")
+
+        assert allowed is True
+        assert remaining == 1
+
+    def test_check_beta_ip_limit_already_enrolled(self, rate_limit_service, mock_db, mock_settings):
+        """Test second enrollment from same IP is blocked."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {"count": 1}
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            allowed, remaining, message = rate_limit_service.check_beta_ip_limit("192.168.1.1")
+
+        assert allowed is False
+        assert remaining == 0
+        assert "Too many beta enrollments" in message
+
+    # =========================================================================
+    # Recording Tests
+    # =========================================================================
+
+    def test_record_job_creation(self, rate_limit_service, mock_db, mock_settings):
+        """Test recording a job creation."""
+        mock_transaction = Mock()
+        mock_db.transaction.return_value = mock_transaction
+
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            with patch('backend.services.rate_limit_service.firestore') as mock_firestore:
+                # Mock the transactional decorator
+                mock_firestore.transactional = lambda f: f
+                rate_limit_service.record_job_creation("user@example.com", "job123")
+
+        # Verify transaction was used
+        mock_db.transaction.assert_called()
+
+    def test_record_youtube_upload(self, rate_limit_service, mock_db, mock_settings):
+        """Test recording a YouTube upload."""
+        mock_transaction = Mock()
+        mock_db.transaction.return_value = mock_transaction
+
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            with patch('backend.services.rate_limit_service.firestore') as mock_firestore:
+                mock_firestore.transactional = lambda f: f
+                rate_limit_service.record_youtube_upload("job123", "user@example.com")
+
+        mock_db.transaction.assert_called()
+
+    def test_record_skipped_when_disabled(self, rate_limit_service, mock_db, mock_settings):
+        """Test that recording is skipped when rate limiting is disabled."""
+        mock_settings.enable_rate_limiting = False
+
+        with patch('backend.services.rate_limit_service.settings', mock_settings):
+            rate_limit_service.record_job_creation("user@example.com", "job123")
+
+        # Should not call Firestore
+        mock_db.collection.assert_not_called()
+
+    # =========================================================================
+    # Override Management Tests
+    # =========================================================================
+
+    def test_get_user_override_exists(self, rate_limit_service, mock_db):
+        """Test getting an existing user override."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_doc.to_dict.return_value = {
+            "email": "vip@example.com",
+            "bypass_job_limit": True,
+            "reason": "VIP user"
+        }
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        override = rate_limit_service.get_user_override("vip@example.com")
+
+        assert override is not None
+        assert override["bypass_job_limit"] is True
+
+    def test_get_user_override_not_exists(self, rate_limit_service, mock_db):
+        """Test getting a non-existent user override."""
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        override = rate_limit_service.get_user_override("regular@example.com")
+
+        assert override is None
+
+    def test_set_user_override(self, rate_limit_service, mock_db):
+        """Test setting a user override."""
+        rate_limit_service.set_user_override(
+            user_email="vip@example.com",
+            bypass_job_limit=True,
+            reason="Special access",
+            admin_email="admin@example.com"
+        )
+
+        mock_db.collection.return_value.document.return_value.set.assert_called_once()
+
+    def test_remove_user_override_exists(self, rate_limit_service, mock_db):
+        """Test removing an existing user override."""
+        mock_doc = Mock()
+        mock_doc.exists = True
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        result = rate_limit_service.remove_user_override("vip@example.com", "admin@example.com")
+
+        assert result is True
+        mock_db.collection.return_value.document.return_value.delete.assert_called_once()
+
+    def test_remove_user_override_not_exists(self, rate_limit_service, mock_db):
+        """Test removing a non-existent user override."""
+        mock_doc = Mock()
+        mock_doc.exists = False
+        mock_db.collection.return_value.document.return_value.get.return_value = mock_doc
+
+        result = rate_limit_service.remove_user_override("regular@example.com", "admin@example.com")
+
+        assert result is False
+
+
+class TestRateLimitExceededError:
+    """Test RateLimitExceededError exception."""
+
+    def test_exception_attributes(self):
+        """Test exception has all expected attributes."""
+        from backend.exceptions import RateLimitExceededError
+
+        exc = RateLimitExceededError(
+            message="Limit exceeded",
+            limit_type="job",
+            remaining_seconds=3600,
+            current_count=5,
+            limit_value=5
+        )
+
+        assert exc.message == "Limit exceeded"
+        assert exc.limit_type == "job"
+        assert exc.remaining_seconds == 3600
+        assert exc.current_count == 5
+        assert exc.limit_value == 5
+
+    def test_exception_str(self):
+        """Test exception string representation."""
+        from backend.exceptions import RateLimitExceededError
+
+        exc = RateLimitExceededError(message="Test message")
+        assert str(exc) == "Test message"