Testing¶

# tests/unit/test_gaming_detection.py
import pytest
from datetime import datetime, timedelta

from app.compliance.gaming_detection import GamingDetector
from app.compliance.gaming_types import GamingIndicator


class TestCommitBurstDetection:
    """Testy pre detekciu commit burstov."""

    @pytest.fixture
    def detector(self):
        return GamingDetector(
            burst_threshold=10,
            burst_window_hours=2,
        )

    def test_no_burst_when_commits_spread_out(self, detector):
        """Commits rozložené v čase by nemali triggernúť burst."""
        commits = [
            {"timestamp": datetime.now() - timedelta(hours=i)}
            for i in range(10)
        ]

        indicators = detector.detect_bursts(commits)

        assert len(indicators) == 0

    def test_burst_detected_when_many_commits_in_short_time(self, detector):
        """Veľa commitov v krátkom čase by malo triggernúť burst."""
        now = datetime.now()
        commits = [
            {"timestamp": now - timedelta(minutes=i * 5)}
            for i in range(15)
        ]

        indicators = detector.detect_bursts(commits)

        assert len(indicators) == 1
        assert indicators[0].type == GamingIndicator.COMMIT_BURST

    @pytest.mark.parametrize("commit_count,expected_bursts", [
        (5, 0),
        (10, 0),
        (11, 1),
        (25, 1),
    ])
    def test_burst_threshold(self, detector, commit_count, expected_bursts):
        """Test rôznych počtov commitov proti threshold."""
        now = datetime.now()
        commits = [
            {"timestamp": now - timedelta(minutes=i)}
            for i in range(commit_count)
        ]

        indicators = detector.detect_bursts(commits)

        assert len(indicators) == expected_bursts

# tests/unit/test_gitlab_service.py
from unittest.mock import AsyncMock, patch
import pytest

from app.services.gitlab_service import GitLabService


class TestGitLabService:

    @pytest.fixture
    def gitlab_service(self):
        return GitLabService(
            base_url="https://gitlab.example.com",
            token="test-token"
        )

    @pytest.mark.asyncio
    async def test_get_project(self, gitlab_service):
        """Test getting project info from GitLab API."""
        mock_response = {
            "id": 123,
            "name": "test-project",
            "path_with_namespace": "group/test-project"
        }

        with patch.object(
            gitlab_service, 
            "_request", 
            new_callable=AsyncMock,
            return_value=mock_response
        ):
            project = await gitlab_service.get_project(123)

            assert project["id"] == 123
            assert project["name"] == "test-project"

# tests/conftest.py
import pytest
import pytest_asyncio
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker

from app.models.base import Base


@pytest.fixture(scope="session")
def event_loop():
    """Create event loop for async tests."""
    import asyncio
    loop = asyncio.new_event_loop()
    yield loop
    loop.close()


@pytest_asyncio.fixture(scope="function")
async def db_session():
    """Create test database session."""
    engine = create_async_engine(
        "sqlite+aiosqlite:///:memory:",
        echo=False,
    )

    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)

    async_session = sessionmaker(
        engine, class_=AsyncSession, expire_on_commit=False
    )

    async with async_session() as session:
        yield session

    await engine.dispose()

# tests/integration/test_api_courses.py
import pytest
from httpx import AsyncClient
from fastapi import status

from app.main import app


@pytest.mark.asyncio
class TestCoursesAPI:

    @pytest_asyncio.fixture
    async def client(self):
        async with AsyncClient(app=app, base_url="http://test") as ac:
            yield ac

    async def test_create_course(self, client, auth_headers):
        """Test creating a new course."""
        course_data = {
            "code": "TP-2024",
            "name": "Tímový projekt",
            "academic_year": "2024/2025",
            "semester": "winter"
        }

        response = await client.post(
            "/api/v1/courses/",
            json=course_data,
            headers=auth_headers
        )

        assert response.status_code == status.HTTP_201_CREATED
        data = response.json()
        assert data["code"] == "TP-2024"
        assert "id" in data

    async def test_get_course_not_found(self, client, auth_headers):
        """Test 404 for non-existent course."""
        response = await client.get(
            "/api/v1/courses/99999",
            headers=auth_headers
        )

        assert response.status_code == status.HTTP_404_NOT_FOUND

# tests/conftest.py
import pytest
from datetime import datetime

from app.models.course import Course
from app.models.team import Team
from app.models.user import User


@pytest.fixture
def sample_course():
    """Factory pre vytvorenie test course."""
    def _create(
        code: str = "TEST-001",
        name: str = "Test Course",
        **kwargs
    ):
        return Course(
            code=code,
            name=name,
            academic_year="2024/2025",
            semester="winter",
            **kwargs
        )
    return _create


@pytest.fixture
def sample_team(sample_course):
    """Factory pre vytvorenie test team."""
    def _create(
        name: str = "Team Alpha",
        course: Course = None,
        **kwargs
    ):
        return Team(
            name=name,
            course=course or sample_course(),
            **kwargs
        )
    return _create


@pytest.fixture
def auth_headers():
    """Headers s test auth token."""
    return {"Authorization": "Bearer test-token-123"}

# 1. Testy závislé na poradí
def test_create_then_read():  # Závisí na test_create

# 2. Príliš veľa assertions
def test_everything():
    assert this
    assert that
    assert other  # Rozdeliť do viacerých testov

# 3. Sleep v testoch
import time
time.sleep(5)  # Použiť mock alebo async waiting