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

backend/tests/test_credential_manager.py

@@ -0,0 +1,377 @@
+"""
+Tests for credential manager and auth endpoints.
+"""
+import pytest
+import json
+from unittest.mock import MagicMock, patch
+from datetime import datetime
+
+from backend.services.credential_manager import (
+    CredentialManager,
+    CredentialStatus,
+    CredentialCheckResult,
+    DeviceAuthInfo,
+    get_credential_manager,
+)
+
+
+class TestCredentialStatus:
+    """Tests for CredentialStatus enum."""
+    
+    def test_status_values(self):
+        """Test all status values exist."""
+        assert CredentialStatus.VALID == "valid"
+        assert CredentialStatus.EXPIRED == "expired"
+        assert CredentialStatus.INVALID == "invalid"
+        assert CredentialStatus.NOT_CONFIGURED == "not_configured"
+        assert CredentialStatus.ERROR == "error"
+
+
+class TestCredentialCheckResult:
+    """Tests for CredentialCheckResult dataclass."""
+    
+    def test_create_result(self):
+        """Test creating a check result."""
+        result = CredentialCheckResult(
+            service="youtube",
+            status=CredentialStatus.VALID,
+            message="Credentials are valid",
+            last_checked=datetime.utcnow()
+        )
+        
+        assert result.service == "youtube"
+        assert result.status == CredentialStatus.VALID
+        assert result.message == "Credentials are valid"
+        assert result.expires_at is None
+    
+    def test_create_result_with_expiry(self):
+        """Test creating a check result with expiry."""
+        expiry = datetime.utcnow()
+        result = CredentialCheckResult(
+            service="gdrive",
+            status=CredentialStatus.VALID,
+            message="Valid",
+            last_checked=datetime.utcnow(),
+            expires_at=expiry
+        )
+        
+        assert result.expires_at == expiry
+
+
+class TestCredentialManager:
+    """Tests for CredentialManager class."""
+    
+    def test_init(self):
+        """Test manager initialization."""
+        manager = CredentialManager()
+        assert manager._pending_device_auths == {}
+    
+    def test_check_youtube_not_configured(self):
+        """Test YouTube check when not configured."""
+        with patch('backend.services.credential_manager.get_settings') as mock_get_settings:
+            mock_settings = MagicMock()
+            mock_settings.get_secret.return_value = None
+            mock_get_settings.return_value = mock_settings
+            
+            manager = CredentialManager()
+            result = manager.check_youtube_credentials()
+            
+            assert result.status == CredentialStatus.NOT_CONFIGURED
+            assert "not configured" in result.message.lower()
+    
+    def test_check_youtube_invalid_json(self):
+        """Test YouTube check with invalid JSON."""
+        with patch('backend.services.credential_manager.get_settings') as mock_get_settings:
+            mock_settings = MagicMock()
+            mock_settings.get_secret.return_value = "not valid json"
+            mock_get_settings.return_value = mock_settings
+            
+            manager = CredentialManager()
+            result = manager.check_youtube_credentials()
+            
+            assert result.status == CredentialStatus.INVALID
+            assert "json" in result.message.lower()
+    
+    def test_check_youtube_missing_fields(self):
+        """Test YouTube check with missing required fields."""
+        # Missing refresh_token and client_secret
+        creds = json.dumps({"token": "test", "client_id": "test"})
+        
+        with patch('backend.services.credential_manager.get_settings') as mock_get_settings:
+            mock_settings = MagicMock()
+            mock_settings.get_secret.return_value = creds
+            mock_get_settings.return_value = mock_settings
+            
+            manager = CredentialManager()
+            result = manager.check_youtube_credentials()
+            
+            assert result.status == CredentialStatus.INVALID
+            assert "missing" in result.message.lower()
+    
+    def test_check_gdrive_not_configured(self):
+        """Test Google Drive check when not configured."""
+        with patch('backend.services.credential_manager.get_settings') as mock_get_settings:
+            mock_settings = MagicMock()
+            mock_settings.get_secret.return_value = None
+            mock_get_settings.return_value = mock_settings
+            
+            manager = CredentialManager()
+            result = manager.check_gdrive_credentials()
+            
+            assert result.status == CredentialStatus.NOT_CONFIGURED
+    
+    def test_check_dropbox_not_configured(self):
+        """Test Dropbox check when not configured."""
+        with patch('backend.services.credential_manager.get_settings') as mock_get_settings:
+            mock_settings = MagicMock()
+            mock_settings.get_secret.return_value = None
+            mock_get_settings.return_value = mock_settings
+            
+            manager = CredentialManager()
+            result = manager.check_dropbox_credentials()
+            
+            assert result.status == CredentialStatus.NOT_CONFIGURED
+    
+    def test_check_dropbox_missing_access_token(self):
+        """Test Dropbox check with missing access token."""
+        creds = json.dumps({"refresh_token": "test"})  # No access_token
+        
+        with patch('backend.services.credential_manager.get_settings') as mock_get_settings:
+            mock_settings = MagicMock()
+            mock_settings.get_secret.return_value = creds
+            mock_get_settings.return_value = mock_settings
+            
+            manager = CredentialManager()
+            result = manager.check_dropbox_credentials()
+            
+            assert result.status == CredentialStatus.INVALID
+            assert "access_token" in result.message.lower()
+    
+    def test_check_all_credentials(self):
+        """Test checking all credentials."""
+        with patch('backend.services.credential_manager.get_settings') as mock_get_settings:
+            mock_settings = MagicMock()
+            mock_settings.get_secret.return_value = None
+            mock_get_settings.return_value = mock_settings
+            
+            manager = CredentialManager()
+            results = manager.check_all_credentials()
+            
+            assert "youtube" in results
+            assert "gdrive" in results
+            assert "dropbox" in results
+            assert all(r.status == CredentialStatus.NOT_CONFIGURED for r in results.values())
+    
+    def test_test_youtube_api_failure(self):
+        """Test YouTube API test failure."""
+        manager = CredentialManager()
+        
+        mock_creds = MagicMock()
+        
+        with patch('googleapiclient.discovery.build', side_effect=Exception("API Error")):
+            result = manager._test_youtube_api(mock_creds)
+            
+            assert result is False
+    
+    def test_test_gdrive_api_failure(self):
+        """Test Google Drive API test failure."""
+        manager = CredentialManager()
+        
+        mock_creds = MagicMock()
+        
+        with patch('googleapiclient.discovery.build', side_effect=Exception("API Error")):
+            result = manager._test_gdrive_api(mock_creds)
+            
+            assert result is False
+    
+    def test_test_dropbox_api_failure(self):
+        """Test Dropbox API test failure."""
+        manager = CredentialManager()
+        
+        with patch('dropbox.Dropbox', side_effect=Exception("API Error")):
+            result = manager._test_dropbox_api({"access_token": "test"})
+            
+            assert result is False
+    
+    def test_send_credential_alert_no_webhook(self):
+        """Test alert without webhook URL."""
+        manager = CredentialManager()
+        
+        result = manager.send_credential_alert([], discord_webhook_url=None)
+        
+        assert result is False
+    
+    def test_send_credential_alert_success(self):
+        """Test successful alert sending."""
+        manager = CredentialManager()
+        
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        
+        invalid_services = [
+            CredentialCheckResult(
+                service="youtube",
+                status=CredentialStatus.INVALID,
+                message="Test message",
+                last_checked=datetime.utcnow()
+            )
+        ]
+        
+        with patch('requests.post', return_value=mock_response) as mock_post:
+            result = manager.send_credential_alert(
+                invalid_services,
+                discord_webhook_url="https://discord.com/webhook/test"
+            )
+            
+            assert result is True
+            mock_post.assert_called_once()
+    
+    def test_start_youtube_device_auth(self):
+        """Test starting YouTube device auth flow."""
+        manager = CredentialManager()
+        
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "device_code": "test_device_code",
+            "user_code": "TEST-CODE",
+            "verification_uri": "https://google.com/device",
+            "expires_in": 1800,
+            "interval": 5
+        }
+        
+        with patch('requests.post', return_value=mock_response):
+            device_info = manager.start_youtube_device_auth(
+                client_id="test_client",
+                client_secret="test_secret"
+            )
+            
+            assert device_info.device_code == "test_device_code"
+            assert device_info.user_code == "TEST-CODE"
+            assert device_info.verification_url == "https://google.com/device"
+            
+            # Should be stored for polling
+            key = f"youtube:{device_info.device_code}"
+            assert key in manager._pending_device_auths
+    
+    def test_poll_device_auth_no_client_creds(self):
+        """Test polling when client credentials are not in Secret Manager."""
+        manager = CredentialManager()
+        
+        # Mock get_youtube_client_credentials to return None (no creds)
+        with patch.object(manager, 'get_youtube_client_credentials', return_value=None):
+            status, data = manager.poll_device_auth("youtube", "some_code")
+        
+        assert status == "error"
+        assert "client credentials not found" in data["message"].lower()
+    
+    def test_poll_device_auth_expired(self):
+        """Test polling with expired device code."""
+        manager = CredentialManager()
+        
+        mock_response = MagicMock()
+        mock_response.status_code = 400
+        mock_response.json.return_value = {"error": "expired_token"}
+        
+        with patch.object(manager, 'get_youtube_client_credentials', 
+                          return_value={"client_id": "test", "client_secret": "test"}):
+            with patch('requests.post', return_value=mock_response):
+                status, data = manager.poll_device_auth("youtube", "expired_code")
+        
+        assert status == "expired"
+        assert "expired" in data["message"].lower()
+    
+    def test_poll_device_auth_pending(self):
+        """Test polling when authorization is pending."""
+        manager = CredentialManager()
+        
+        mock_response = MagicMock()
+        mock_response.status_code = 400
+        mock_response.json.return_value = {"error": "authorization_pending"}
+        
+        with patch.object(manager, 'get_youtube_client_credentials',
+                          return_value={"client_id": "test", "client_secret": "test"}):
+            with patch('requests.post', return_value=mock_response):
+                status, data = manager.poll_device_auth("youtube", "pending_code")
+        
+        assert status == "pending"
+        assert "waiting" in data["message"].lower()
+    
+    def test_poll_device_auth_success(self):
+        """Test polling when authorization completes successfully."""
+        manager = CredentialManager()
+        
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "access_token": "new_access_token",
+            "refresh_token": "new_refresh_token"
+        }
+        
+        with patch.object(manager, 'get_youtube_client_credentials',
+                          return_value={"client_id": "test_id", "client_secret": "test_secret"}):
+            with patch('requests.post', return_value=mock_response):
+                with patch.object(manager, '_save_credentials_to_secret', return_value=True):
+                    status, data = manager.poll_device_auth("youtube", "completed_code")
+        
+        assert status == "complete"
+        assert data["token"] == "new_access_token"
+        assert data["refresh_token"] == "new_refresh_token"
+        assert data["client_id"] == "test_id"
+
+
+class TestGetCredentialManager:
+    """Tests for singleton factory function."""
+    
+    def test_returns_singleton(self):
+        """Test that factory returns same instance."""
+        # Reset singleton
+        import backend.services.credential_manager as module
+        module._credential_manager = None
+        
+        manager1 = get_credential_manager()
+        manager2 = get_credential_manager()
+        
+        assert manager1 is manager2
+
+
+class TestAuthRoutes:
+    """Tests for auth API routes."""
+    
+    def test_routes_import(self):
+        """Test that routes can be imported."""
+        from backend.api.routes.auth import router
+        assert router is not None
+    
+    def test_status_endpoint_exists(self):
+        """Test that status endpoint is defined."""
+        from backend.api.routes.auth import get_credentials_status
+        assert get_credentials_status is not None
+    
+    def test_validate_endpoint_exists(self):
+        """Test that validate endpoint is defined."""
+        from backend.api.routes.auth import validate_credentials
+        assert validate_credentials is not None
+    
+    def test_device_auth_endpoint_exists(self):
+        """Test that device auth endpoints are defined."""
+        from backend.api.routes.auth import (
+            start_youtube_device_auth,
+            poll_youtube_device_auth,
+            start_gdrive_device_auth,
+            poll_gdrive_device_auth,
+        )
+        assert start_youtube_device_auth is not None
+        assert poll_youtube_device_auth is not None
+        assert start_gdrive_device_auth is not None
+        assert poll_gdrive_device_auth is not None
+
+
+class TestFileUploadCredentialValidation:
+    """Tests for credential validation in file upload."""
+    
+    def test_credential_manager_imported(self):
+        """Test that credential manager is imported in file upload."""
+        from backend.api.routes.file_upload import get_credential_manager, CredentialStatus
+        assert get_credential_manager is not None
+        assert CredentialStatus is not None

