use central cloudflared tunnel

.github/workflows/ci.yml

@@ -35,6 +35,8 @@ jobs:
         run: mypy src/
 
       - name: Test
+        env:
+          DATABASE_URL: "sqlite+aiosqlite:///:memory:"
         run: pytest --cov=src --cov-report=term-missing --cov-fail-under=80
 
   frontend:
@@ -61,7 +63,7 @@ jobs:
         run: npm run lint
 
       - name: Type check
-        run: tsc --noEmit
+        run: npx tsc --noEmit
 
       - name: Test
         run: npm test
@@ -86,8 +88,6 @@ jobs:
           context: ./backend
           push: false
           tags: codetutor-backend:test
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
 
       - name: Build frontend image
         uses: docker/build-push-action@v5
@@ -95,5 +95,3 @@ jobs:
           context: ./frontend
           push: false
           tags: codetutor-frontend:test
-          cache-from: type=gha
-          cache-to: type=gha,mode=max

backend/tests/test_api.py

@@ -177,3 +177,92 @@ async def test_get_stats(client: AsyncClient, db_session: AsyncSession) -> None:
     assert data["by_difficulty"]["easy"] == 1
     assert len(data["by_category"]) == 1
     assert len(data["by_pattern"]) == 1
+
+
+async def test_get_pattern_tutorial(client: AsyncClient, db_session: AsyncSession) -> None:
+    await create_sample_data(db_session)
+    response = await client.get("/api/patterns/two-pointers/tutorial")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["name"] == "Two Pointers"
+    assert data["learning_progression"]["warmup"][0]["title"] == "Two Sum"
+    assert len(data["learning_progression"]["core"]) == 0
+
+
+async def test_get_pattern_tutorial_not_found(client: AsyncClient) -> None:
+    response = await client.get("/api/patterns/nonexistent/tutorial")
+    assert response.status_code == 404
+
+
+async def test_submit_passing(client: AsyncClient, db_session: AsyncSession) -> None:
+    data = await create_sample_data(db_session)
+    q = data["question"]
+    q.test_cases = {
+        "visible": [{"input": {"nums": [2, 7], "target": 9}, "expected": [0, 1]}],
+        "hidden": [{"input": {"nums": [3, 2, 4], "target": 6}, "expected": [1, 2]}],
+    }
+    await db_session.commit()
+
+    response = await client.post(
+        "/api/questions/two-sum/submit",
+        json={
+            "code": "def solve(nums, t): pass",
+            "hidden_outputs": [{"test_id": 1, "output": [1, 2]}],
+        },
+    )
+    assert response.status_code == 200
+    result = response.json()
+    assert result["passed"] is True
+    assert result["total_passed"] == 1
+
+
+async def test_submit_wrong_output(client: AsyncClient, db_session: AsyncSession) -> None:
+    data = await create_sample_data(db_session)
+    data["question"].test_cases = {
+        "visible": [],
+        "hidden": [{"input": {"nums": [1, 2], "target": 3}, "expected": [0, 1]}],
+    }
+    await db_session.commit()
+
+    response = await client.post(
+        "/api/questions/two-sum/submit",
+        json={
+            "code": "def solve(nums, t): pass",
+            "hidden_outputs": [{"test_id": 0, "output": [9, 9]}],
+        },
+    )
+    assert response.status_code == 200
+    assert response.json()["passed"] is False
+
+
+async def test_submit_missing_output(client: AsyncClient, db_session: AsyncSession) -> None:
+    data = await create_sample_data(db_session)
+    data["question"].test_cases = {
+        "visible": [],
+        "hidden": [{"input": {"nums": [1, 2], "target": 3}, "expected": [0, 1]}],
+    }
+    await db_session.commit()
+
+    response = await client.post(
+        "/api/questions/two-sum/submit",
+        json={"code": "def solve(nums, t): pass", "hidden_outputs": []},
+    )
+    assert response.status_code == 200
+    assert response.json()["hidden_results"][0]["error"] == "No output provided"
+
+
+async def test_submit_no_test_cases(client: AsyncClient, db_session: AsyncSession) -> None:
+    await create_sample_data(db_session)
+    response = await client.post(
+        "/api/questions/two-sum/submit",
+        json={"code": "pass", "hidden_outputs": []},
+    )
+    assert response.status_code == 400
+
+
+async def test_submit_not_found(client: AsyncClient) -> None:
+    response = await client.post(
+        "/api/questions/nonexistent/submit",
+        json={"code": "pass", "hidden_outputs": []},
+    )
+    assert response.status_code == 404

backend/tests/test_services.py

@@ -215,6 +215,55 @@ class TestPatternService:
 
         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: