Merge pull request #5 from Tobkubos/backend-setup

TODO.md

@@ -1,2 +0,0 @@
-Bezpieczeństwo (SSRF - Server-Side Request Forgery): Twój backend pobiera pliki z dowolnego przekazanego adresu URL. Złośliwy użytkownik mógłby podać URL wskazujący na wewnętrzne zasoby Twojej sieci (np. http://localhost:8080/admin). Warto zaimplementować w download_file walidację, która pozwala na pobieranie plików wyłącznie z zaufanych domen (np. tylko z *.discordapp.com i *.media.discordapp.net).
-

backend/.env.example

@@ -14,10 +14,6 @@ PORT=8000
 DOWNLOAD_TIMEOUT=30
 MAX_FILE_SIZE=104857600
 
-# ML Model Configuration
-DEFAULT_DETECTOR_MODEL=mock
-# Supported models: mock, deepseek, openai, etc.
-
 # Redis Configuration (for future queuing)
 REDIS_ENABLED=False
 REDIS_URL=redis://localhost:6379

backend/README.md

@@ -41,25 +41,6 @@ Once the server is running, interactive API documentation is available at:
 - Swagger UI: `http://127.0.0.1:8000/docs`
 - ReDoc: `http://127.0.0.1:8000/redoc`
 
-## 🔌 API Endpoints
-
-### Health Check
-```bash
-GET /
-```
-
-Returns service status and available models.
-
-**Response:**
-```json
-{
-  "status": "ok",
-  "service": "Deepfake Detection Service",
-  "version": "1.0.0",
-  "available_models": ["mock"]
-}
-```
-
 ### Analyze File
 ```bash
 POST /analyze
@@ -81,7 +62,7 @@ Content-Type: application/json
   "is_deepfake": true,
   "confidence": 0.847,
   "analysis_time": 1.234,
-  "model_used": "mock"
+  "used_model": "mock"
 }
 ```
 

backend/app/__init__.py

@@ -1,6 +1,9 @@
 from fastapi import FastAPI
+from slowapi import _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
 from app.api.routes import router as api_router
 from app.core.logging_config import setup_logging
+from app.core.limiter import limiter
 
 setup_logging()
 
@@ -10,4 +13,6 @@ app = FastAPI(
     version="1.0.0",
 )
 
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
 app.include_router(api_router)

backend/app/api/routes.py

@@ -1,5 +1,5 @@
 import logging
-from fastapi import APIRouter, HTTPException, status
+from fastapi import APIRouter, HTTPException, Request, status
 
 from app.models.schemas import (
     AnalysisRequest,
@@ -14,6 +14,7 @@ from app.services.text_analyzer import analyze_text
 from app.services.image_analyzer import analyze_image
 from app.core.config import get_settings
 from app.utils.exceptions import DeepfakeDetectionError
+from app.core.limiter import limiter
 
 logger = logging.getLogger(__name__)
 
@@ -29,8 +30,28 @@ async def health_check() -> HealthResponse:
     settings = get_settings()
     logger.info("Health check endpoint accessed")
     
+    handlers = {
+        "text": analyze_text,
+        "image": analyze_image,
+    }
+    
+    models_status = {}
+    is_healthy = True
+    
+    for content_type in settings.AVAILABLE_MODELS.keys():
+        handler = handlers.get(content_type)
+        
+        if handler is not None and callable(handler):
+            models_status[content_type] = "ready"
+        else:
+            models_status[content_type] = "error_not_callable"
+            is_healthy = False
+            logger.error(f"Krytyczny brak! Handler dla typu '{content_type}' nie jest callable.")
+
+    overall_status = "ok" if is_healthy else "degraded"
+    
     return HealthResponse(
-        status="ok",
+        status=overall_status,
         service="Deepfake Detection Service",
         version=settings.APP_VERSION,
         available_models=settings.AVAILABLE_MODELS,
@@ -44,15 +65,17 @@ async def health_check() -> HealthResponse:
         400: {"model": ErrorResponse, "description": "Bad request"},
         408: {"model": ErrorResponse, "description": "Request timeout"},
         415: {"model": ErrorResponse, "description": "Unsupported media type"},
+        429: {"model": ErrorResponse, "description": "Too many requests"},
         500: {"model": ErrorResponse, "description": "Internal server error"},
     },
     tags=["Analysis"],
     summary="Analyze content for deepfake detection",
 )
-async def analyze(request: AnalysisRequest) -> AnalysisResponse:
-    if isinstance(request, TextAnalysisRequest):
+@limiter.limit("1/5seconds")
+async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisResponse:
+    if isinstance(payload, TextAnalysisRequest):
         content_type = "text"
-    elif isinstance(request, ImageAnalysisRequest):
+    elif isinstance(payload, ImageAnalysisRequest):
         content_type = "image"
     else:
         raise HTTPException(
@@ -70,15 +93,15 @@ async def analyze(request: AnalysisRequest) -> AnalysisResponse:
 
     try:
         if content_type == "text":
-            if len(request.text) > settings.MAX_CONTENT_SIZES["text"]:
+            if len(payload.text) > settings.MAX_CONTENT_SIZES["text"]:
                 raise ValueError(f"Text content exceeds maximum length of {settings.MAX_CONTENT_SIZES['text']} characters")
-            if len(request.text) < 50:
+            if len(payload.text) < 50:
                 raise ValueError("Text content must be at least 50 characters")
             
-            analysis_result = await analyze_text(request.text)
+            analysis_result = await analyze_text(payload.text)
 
         elif content_type == "image":
-            image_bytes = await download_file(str(request.image_url))
+            image_bytes = await download_file(str(payload.image_url))
             if not image_bytes:
                 raise ValueError("Failed to download image")
             if len(image_bytes) > settings.MAX_CONTENT_SIZES["image"]:
@@ -86,7 +109,6 @@ async def analyze(request: AnalysisRequest) -> AnalysisResponse:
             
             analysis_result = await analyze_image(image_bytes)
 
-    # 4. Globalna obsługa błędów
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
     except DeepfakeDetectionError as e:
@@ -101,6 +123,6 @@ async def analyze(request: AnalysisRequest) -> AnalysisResponse:
         is_deepfake=analysis_result["is_deepfake"],
         confidence=analysis_result["confidence"],
         analysis_time=analysis_result["analysis_time"],
-        model_used=model,
+        used_model=model,
         content_type=content_type,
     )

backend/app/core/config.py

@@ -18,11 +18,7 @@ class Settings:
     # File handling
     DOWNLOAD_TIMEOUT: int = int(os.getenv("DOWNLOAD_TIMEOUT", "30"))
     MAX_FILE_SIZE: int = int(os.getenv("MAX_FILE_SIZE", str(100 * 1024 * 1024)))  # 100 MB
-    
-    # ML Model configuration
-    DEFAULT_DETECTOR_MODEL: str = os.getenv("DEFAULT_DETECTOR_MODEL", "mock")
-    # Supported models: "mock", "deepseek", "openai", etc. (easy to add more)
-    
+ 
     # Redis configuration (for future queuing)
     REDIS_ENABLED: bool = os.getenv("REDIS_ENABLED", "False").lower() == "true"
     REDIS_URL: str = os.getenv("REDIS_URL", "redis://localhost:6379")

backend/app/core/limiter.py

@@ -0,0 +1,4 @@
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+limiter = Limiter(key_func=get_remote_address)

backend/app/models/schemas.py

@@ -66,7 +66,7 @@ class AnalysisResponse(BaseModel):
     is_deepfake: bool = Field(..., description="Whether the content is detected as a deepfake")
     confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score between 0.0 and 1.0")
     analysis_time: float = Field(..., description="Time taken for analysis in seconds")
-    model_used: str = Field(..., description="The detector model that was used")
+    used_model: str = Field(..., description="The detector model that was used")
     content_type: str = Field(..., description="Type of content analyzed (text/image/video/file)")
     
     class Config:
@@ -75,7 +75,7 @@ class AnalysisResponse(BaseModel):
                 "is_deepfake": True,
                 "confidence": 0.847,
                 "analysis_time": 1.234,
-                "model_used": "mock",
+                "used_model": "mock",
                 "content_type": "image"
             }
         }