backend/tests/test_dependencies.py

@@ -0,0 +1,54 @@
+"""
+Tests for API dependencies (authentication, authorization).
+"""
+import pytest
+from unittest.mock import MagicMock, patch
+
+
+class TestAuthDependencies:
+    """Tests for authentication dependencies module structure."""
+    
+    def test_get_token_from_request_function_exists(self):
+        """Test get_token_from_request function exists."""
+        from backend.api.dependencies import get_token_from_request
+        assert get_token_from_request is not None
+    
+    def test_require_auth_function_exists(self):
+        """Test require_auth function exists."""
+        from backend.api.dependencies import require_auth
+        assert require_auth is not None
+    
+    def test_require_admin_function_exists(self):
+        """Test require_admin function exists."""
+        from backend.api.dependencies import require_admin
+        assert require_admin is not None
+    
+    def test_optional_auth_function_exists(self):
+        """Test optional_auth function exists."""
+        from backend.api.dependencies import optional_auth
+        assert optional_auth is not None
+    
+    def test_security_scheme_defined(self):
+        """Test HTTP Bearer security scheme is defined."""
+        from backend.api.dependencies import security
+        assert security is not None
+    
+    def test_logger_configured(self):
+        """Test logger is configured."""
+        from backend.api.dependencies import logger
+        assert logger is not None
+
+
+class TestAuthServiceAccess:
+    """Tests for auth service access."""
+    
+    def test_get_auth_service_function_exists(self):
+        """Test get_auth_service function exists."""
+        from backend.services.auth_service import get_auth_service
+        assert get_auth_service is not None
+    
+    def test_user_type_enum_defined(self):
+        """Test UserType enum is defined."""
+        from backend.services.auth_service import UserType
+        assert UserType is not None
+

