test(backend): add unit tests

backend/tests/test_services.py

@@ -0,0 +1,286 @@
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from src.models import Category, Difficulty, Pattern, Question
+from src.services import CategoryService, PatternService, QuestionService, StatsService
+
+TestData = dict[str, Any]
+
+
+async def create_test_data(db_session: AsyncSession) -> TestData:
+    cat_arrays = Category(name="Arrays", slug="arrays")
+    cat_strings = Category(name="Strings", slug="strings")
+    db_session.add_all([cat_arrays, cat_strings])
+
+    pat_two_pointers = Pattern(name="Two Pointers", slug="two-pointers")
+    pat_sliding = Pattern(name="Sliding Window", slug="sliding-window")
+    db_session.add_all([pat_two_pointers, pat_sliding])
+
+    await db_session.flush()
+
+    q1 = Question(
+        title="Two Sum",
+        slug="two-sum",
+        difficulty=Difficulty.EASY,
+        description="Find two numbers.",
+    )
+    q1.categories = [cat_arrays]
+    q1.patterns = [pat_two_pointers]
+
+    q2 = Question(
+        title="Three Sum",
+        slug="three-sum",
+        difficulty=Difficulty.MEDIUM,
+        description="Find three numbers.",
+    )
+    q2.categories = [cat_arrays]
+    q2.patterns = [pat_two_pointers]
+
+    q3 = Question(
+        title="Longest Substring",
+        slug="longest-substring",
+        difficulty=Difficulty.MEDIUM,
+        description="Find longest substring.",
+    )
+    q3.categories = [cat_strings]
+    q3.patterns = [pat_sliding]
+
+    db_session.add_all([q1, q2, q3])
+    await db_session.commit()
+
+    return {
+        "cat_arrays": cat_arrays,
+        "cat_strings": cat_strings,
+        "pat_two_pointers": pat_two_pointers,
+        "pat_sliding": pat_sliding,
+        "q1": q1,
+        "q2": q2,
+        "q3": q3,
+    }
+
+
+class TestQuestionService:
+    async def test_get_questions(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        questions, total = await service.get_questions()
+
+        assert total == 3
+        assert len(questions) == 3
+
+    async def test_pagination(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        questions, total = await service.get_questions(page=1, limit=2)
+
+        assert total == 3
+        assert len(questions) == 2
+
+    async def test_filter_difficulty(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        questions, total = await service.get_questions(difficulties=[Difficulty.EASY])
+
+        assert total == 1
+        assert questions[0].title == "Two Sum"
+
+    async def test_filter_category(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        questions, total = await service.get_questions(category_slug="arrays")
+
+        assert total == 2
+
+    async def test_filter_pattern(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        questions, total = await service.get_questions(pattern_slug="sliding-window")
+
+        assert total == 1
+        assert questions[0].title == "Longest Substring"
+
+    async def test_search(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        questions, total = await service.get_questions(search="Sum")
+
+        assert total == 2
+
+    async def test_get_by_slug(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        question = await service.get_question_by_slug("two-sum")
+
+        assert question is not None
+        assert question.title == "Two Sum"
+
+    async def test_get_by_slug_not_found(self, db_session: AsyncSession) -> None:
+        service = QuestionService(db_session)
+        question = await service.get_question_by_slug("nonexistent")
+
+        assert question is None
+
+    async def test_get_by_id(self, db_session: AsyncSession) -> None:
+        data = await create_test_data(db_session)
+        service = QuestionService(db_session)
+        question = await service.get_question_by_id(data["q1"].id)
+
+        assert question is not None
+        assert question.title == "Two Sum"
+
+    async def test_get_by_id_not_found(self, db_session: AsyncSession) -> None:
+        from uuid import uuid4
+
+        service = QuestionService(db_session)
+        question = await service.get_question_by_id(uuid4())
+
+        assert question is None
+
+    async def test_combined_filters(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        questions, total = await service.get_questions(
+            difficulties=[Difficulty.MEDIUM],
+            category_slug="arrays",
+        )
+
+        assert total == 1
+        assert questions[0].title == "Three Sum"
+
+    async def test_pagination_page_two(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        questions, total = await service.get_questions(page=2, limit=2)
+
+        assert total == 3
+        assert len(questions) == 1
+
+    async def test_pagination_beyond_data(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = QuestionService(db_session)
+        questions, total = await service.get_questions(page=10, limit=20)
+
+        assert total == 3
+        assert len(questions) == 0
+
+
+class TestCategoryService:
+    async def test_get_categories(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = CategoryService(db_session)
+        categories = await service.get_categories()
+
+        assert len(categories) == 2
+
+        arrays = next((c, cnt) for c, cnt in categories if c.slug == "arrays")
+        assert arrays[1] == 2
+
+    async def test_get_by_slug(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = CategoryService(db_session)
+        category = await service.get_category_by_slug("arrays")
+
+        assert category is not None
+        assert category.name == "Arrays"
+
+    async def test_get_by_slug_not_found(self, db_session: AsyncSession) -> None:
+        service = CategoryService(db_session)
+        category = await service.get_category_by_slug("nonexistent")
+
+        assert category is None
+
+
+class TestPatternService:
+    async def test_get_patterns(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = PatternService(db_session)
+        patterns = await service.get_patterns()
+
+        assert len(patterns) == 2
+
+    async def test_get_by_slug(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = PatternService(db_session)
+        result = await service.get_pattern_by_slug("two-pointers")
+
+        assert result is not None
+        pattern, count = result
+        assert pattern.name == "Two Pointers"
+        assert count == 2
+
+    async def test_get_by_slug_not_found(self, db_session: AsyncSession) -> None:
+        service = PatternService(db_session)
+        result = await service.get_pattern_by_slug("nonexistent")
+
+        assert result is None
+
+    async def test_get_tutorial(self, db_session: AsyncSession) -> None:
+        related = Pattern(name="BFS", slug="bfs", description="Breadth-first search")
+        pattern = Pattern(
+            name="Two Pointers",
+            slug="two-pointers",
+            description="Two pointer technique",
+            common_mistakes=[
+                {"title": "Off by one", "description": "Wrong bounds", "fix": "Use <="}
+            ],
+            variations=[{"name": "Fast/slow", "description": "Different speeds"}],
+            related_patterns=["bfs"],
+            visualization_examples=[{"id": "ex1", "title": "Basic", "code": "x=1", "steps": []}],
+        )
+        db_session.add_all([related, pattern])
+        await db_session.flush()
+
+        q1 = Question(
+            title="Easy Q", slug="easy-q", difficulty=Difficulty.EASY, description="Easy."
+        )
+        q2 = Question(title="Med Q", slug="med-q", difficulty=Difficulty.MEDIUM, description="Med.")
+        q3 = Question(
+            title="Hard Q", slug="hard-q", difficulty=Difficulty.HARD, description="Hard."
+        )
+        q1.patterns = [pattern]
+        q2.patterns = [pattern]
+        q3.patterns = [pattern]
+        db_session.add_all([q1, q2, q3])
+        await db_session.commit()
+
+        service = PatternService(db_session)
+        result = await service.get_pattern_tutorial("two-pointers")
+
+        assert result is not None
+        assert result.name == "Two Pointers"
+        assert len(result.common_mistakes) == 1
+        assert len(result.variations) == 1
+        assert len(result.related_patterns) == 1
+        assert result.related_patterns[0].slug == "bfs"
+        assert len(result.learning_progression.warmup) == 1
+        assert len(result.learning_progression.core) == 1
+        assert len(result.learning_progression.challenge) == 1
+        assert len(result.visualization_examples) == 1
+
+    async def test_get_tutorial_not_found(self, db_session: AsyncSession) -> None:
+        service = PatternService(db_session)
+        result = await service.get_pattern_tutorial("nonexistent")
+
+        assert result is None
+
+
+class TestStatsService:
+    async def test_get_stats(self, db_session: AsyncSession) -> None:
+        await create_test_data(db_session)
+        service = StatsService(db_session)
+        stats = await service.get_stats()
+
+        assert stats.total_questions == 3
+        assert stats.by_difficulty.easy == 1
+        assert stats.by_difficulty.medium == 2
+        assert stats.by_difficulty.hard == 0
+        assert len(stats.by_category) == 2
+        assert len(stats.by_pattern) == 2
+
+    async def test_get_stats_empty(self, db_session: AsyncSession) -> None:
+        service = StatsService(db_session)
+        stats = await service.get_stats()
+
+        assert stats.total_questions == 0
+        assert stats.by_difficulty.easy == 0