backend/requirements.txt

@@ -9,4 +9,7 @@ torch==2.3.1
 numpy==1.26.4
 sentencepiece
 protobuf
-Pillow
+Pillow
+slowapi
+pytest==7.4.3
+pytest-asyncio==0.21.1

backend/run_tests.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+"""
+Simple test runner script for the Deepfake Detection Service.
+Run this file to execute all tests with proper output formatting.
+"""
+
+import sys
+import subprocess
+from pathlib import Path
+
+
+def run_tests():
+    """Run all tests with pytest."""
+    print("=" * 70)
+    print("🧪 Deepfake Detection Service - Test Suite")
+    print("=" * 70)
+    
+    backend_dir = Path(__file__).parent
+    
+    # Run tests with verbose output
+    cmd = [
+        sys.executable,
+        "-m",
+        "pytest",
+        "tests/",
+        "-v",
+        "--tb=short",
+        "-ra"  # Show summary of all test outcomes
+    ]
+    
+    print(f"\n📝 Running command: {' '.join(cmd)}\n")
+    
+    result = subprocess.run(cmd, cwd=backend_dir)
+    
+    print("\n" + "=" * 70)
+    if result.returncode == 0:
+        print("✅ All tests passed!")
+    else:
+        print("❌ Some tests failed. See output above for details.")
+    print("=" * 70)
+    
+    return result.returncode
+
+
+if __name__ == "__main__":
+    exit_code = run_tests()
+    sys.exit(exit_code)