backend/tests/test_discord_service.py

@@ -0,0 +1,244 @@
+"""
+Tests for DiscordNotificationService.
+
+Tests cover:
+- Service initialization
+- Webhook URL validation
+- Message posting
+- Video notification posting
+- Dry run mode
+"""
+
+import pytest
+from unittest.mock import MagicMock, patch
+
+from backend.services.discord_service import (
+    DiscordNotificationService,
+    get_discord_notification_service,
+)
+
+
+class TestDiscordNotificationServiceInit:
+    """Test service initialization."""
+
+    def test_init_with_webhook_url(self):
+        """Test initialization with valid webhook URL."""
+        url = "https://discord.com/api/webhooks/123456789/abcdef123456"
+        service = DiscordNotificationService(webhook_url=url)
+        assert service.webhook_url == url
+        assert service.is_enabled() is True
+
+    def test_init_without_webhook_url(self):
+        """Test initialization without webhook URL."""
+        service = DiscordNotificationService()
+        assert service.webhook_url is None
+        assert service.is_enabled() is False
+
+    def test_init_with_dry_run(self):
+        """Test initialization with dry run mode."""
+        service = DiscordNotificationService(dry_run=True)
+        assert service.dry_run is True
+
+    def test_init_with_invalid_webhook_url_raises(self):
+        """Test that invalid webhook URL raises ValueError."""
+        with pytest.raises(ValueError) as exc_info:
+            DiscordNotificationService(webhook_url="https://example.com/webhook")
+        assert "Invalid Discord webhook URL" in str(exc_info.value)
+
+    def test_init_with_non_discord_url_raises(self):
+        """Test that non-Discord URL raises ValueError."""
+        with pytest.raises(ValueError):
+            DiscordNotificationService(
+                webhook_url="https://slack.com/api/webhooks/123"
+            )
+
+
+class TestDiscordNotificationServiceValidation:
+    """Test webhook URL validation."""
+
+    def test_validate_valid_webhook_url(self):
+        """Test that valid webhook URL passes validation."""
+        service = DiscordNotificationService()
+        # Should not raise
+        service._validate_webhook_url(
+            "https://discord.com/api/webhooks/123456789/abcdef"
+        )
+
+    def test_validate_invalid_webhook_url(self):
+        """Test that invalid webhook URL raises ValueError."""
+        service = DiscordNotificationService()
+        with pytest.raises(ValueError) as exc_info:
+            service._validate_webhook_url("https://example.com/webhook")
+        assert "Invalid Discord webhook URL" in str(exc_info.value)
+
+    def test_validate_strips_whitespace(self):
+        """Test that whitespace is stripped from URL."""
+        service = DiscordNotificationService()
+        # Should not raise - whitespace is stripped
+        service._validate_webhook_url(
+            "  https://discord.com/api/webhooks/123456789/abcdef  "
+        )
+
+
+class TestDiscordNotificationServicePostMessage:
+    """Test message posting."""
+
+    @patch("backend.services.discord_service.requests.post")
+    def test_post_message_success(self, mock_post):
+        """Test successful message posting."""
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        url = "https://discord.com/api/webhooks/123456789/abcdef"
+        service = DiscordNotificationService(webhook_url=url)
+
+        result = service.post_message("Test message")
+
+        assert result is True
+        mock_post.assert_called_once_with(
+            url,
+            json={"content": "Test message"},
+            timeout=30
+        )
+
+    @patch("backend.services.discord_service.requests.post")
+    def test_post_message_with_custom_webhook(self, mock_post):
+        """Test message posting with custom webhook URL."""
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        service = DiscordNotificationService()
+        custom_url = "https://discord.com/api/webhooks/987654321/fedcba"
+
+        result = service.post_message("Test message", webhook_url=custom_url)
+
+        assert result is True
+        mock_post.assert_called_once_with(
+            custom_url,
+            json={"content": "Test message"},
+            timeout=30
+        )
+
+    def test_post_message_no_webhook_raises(self):
+        """Test that posting without webhook URL raises ValueError."""
+        service = DiscordNotificationService()
+
+        with pytest.raises(ValueError) as exc_info:
+            service.post_message("Test message")
+        assert "No Discord webhook URL provided" in str(exc_info.value)
+
+    def test_post_message_dry_run(self):
+        """Test message posting in dry run mode."""
+        url = "https://discord.com/api/webhooks/123456789/abcdef"
+        service = DiscordNotificationService(webhook_url=url, dry_run=True)
+
+        result = service.post_message("Test message")
+
+        assert result is True
+        # In dry run mode, no actual request should be made
+
+    @patch("backend.services.discord_service.requests.post")
+    def test_post_message_http_error(self, mock_post):
+        """Test handling of HTTP errors."""
+        import requests as req
+        mock_response = MagicMock()
+        mock_response.raise_for_status.side_effect = req.HTTPError("404 Not Found")
+        mock_post.return_value = mock_response
+
+        url = "https://discord.com/api/webhooks/123456789/abcdef"
+        service = DiscordNotificationService(webhook_url=url)
+
+        with pytest.raises(req.HTTPError):
+            service.post_message("Test message")
+
+
+class TestDiscordNotificationServiceVideoNotification:
+    """Test video notification posting."""
+
+    @patch("backend.services.discord_service.requests.post")
+    def test_post_video_notification_success(self, mock_post):
+        """Test successful video notification."""
+        mock_response = MagicMock()
+        mock_response.raise_for_status = MagicMock()
+        mock_post.return_value = mock_response
+
+        url = "https://discord.com/api/webhooks/123456789/abcdef"
+        service = DiscordNotificationService(webhook_url=url)
+
+        result = service.post_video_notification(
+            "https://www.youtube.com/watch?v=abc123"
+        )
+
+        assert result is True
+        mock_post.assert_called_once()
+        call_args = mock_post.call_args
+        assert "New upload:" in call_args[1]["json"]["content"]
+        assert "abc123" in call_args[1]["json"]["content"]
+
+    def test_post_video_notification_no_youtube_url(self):
+        """Test video notification with empty YouTube URL."""
+        url = "https://discord.com/api/webhooks/123456789/abcdef"
+        service = DiscordNotificationService(webhook_url=url)
+
+        result = service.post_video_notification("")
+
+        assert result is False
+
+    def test_post_video_notification_none_youtube_url(self):
+        """Test video notification with None YouTube URL."""
+        url = "https://discord.com/api/webhooks/123456789/abcdef"
+        service = DiscordNotificationService(webhook_url=url)
+
+        result = service.post_video_notification(None)
+
+        assert result is False
+
+    def test_post_video_notification_dry_run(self):
+        """Test video notification in dry run mode."""
+        url = "https://discord.com/api/webhooks/123456789/abcdef"
+        service = DiscordNotificationService(webhook_url=url, dry_run=True)
+
+        result = service.post_video_notification(
+            "https://www.youtube.com/watch?v=abc123"
+        )
+
+        assert result is True
+
+
+class TestGetDiscordNotificationService:
+    """Test factory function."""
+
+    def test_get_service_creates_instance(self):
+        """Test that factory function creates a new instance."""
+        import backend.services.discord_service as module
+        module._discord_notification_service = None
+
+        url = "https://discord.com/api/webhooks/123456789/abcdef"
+        service = get_discord_notification_service(webhook_url=url)
+
+        assert service is not None
+        assert isinstance(service, DiscordNotificationService)
+        assert service.webhook_url == url
+
+    def test_get_service_without_webhook(self):
+        """Test factory function without webhook URL."""
+        import backend.services.discord_service as module
+        module._discord_notification_service = None
+
+        service = get_discord_notification_service()
+
+        assert service is not None
+        assert service.webhook_url is None
+        assert service.is_enabled() is False
+
+    def test_get_service_with_dry_run(self):
+        """Test factory function with dry run mode."""
+        import backend.services.discord_service as module
+        module._discord_notification_service = None
+
+        url = "https://discord.com/api/webhooks/123456789/abcdef"
+        service = get_discord_notification_service(webhook_url=url, dry_run=True)
+
+        assert service.dry_run is True