feat: add job description length validation and corresponding tests for resume score service

- fix tests base service to mock httpx tranport instead of rely on external services

Author: AmirAref

magicalapi/services/resume_score_service.py

@@ -35,6 +35,9 @@ async def get_resume_score(
             ErrorResponse: When an error occurs (e.g., 403 if webhook domain not whitelisted).
 
         """
+        if not 100 <= len(job_description) <= 5000:
+            raise ValueError("job_description must be between 100 and 5000 characters long")
+
         request_body = {
             "url": url,
             "job_description": job_description,

tests/services/test_base_service.py

@@ -13,6 +13,23 @@
 from magicalapi.types.schemas import HttpResponse
 
 
+def _make_mock_transport(*, timeout_on_delay: bool = False) -> httpx.MockTransport:
+    def handler(request: httpx.Request) -> httpx.Response:
+        if timeout_on_delay and request.url.path.endswith("/delay/10"):
+            raise httpx.TimeoutException("request timed out", request=request)
+
+        if request.method == "POST":
+            body = json.loads(request.content.decode()) if request.content else {}
+            return httpx.Response(200, json={"json": body}, request=request)
+
+        if request.method == "GET":
+            return httpx.Response(200, json={"url": str(request.url)}, request=request)
+
+        return httpx.Response(405, json={"message": "method not allowed"}, request=request)
+
+    return httpx.MockTransport(handler)
+
+
 @pytest_asyncio.fixture(scope="function")
 async def httpxclient(request) -> AsyncGenerator[httpx.AsyncClient]:
     timeout = (
@@ -25,6 +42,7 @@ async def httpxclient(request) -> AsyncGenerator[httpx.AsyncClient]:
     client = httpx.AsyncClient(
         headers={"content-type": "application/json"},
         timeout=timeout,
+        transport=_make_mock_transport(timeout_on_delay=timeout is not None),
     )
 
     yield client
@@ -39,7 +57,7 @@ async def test_base_service_post_request(httpxclient: httpx.AsyncClient):
     test_data = {"foo": "bar"}
 
     response = await base_service._send_post_request(
-        path="https://httpbin.org/post", data=test_data
+        path="https://example.com/post", data=test_data
     )
     # check response type
     assert isinstance(response, HttpResponse)
@@ -52,7 +70,7 @@ async def test_base_service_post_request(httpxclient: httpx.AsyncClient):
 @pytest.mark.asyncio
 async def test_base_service_get_request(httpxclient: httpx.AsyncClient):
     base_service = BaseService(httpxclient)
-    response = await base_service._send_get_request(path="https://httpbin.org/get")
+    response = await base_service._send_get_request(path="https://example.com/get")
 
     # check response type
     assert isinstance(response, HttpResponse)
@@ -69,11 +87,11 @@ async def test_base_service_request_timed_out(httpxclient: httpx.AsyncClient):
     # post request
     with pytest.raises(APIServerTimedout):
         await base_service._send_post_request(
-            path="https://httpbin.org/delay/10", data={}
+            path="https://example.com/delay/10", data={}
         )
     # gee request
     with pytest.raises(APIServerTimedout):
-        await base_service._send_get_request(path="https://httpbin.org/delay/10")
+        await base_service._send_get_request(path="https://example.com/delay/10")
 
 
 def test_base_service_validating_response(httpxclient: httpx.AsyncClient):

tests/services/test_resume_score_service.py

@@ -0,0 +1,121 @@
+from collections.abc import AsyncGenerator
+import json
+
+import httpx
+import pytest
+import pytest_asyncio
+
+from magicalapi.services.resume_score_service import ResumeScoreService
+from magicalapi.types.base import ErrorResponse
+from magicalapi.types.resume_score import ResumeScoreResponse
+from magicalapi.types.schemas import HttpResponse
+
+
+def _make_resume_score_response() -> HttpResponse:
+    response_body = {
+        "data": {
+            "score": 87,
+            "summary": "Strong match for the role",
+            "strengths": [{"text": "Python experience", "category": "skills"}],
+            "improvements": [
+                {"text": "Add more leadership examples", "category": "other"}
+            ],
+            "job_match": {
+                "score": 90,
+                "summary": "Job match is strong",
+                "pros": [{"type": "title", "message": "Title aligns"}],
+                "cons": [
+                    {"type": "gap", "message": "Missing one requirement"}
+                ],
+                "warns": [
+                    {
+                        "type": "note",
+                        "message": "Consider tailoring summary",
+                    }
+                ],
+            },
+            "skill_match": {
+                "score": 85,
+                "summary": "Skills align",
+                "skills": {"all_skills": ["Python", "AWS"]},
+                "match_result": {
+                    "miss_match": ["Kubernetes"],
+                    "partial_match": ["Docker"],
+                    "strong_match": ["Python"],
+                },
+            },
+            "education_match": {
+                "score": 80,
+                "summary": "Education is a fit",
+                "pros": [{"type": "degree", "message": "Relevant degree"}],
+                "cons": [
+                    {
+                        "type": "specialization",
+                        "message": "Could be more specific",
+                    }
+                ],
+                "warns": [{"type": "note", "message": "No issues"}],
+            },
+            "more_information": {
+                "region": "Europe",
+                "overqualification_status": False,
+                "qualification_reason": "Meets the role requirements",
+            },
+            "jd_text": "job description text",
+        },
+        "usage": {"credits": 10},
+    }
+
+    return HttpResponse(
+        text=json.dumps(response_body),
+        status_code=200,
+    )
+
+
+@pytest_asyncio.fixture(scope="function")
+async def httpxclient() -> AsyncGenerator[httpx.AsyncClient]:
+    client = httpx.AsyncClient(headers={"content-type": "application/json"})
+
+    yield client
+
+    await client.aclose()
+    del client
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("job_description", ["a" * 99, "a" * 5001])
+async def test_get_resume_score_rejects_invalid_job_description_length(
+    httpxclient: httpx.AsyncClient, job_description: str
+):
+    service = ResumeScoreService(httpxclient)
+
+    with pytest.raises(ValueError, match="between 100 and 5000 characters long"):
+        await service.get_resume_score(url="https://example.com/resume.pdf", job_description=job_description)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("job_description", ["a" * 100, "a" * 5000])
+async def test_get_resume_score_accepts_boundary_lengths(
+    httpxclient: httpx.AsyncClient, monkeypatch: pytest.MonkeyPatch, job_description: str
+):
+    service = ResumeScoreService(httpxclient)
+    captured_request: dict[str, str] = {}
+
+    async def fake_send_post_request(path: str, data: dict[str, str], headers: dict[str, str] = {}):
+        captured_request["path"] = path
+        captured_request.update(data)
+        return _make_resume_score_response()
+
+    monkeypatch.setattr(service, "_send_post_request", fake_send_post_request)
+
+    response = await service.get_resume_score(
+        url="https://example.com/resume.pdf",
+        job_description=job_description,
+    )
+
+    assert isinstance(response, ResumeScoreResponse)
+    assert response.data.score == 87
+    assert response.usage.credits == 10
+    assert captured_request["path"] == "resume-score"
+    assert captured_request["url"] == "https://example.com/resume.pdf"
+    assert captured_request["job_description"] == job_description

tests/services/test_webhook_url.py

@@ -14,11 +14,25 @@
 from magicalapi.types.schemas import HttpResponse, WebhookCreatedResponse
 
 
+def _make_mock_transport() -> httpx.MockTransport:
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.method == "POST":
+            body = json.loads(request.content.decode()) if request.content else {}
+            return httpx.Response(200, json={"json": body}, request=request)
+
+        return httpx.Response(
+            405, json={"message": "method not allowed"}, request=request
+        )
+
+    return httpx.MockTransport(handler)
+
+
 @pytest_asyncio.fixture(scope="function")
 async def httpxclient() -> AsyncGenerator[httpx.AsyncClient]:
     """Fixture to create an httpx client for testing."""
     client = httpx.AsyncClient(
         headers={"content-type": "application/json"},
+        transport=_make_mock_transport(),
     )
 
     yield client
@@ -30,15 +44,12 @@ async def httpxclient() -> AsyncGenerator[httpx.AsyncClient]:
 @pytest.mark.asyncio
 async def test_base_service_with_webhook_url(httpxclient: httpx.AsyncClient):
     """Test that webhook_url is properly added to request body."""
-    # Set a reasonable timeout for the client
-    httpxclient._timeout = httpx.Timeout(30.0)
-
     webhook_url = "https://example.com/webhook"
     base_service = BaseService(httpxclient, webhook_url=webhook_url)
     test_data = {"foo": "bar"}
 
     response = await base_service._send_post_request(
-        path="https://httpbin.org/post", data=test_data
+        path="https://example.com/post", data=test_data
     )
 
     # Verify response
@@ -58,7 +69,7 @@ async def test_base_service_without_webhook_url(httpxclient: httpx.AsyncClient):
     test_data = {"foo": "bar"}
 
     response = await base_service._send_post_request(
-        path="https://httpbin.org/post", data=test_data
+        path="https://example.com/post", data=test_data
     )
 
     # Verify response