backend/test_rate_limit.sh

@@ -0,0 +1,161 @@
+#!/bin/bash
+
+# Manual Testing Script for Rate Limiting (slowapi)
+# This script demonstrates how to test the rate limiting manually
+# Make sure the backend is running first: python main.py
+
+API_URL="http://127.0.0.1:8000"
+ENDPOINT="/analyze"
+
+# Sample text for testing
+SAMPLE_TEXT="This is a comprehensive test of the rate limiting functionality to ensure that the API properly restricts requests to one per five second interval."
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}╔═══════════════════════════════════════════════════════════════════════════╗${NC}"
+echo -e "${BLUE}║        Rate Limiting Test - Slowapi (1 request per 5 seconds)             ║${NC}"
+echo -e "${BLUE}╚═══════════════════════════════════════════════════════════════════════════╝${NC}"
+echo ""
+
+# Test 1: First request (should succeed)
+echo -e "${YELLOW}[TEST 1]${NC} First request (should succeed - HTTP 200):"
+echo -e "${YELLOW}Command:${NC} curl -X POST $API_URL$ENDPOINT -H \"Content-Type: application/json\" -d '{...}'"
+echo ""
+
+RESPONSE1=$(curl -s -w "\n%{http_code}" -X POST "$API_URL$ENDPOINT" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"content_type\": \"text\",
+    \"text\": \"$SAMPLE_TEXT\"
+  }")
+
+HTTP_CODE1=$(echo "$RESPONSE1" | tail -n 1)
+BODY1=$(echo "$RESPONSE1" | head -n -1)
+
+if [ "$HTTP_CODE1" == "200" ]; then
+  echo -e "${GREEN}✅ SUCCESS${NC} - HTTP $HTTP_CODE1"
+  echo -e "${GREEN}Response:${NC} (truncated) $(echo $BODY1 | head -c 100)..."
+else
+  echo -e "${RED}❌ FAILED${NC} - HTTP $HTTP_CODE1"
+  echo -e "${RED}Response:${NC} $BODY1"
+fi
+echo ""
+
+# Test 2: Immediate second request (should be rate limited)
+echo -e "${YELLOW}[TEST 2]${NC} Immediate second request (should be rate limited - HTTP 429):"
+echo -e "${YELLOW}Command:${NC} curl -X POST $API_URL$ENDPOINT ... (immediately)"
+echo ""
+
+RESPONSE2=$(curl -s -w "\n%{http_code}" -X POST "$API_URL$ENDPOINT" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"content_type\": \"text\",
+    \"text\": \"$SAMPLE_TEXT\"
+  }")
+
+HTTP_CODE2=$(echo "$RESPONSE2" | tail -n 1)
+BODY2=$(echo "$RESPONSE2" | head -n -1)
+
+if [ "$HTTP_CODE2" == "429" ]; then
+  echo -e "${GREEN}✅ SUCCESS${NC} - HTTP $HTTP_CODE2 (Rate Limited as expected)"
+  echo -e "${GREEN}Response:${NC} (truncated) $(echo $BODY2 | head -c 100)..."
+else
+  echo -e "${RED}❌ FAILED${NC} - Expected HTTP 429, got HTTP $HTTP_CODE2"
+fi
+echo ""
+
+# Test 3: Wait and retry
+echo -e "${YELLOW}[TEST 3]${NC} Wait 5 seconds and retry (should succeed - HTTP 200):"
+echo -e "${YELLOW}Command:${NC} sleep 5 && curl -X POST $API_URL$ENDPOINT ..."
+echo ""
+
+echo -e "${BLUE}⏳ Waiting 5 seconds...${NC}"
+for i in {1..5}; do
+  echo -ne "\r⏳ Waiting $i/5 seconds..."
+  sleep 1
+done
+echo ""
+
+RESPONSE3=$(curl -s -w "\n%{http_code}" -X POST "$API_URL$ENDPOINT" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"content_type\": \"text\",
+    \"text\": \"$SAMPLE_TEXT\"
+  }")
+
+HTTP_CODE3=$(echo "$RESPONSE3" | tail -n 1)
+BODY3=$(echo "$RESPONSE3" | head -n -1)
+
+if [ "$HTTP_CODE3" == "200" ]; then
+  echo -e "${GREEN}✅ SUCCESS${NC} - HTTP $HTTP_CODE3 (Rate limit recovered)"
+  echo -e "${GREEN}Response:${NC} (truncated) $(echo $BODY3 | head -c 100)..."
+else
+  echo -e "${RED}❌ FAILED${NC} - Expected HTTP 200, got HTTP $HTTP_CODE3"
+fi
+echo ""
+
+# Summary
+echo -e "${BLUE}╔═══════════════════════════════════════════════════════════════════════════╗${NC}"
+echo -e "${BLUE}║                          TEST SUMMARY                                     ║${NC}"
+echo -e "${BLUE}╚═══════════════════════════════════════════════════════════════════════════╝${NC}"
+echo ""
+
+PASSED=0
+FAILED=0
+
+if [ "$HTTP_CODE1" == "200" ]; then
+  echo -e "${GREEN}✅${NC} Test 1 (First request): PASSED"
+  PASSED=$((PASSED + 1))
+else
+  echo -e "${RED}❌${NC} Test 1 (First request): FAILED"
+  FAILED=$((FAILED + 1))
+fi
+
+if [ "$HTTP_CODE2" == "429" ]; then
+  echo -e "${GREEN}✅${NC} Test 2 (Rate limited): PASSED"
+  PASSED=$((PASSED + 1))
+else
+  echo -e "${RED}❌${NC} Test 2 (Rate limited): FAILED"
+  FAILED=$((FAILED + 1))
+fi
+
+if [ "$HTTP_CODE3" == "200" ]; then
+  echo -e "${GREEN}✅${NC} Test 3 (Recovery): PASSED"
+  PASSED=$((PASSED + 1))
+else
+  echo -e "${RED}❌${NC} Test 3 (Recovery): FAILED"
+  FAILED=$((FAILED + 1))
+fi
+
+echo ""
+echo -e "Results: ${GREEN}$PASSED passed${NC}, ${RED}$FAILED failed${NC}"
+echo ""
+
+# Additional manual test options
+echo -e "${BLUE}Additional Manual Tests:${NC}"
+echo ""
+echo "1. Test with different IPs (requires proxy or localhost simulation):"
+echo "   This would test that rate limiting is per-IP"
+echo ""
+echo "2. Test different rate limit thresholds:"
+echo "   Modify @limiter.limit(\"1/5seconds\") in routes.py to test different rates"
+echo ""
+echo "3. Test health endpoint (no rate limit):"
+echo "   curl -X GET http://127.0.0.1:8000/"
+echo ""
+
+# Health check (no rate limit)
+echo -e "${YELLOW}[BONUS]${NC} Testing health endpoint (should have no rate limit):"
+HEALTH_RESPONSE=$(curl -s -w "\n%{http_code}" -X GET "$API_URL/")
+HEALTH_CODE=$(echo "$HEALTH_RESPONSE" | tail -n 1)
+
+if [ "$HEALTH_CODE" == "200" ]; then
+  echo -e "${GREEN}✅ Health check: PASSED (HTTP $HEALTH_CODE)${NC}"
+else
+  echo -e "${RED}❌ Health check: FAILED (HTTP $HEALTH_CODE)${NC}"
+fi

