test: update test cases

.gitignore

@@ -105,6 +105,7 @@ coverage.xml
 .hypothesis/
 */playwright-report/*
 */test-results/*
+coverage.json
 
 # Translations
 *.mo

my_ghost_writer/app.py

@@ -14,7 +14,7 @@ from fastapi.staticfiles import StaticFiles
 from pymongo import __version__ as pymongo_version
 from pymongo.errors import PyMongoError
 
-from my_ghost_writer import pymongo_operations_rw
+from my_ghost_writer import pymongo_operations_rw, exception_handlers
 from my_ghost_writer.constants import (app_logger, ALLOWED_ORIGIN_LIST, API_MODE, DOMAIN, IS_TESTING, LOG_LEVEL, PORT,
     STATIC_FOLDER, WORDSAPI_KEY, WORDSAPI_URL, RAPIDAPI_HOST, MONGO_USE_OK, MONGO_HEALTHCHECK_SLEEP)
 from my_ghost_writer.pymongo_utils import mongodb_health_check
@@ -159,15 +159,11 @@ def get_thesaurus_wordsapi(body: RequestQueryThesaurusWordsapiBody | str) -> JSO
 
 @app.exception_handler(RequestValidationError)
 def request_validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
-    from my_ghost_writer import exception_handlers
-
     return exception_handlers.request_validation_exception_handler(request, exc)
 
 
 @app.exception_handler(HTTPException)
 def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
-    from my_ghost_writer import exception_handlers
-
     return exception_handlers.http_exception_handler(request, exc)
 
 

tests/test_app.py

@@ -1,8 +1,11 @@
+import asyncio
 import unittest
 from unittest.mock import patch, MagicMock
+
+from fastapi import Request
 from fastapi.testclient import TestClient
 
-from my_ghost_writer.app import app
+from my_ghost_writer.app import app, mongo_health_check_background_task, lifespan
 
 
 class TestAppEndpoints(unittest.TestCase):
@@ -76,6 +79,19 @@ class TestAppEndpoints(unittest.TestCase):
             self.assertEqual(response.status_code, 200)
             self.assertEqual(response.json()["source"], "wordsapi")
 
+    @patch("my_ghost_writer.app.pymongo_operations_rw.get_document_by_word", side_effect=AssertionError("fail"))
+    @patch("my_ghost_writer.app.requests.get")
+    def test_thesaurus_wordsapi_remote_non_200(self, mock_requests_get, mock_get_doc):
+        mock_response = MagicMock()
+        mock_response.status_code = 400
+        mock_response.json.return_value = {"error": "not found"}
+        mock_requests_get.return_value = mock_response
+        with patch("my_ghost_writer.app.db_ok", {"mongo_ok": True}):
+            body = '{"query": "test"}'
+            response = self.client.post("/thesaurus-wordsapi", json=body)
+            self.assertEqual(response.status_code, 500)
+            self.assertIn("Error - Internal Server Error", response.text)
+
     @patch("my_ghost_writer.app.WORDSAPI_URL", "http://mocked-url.com")
     @patch("my_ghost_writer.app.RAPIDAPI_HOST", "mocked-rapidapi-host.com")
     @patch("my_ghost_writer.app.WORDSAPI_KEY", "WORDSAPI_KEY")
@@ -107,5 +123,68 @@ class TestAppEndpoints(unittest.TestCase):
             self.assertEqual(response.text, "")
 
 
+    @patch("my_ghost_writer.app.pymongo_operations_rw.get_document_by_word", side_effect=AssertionError("fail"))
+    @patch("my_ghost_writer.app.requests.get")
+    def test_thesaurus_wordsapi_remote_non_200(self, mock_requests_get, mock_get_doc):
+        mock_response = MagicMock()
+        mock_response.status_code = 400
+        mock_response.json.return_value = {"error": "not found"}
+        mock_requests_get.return_value = mock_response
+        with patch("my_ghost_writer.app.db_ok", {"mongo_ok": True}):
+            body = '{"query": "test"}'
+            response = self.client.post("/thesaurus-wordsapi", json=body)
+            self.assertEqual(response.status_code, 500)
+            self.assertIn("Error - Internal Server Error", response.text)
+
+    def test_lifespan(self):
+        # Test that lifespan yields and cancels the task
+        async def run_lifespan():
+            gen = lifespan(app)
+            await gen.asend(None)
+            await gen.aclose()
+        asyncio.run(run_lifespan())
+
+    def test_mongo_health_check_background_task(self):
+        # Patch sleep and health_mongo to exit after one loop
+        with patch("my_ghost_writer.app.MONGO_USE_OK", True), \
+                patch("my_ghost_writer.app.health_mongo", return_value="Mongodb: still alive..."), \
+                patch("my_ghost_writer.app.asyncio.sleep", side_effect=Exception("stop")):
+            with self.assertRaises(Exception):
+                asyncio.run(mongo_health_check_background_task())
+
+    def test_index_route(self):
+        from pathlib import Path
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmpdir:
+            index_path = Path(tmpdir) / "index.html"
+            index_path.write_text("<html>Test</html>")
+            with patch("my_ghost_writer.app.STATIC_FOLDER", Path(tmpdir)):
+                response = self.client.get("/")
+                self.assertEqual(response.status_code, 200)
+                self.assertIn("Test", response.text)
+
+    def test_static_route(self):
+        with patch("my_ghost_writer.app.STATIC_FOLDER") as mock_static:
+            mock_static.__truediv__.return_value = "index.html"
+            response = self.client.get("/static/")
+            self.assertEqual(response.status_code, 200)
+
+    @patch("my_ghost_writer.app.exception_handlers.request_validation_exception_handler")
+    def test_request_validation_exception_handler(self, mock_handler):
+        req = MagicMock(spec=Request)
+        exc = MagicMock()
+        from my_ghost_writer.app import request_validation_exception_handler
+        request_validation_exception_handler(req, exc)
+        mock_handler.assert_called_once_with(req, exc)
+
+    @patch("my_ghost_writer.app.exception_handlers.http_exception_handler")
+    def test_http_exception_handler(self, mock_handler):
+        req = MagicMock(spec=Request)
+        exc = MagicMock()
+        from my_ghost_writer.app import http_exception_handler
+        http_exception_handler(req, exc)
+        mock_handler.assert_called_once_with(req, exc)
+
+
 if __name__ == "__main__":
     unittest.main()

tests/test_exception_handlers.py

@@ -0,0 +1,48 @@
+import pytest
+from fastapi import HTTPException, status
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+
+from my_ghost_writer.exception_handlers import request_validation_exception_handler, http_exception_handler
+
+
+class DummyRequest:
+    def __init__(self):
+        self.headers = {"x-test": "header"}
+        self.query_params = {"q": "param"}
+    @property
+    def headers(self):
+        return self._headers
+    @headers.setter
+    def headers(self, value):
+        self._headers = value
+    @property
+    def query_params(self):
+        return self._query_params
+    @query_params.setter
+    def query_params(self, value):
+        self._query_params = value
+
+
+def test_request_validation_exception_handler():
+    request = DummyRequest()
+    exc = RequestValidationError([{"loc": ["body", "field"], "msg": "field required", "type": "value_error.missing"}])
+    exc.body = {"field": None}
+    response = request_validation_exception_handler(request, exc)
+    assert isinstance(response, JSONResponse)
+    assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY
+    assert response.body
+    assert b"Unprocessable Entity" in response.body
+
+def test_http_exception_handler():
+    request = DummyRequest()
+    exc = HTTPException(status_code=400, detail="Bad request")
+    response = http_exception_handler(request, exc)
+    assert isinstance(response, JSONResponse)
+    assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
+    assert response.body
+    assert b"Internal Server Error" in response.body
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])