backend/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests package for Deepfake Detection Service."""

backend/tests/conftest.py

@@ -0,0 +1,33 @@
+"""
+Pytest configuration for the Deepfake Detection Service tests.
+"""
+
+import sys
+from pathlib import Path
+
+# Add the backend directory to the Python path
+backend_dir = Path(__file__).parent.parent
+sys.path.insert(0, str(backend_dir))
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture
+def test_client():
+    """Provide a test client for API testing."""
+    from app import app
+    return TestClient(app)
+
+
+@pytest.fixture
+def sample_texts():
+    """Provide sample text data for testing."""
+    return {
+        "ai_generated": "This is an AI-generated text that demonstrates the capabilities of modern language models in creating coherent and contextually appropriate content without human intervention.",
+        "human_written": "I went to the store yesterday and bought some groceries. The weather was nice, and I enjoyed the walk.",
+        "technical": "The implementation of neural networks requires careful consideration of hyperparameters, activation functions, and optimization techniques to achieve optimal performance.",
+        "short": "Too short",
+        "long": "A" * 5001,  # Exceeds 5000 char limit
+        "minimum": "A" * 50,  # Exactly 50 chars (minimum valid)
+    }

backend/tests/test_analysis.py

@@ -0,0 +1,348 @@
+"""
+Comprehensive tests for the Deepfake Detection Service.
+Tests cover: text analysis, rate limiting, response validation, and Redis integration.
+"""
+
+import asyncio
+import pytest
+from fastapi.testclient import TestClient
+from unittest.mock import patch, AsyncMock, MagicMock
+
+from app import app
+from app.services.text_analyzer import analyze_text
+from app.services.queue import get_queue_service
+from app.models.schemas import TextAnalysisRequest, AnalysisResponse
+from app.core.limiter import limiter
+
+
+client = TestClient(app)
+
+@pytest.fixture(autouse=True)
+def reset_rate_limits():
+    """
+    Automatyczny fixture, który przed KAŻDYM testem 
+    czyści pamięć limitera zapytań SlowAPI.
+    Dzięki temu testy nie blokują się nawzajem błędem 429.
+    """
+    limiter._storage.reset()
+
+class TestTextAnalysis:
+    """Test text deepfake analysis functionality."""
+    
+    def test_health_check(self):
+        """Test health check endpoint returns correct status."""
+        response = client.get("/")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] in ["ok", "degraded"]
+        assert data["service"] == "Deepfake Detection Service"
+        assert "available_models" in data
+        assert "text" in data["supported_types"]
+        assert "image" in data["supported_types"]
+    
+    def test_text_analysis_valid_input(self):
+        """Test text analysis with valid AI-generated text."""
+        payload = {
+            "content_type": "text",
+            "text": "This is an AI-generated text that demonstrates the capabilities of modern language models in creating coherent and contextually appropriate content without human intervention."
+        }
+        response = client.post("/analyze", json=payload)
+        
+        assert response.status_code == 200
+        data = response.json()
+        
+        # Validate response structure
+        assert "is_deepfake" in data
+        assert isinstance(data["is_deepfake"], bool)
+        assert "confidence" in data
+        assert 0.0 <= data["confidence"] <= 1.0
+        assert "analysis_time" in data
+        assert data["analysis_time"] > 0
+        assert "used_model" in data
+        assert data["content_type"] == "text"
+        assert "yaya36095/xlm-roberta-text-detector" in data["used_model"]
+    
+    def test_text_analysis_human_written(self):
+        """Test text analysis with human-written text."""
+        payload = {
+            "content_type": "text",
+            "text": "I went to the store yesterday and bought some groceries. The weather was nice, and I enjoyed the walk. I also met an old friend who I haven't seen in years. We talked about our lives and made plans to meet again soon."
+        }
+        response = client.post("/analyze", json=payload)
+        
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data["is_deepfake"], bool)
+        assert 0.0 <= data["confidence"] <= 1.0
+    
+    def test_text_analysis_too_short(self):
+        """Test text analysis with text that's too short (< 50 chars)."""
+        payload = {
+            "content_type": "text",
+            "text": "Short text"
+        }
+        response = client.post("/analyze", json=payload)
+        
+        assert response.status_code == 400
+        data = response.json()
+        assert "at least 50 characters" in data["detail"]
+    
+    def test_text_analysis_too_long(self):
+        """Test text analysis with text that exceeds max length."""
+        payload = {
+            "content_type": "text",
+            "text": "A" * 5001  # Exceeds 5000 character limit
+        }
+        response = client.post("/analyze", json=payload)
+        
+        assert response.status_code == 400
+        data = response.json()
+        assert "exceeds maximum length" in data["detail"]
+    
+    def test_text_analysis_exactly_50_chars(self):
+        """Test text analysis with exactly 50 characters (minimum valid)."""
+        text_50_chars = "A" * 50
+        payload = {
+            "content_type": "text",
+            "text": text_50_chars
+        }
+        response = client.post("/analyze", json=payload)
+        
+        # Should either succeed or fail based on model behavior
+        # but not because of length validation
+        assert response.status_code in [200, 500]  # Success or model error, not validation error
+    
+    def test_text_analysis_empty_text(self):
+        """Test text analysis with empty text."""
+        payload = {
+            "content_type": "text",
+            "text": ""
+        }
+        response = client.post("/analyze", json=payload)
+        
+        assert response.status_code == 400
+    
+    def test_text_analysis_missing_field(self):
+        """Test text analysis with missing text field."""
+        payload = {
+            "content_type": "text"
+        }
+        response = client.post("/analyze", json=payload)
+        
+        assert response.status_code == 422  # Validation error
+
+
+class TestRateLimiting:
+    """Test rate limiting (slowapi) functionality."""
+    
+    def test_rate_limit_single_request(self):
+        """Test that a single request is allowed."""
+        payload = {
+            "content_type": "text",
+            "text": "This is a test text with sufficient length to pass validation and be analyzed by the deepfake detector model."
+        }
+        response = client.post("/analyze", json=payload)
+        
+        assert response.status_code in [200, 500]  # Should not be rate limited
+        assert response.status_code != 429
+    
+    def test_rate_limit_multiple_rapid_requests(self):
+        """Test that rapid requests are rate limited (1 per 5 seconds)."""
+        payload = {
+            "content_type": "text",
+            "text": "This is a test text with sufficient length to pass validation and be analyzed by the deepfake detector model."
+        }
+        
+        # First request should succeed
+        response1 = client.post("/analyze", json=payload)
+        assert response1.status_code != 429
+        
+        # Immediate second request should be rate limited
+        response2 = client.post("/analyze", json=payload)
+        assert response2.status_code == 429
+        assert "rate limit" in response2.text.lower()
+    
+    def test_rate_limit_recovery_after_delay(self):
+        """Test that rate limit recovers after 5 seconds."""
+        payload = {
+            "content_type": "text",
+            "text": "This is a test text with sufficient length to pass validation and be analyzed by the deepfake detector model."
+        }
+        
+        # First request
+        response1 = client.post("/analyze", json=payload)
+        first_status = response1.status_code
+        
+        # Wait for rate limit to reset (5+ seconds)
+        import time
+        time.sleep(5.1)
+        
+        # Second request should now be allowed
+        response2 = client.post("/analyze", json=payload)
+        assert response2.status_code != 429
+
+
+class TestResponseValidation:
+    """Test response structure and validation."""
+    
+    def test_response_includes_all_fields(self):
+        """Test that response includes all required fields."""
+        payload = {
+            "content_type": "text",
+            "text": "This is a comprehensive test to ensure the response includes all necessary fields for proper API usage and data handling requirements."
+        }
+        response = client.post("/analyze", json=payload)
+        
+        if response.status_code == 200:
+            data = response.json()
+            required_fields = ["is_deepfake", "confidence", "analysis_time", "used_model", "content_type"]
+            for field in required_fields:
+                assert field in data, f"Missing required field: {field}"
+    
+    def test_response_confidence_range(self):
+        """Test that confidence score is between 0.0 and 1.0."""
+        payload = {
+            "content_type": "text",
+            "text": "This is another test to verify that the confidence score is properly normalized between zero and one for consistent API behavior."
+        }
+        response = client.post("/analyze", json=payload)
+        
+        if response.status_code == 200:
+            data = response.json()
+            assert 0.0 <= data["confidence"] <= 1.0
+    
+    def test_response_analysis_time_positive(self):
+        """Test that analysis_time is positive."""
+        payload = {
+            "content_type": "text",
+            "text": "Testing the analysis time tracking to ensure it records valid positive durations for performance monitoring purposes."
+        }
+        response = client.post("/analyze", json=payload)
+        
+        if response.status_code == 200:
+            data = response.json()
+            assert data["analysis_time"] > 0
+
+
+class TestRedisIntegration:
+    """Test Redis queue integration."""
+    
+    def test_queue_service_initialization(self):
+        """Test that queue service initializes correctly."""
+        queue_service = get_queue_service()
+        assert queue_service is not None
+    
+    def test_queue_service_singleton(self):
+        """Test that queue service is a singleton."""
+        queue_service1 = get_queue_service()
+        queue_service2 = get_queue_service()
+        assert queue_service1 is queue_service2
+    
+    @pytest.mark.asyncio
+    async def test_enqueue_analysis_task(self):
+        """Test enqueuing an analysis task."""
+        queue_service = get_queue_service()
+        
+        result = await queue_service.enqueue_analysis(
+            file_url="https://example.com/text.txt",
+            model="yaya36095/xlm-roberta-text-detector",
+            task_id="test_task_001"
+        )
+        
+        assert result is True
+    
+    @pytest.mark.asyncio
+    async def test_get_task_result(self):
+        """Test retrieving task result from queue."""
+        queue_service = get_queue_service()
+        
+        # Try to get a non-existent result
+        result = await queue_service.get_task_result("non_existent_task")
+        
+        # Should return None for non-existent task
+        assert result is None
+    
+    def test_redis_config_available(self):
+        """Test that Redis config is available."""
+        from app.core.config import get_settings
+        settings = get_settings()
+        
+        assert hasattr(settings, "REDIS_ENABLED")
+        assert hasattr(settings, "REDIS_URL")
+        assert hasattr(settings, "REDIS_QUEUE_NAME")
+
+
+class TestAsyncTextAnalyzer:
+    """Test async text analyzer directly."""
+    
+    @pytest.mark.asyncio
+    async def test_analyze_text_valid_input(self):
+        """Test analyze_text function with valid input."""
+        text = "This is a comprehensive test of the async text analyzer to ensure it properly processes input and returns valid results."
+        
+        result = await analyze_text(text)
+        
+        assert isinstance(result, dict)
+        assert "is_deepfake" in result
+        assert "confidence" in result
+        assert "analysis_time" in result
+        assert isinstance(result["is_deepfake"], bool)
+        assert isinstance(result["confidence"], float)
+        assert 0.0 <= result["confidence"] <= 1.0
+    
+    @pytest.mark.asyncio
+    async def test_analyze_text_multiple_calls(self):
+        """Test that analyze_text can be called multiple times (model caching)."""
+        text1 = "First test text that should be analyzed by the model to verify it works correctly on multiple invocations."
+        text2 = "Second test text to ensure the model remains loaded in memory for subsequent analysis operations."
+        
+        result1 = await analyze_text(text1)
+        result2 = await analyze_text(text2)
+        
+        assert result1 is not None
+        assert result2 is not None
+        assert "confidence" in result1
+        assert "confidence" in result2
+
+
+class TestErrorHandling:
+    """Test error handling in endpoints."""
+    
+    def test_unsupported_content_type(self):
+        """Test handling of unsupported content type."""
+        payload = {
+            "content_type": "unsupported_type",
+            "data": "some data"
+        }
+        response = client.post("/analyze", json=payload)
+        
+        assert response.status_code in [415, 422]  # Unsupported media type or validation error
+    
+    def test_malformed_json(self):
+        """Test handling of malformed JSON."""
+        response = client.post(
+            "/analyze",
+            content="not valid json",
+            headers={"Content-Type": "application/json"}
+        )
+        
+        assert response.status_code == 422
+    
+    def test_invalid_content_type_header(self):
+        """Test handling of invalid Content-Type header."""
+        payload = {
+            "content_type": "text",
+            "text": "Valid test text with sufficient length to be properly analyzed and validated by the system."
+        }
+        response = client.post(
+            "/analyze",
+            json=payload,
+            headers={"Content-Type": "text/plain"}
+        )
+        
+        # Should still work as FastAPI is lenient
+        assert response.status_code in [200, 422, 400, 415, 500]
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "--tb=short"])

index.js

@@ -284,7 +284,7 @@ async function handleAnalysis(interaction, userContent, targetMessage = null) {
 			.addFields(
 				{ name: "Pewność modelu", value: `\`${confidencePercent}%\` \n${progressBar}` },
 				{ name: "Czas przetwarzania", value: `\`${data.analysis_time.toFixed(3)}s\``, inline: true },
-				{ name: "Użyty model", value: `\`${data.model_used}\``, inline: true },
+				{ name: "Użyty model", value: `\`${data.used_model}\``, inline: true },
 				{ name: "Format danych", value: `\`${data.content_type.toUpperCase()}\``, inline: true }
 			)
 			.setTimestamp()