[test] add fastapi app test cases

.coveragerc

@@ -1,6 +1,6 @@
 [run]
 source = samgis
-omit = ./venv/*,*tests*,*apps.py,*manage.py,*__init__.py,*migrations*,*asgi*,*wsgi*,*admin.py,*urls.py,./tests/*
+omit = ./venv/*,__version__.py,*tests*,*apps.py,*manage.py,*__init__.py,*migrations*,*asgi*,*wsgi*,*admin.py,*urls.py,./tests/*
 
 [report]
 omit = ./venv/*,*tests*,*apps.py,*manage.py,*__init__.py,*migrations*,*asgi*,*wsgi*,*admin.py,*urls.py,./tests/*

.idea/other.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="PySciProjectComponent">
+    <option name="PY_INTERACTIVE_PLOTS_SUGGESTED" value="true" />
+  </component>
+</project>

pyproject.toml

@@ -36,6 +36,7 @@ optional = true
 pytest = "^7.4.3"
 pytest-cov = "^4.1.0"
 python-dotenv = "^1.0.0"
+httpx = "^0.26.0"
 
 [tool.poetry.group.docs]
 optional = true

samgis/__init__.py

@@ -5,7 +5,6 @@ from pathlib import Path
 
 from samgis.utilities.constants import SERVICE_NAME
 
-
 PROJECT_ROOT_FOLDER = Path(globals().get("__file__", "./_")).absolute().parent.parent
 MODEL_FOLDER = Path(PROJECT_ROOT_FOLDER / "machine_learning_models")
 try:
@@ -13,29 +12,4 @@ try:
 
     app_logger = Logger(service=SERVICE_NAME)
 except ModuleNotFoundError:
-    import loguru
-
-    def setup_logging(debug: bool = False, formatter: str = "{time} - {level} - ({extra[request_id]}) {message} "
-                      ) -> loguru.logger:
-        """
-        Create a logging instance with log string formatter.
-
-        Args:
-            debug: logging debug argument
-            formatter: log string formatter
-
-        Returns:
-            Logger
-
-        """
-        import sys
-
-        logger = loguru.logger
-        logger.remove()
-        level_logger = "DEBUG" if debug else "INFO"
-        logger.add(sys.stdout, format=formatter, level=level_logger)
-        logger.info(f"type_logger:{type(logger)}, logger:{logger}.")
-        return logger
-
-
-    app_logger = setup_logging(debug=True)
+    from wrappers.fastapi_wrapper import app_logger

samgis/io/wrappers_helpers.py

@@ -165,16 +165,22 @@ nextzen_terrain_rgb = TileProvider(
 
 
 def get_url_tile(source_type: str):
-    match source_type.lower():
-        case TmsDefaultProvidersNames.DEFAULT_TILES_NAME_SHORT:
-            return providers.query_name(TmsDefaultProvidersNames.DEFAULT_TILES_NAME_SHORT)
-        case TmsTerrainProvidersNames.MAPBOX_TERRAIN_TILES_NAME:
-            return mapbox_terrain_rgb
-        case TmsTerrainProvidersNames.NEXTZEN_TERRAIN_TILES_NAME:
-            app_logger.info("nextzen_terrain_rgb:", nextzen_terrain_rgb)
-            return nextzen_terrain_rgb
-
-    return providers.query_name(source_type)
+    try:
+        match source_type.lower():
+            case TmsDefaultProvidersNames.DEFAULT_TILES_NAME_SHORT:
+                return providers.query_name(TmsDefaultProvidersNames.DEFAULT_TILES_NAME)
+            case TmsTerrainProvidersNames.MAPBOX_TERRAIN_TILES_NAME:
+                return mapbox_terrain_rgb
+            case TmsTerrainProvidersNames.NEXTZEN_TERRAIN_TILES_NAME:
+                app_logger.info("nextzen_terrain_rgb:", nextzen_terrain_rgb)
+                return nextzen_terrain_rgb
+
+        return providers.query_name(source_type)
+    except ValueError as ve:
+        from pydantic_core import ValidationError
+
+        app_logger.error("ve:", str(ve))
+        raise ValidationError(ve)
 
 
 def check_source_type_is_terrain(source: str | TileProvider):

samgis/utilities/fastapi_logger.py

@@ -0,0 +1,24 @@
+import loguru
+
+
+def setup_logging(debug: bool = False, formatter: str = "{time} - {level} - ({extra[request_id]}) {message} "
+                  ) -> loguru.logger:
+    """
+    Create a logging instance with log string formatter.
+
+    Args:
+        debug: logging debug argument
+        formatter: log string formatter
+
+    Returns:
+        Logger
+
+    """
+    import sys
+
+    logger = loguru.logger
+    logger.remove()
+    level_logger = "DEBUG" if debug else "INFO"
+    logger.add(sys.stdout, format=formatter, level=level_logger)
+    logger.info(f"type_logger:{type(logger)}, logger:{logger}.")
+    return logger

tests/io/test_lambda_helpers.py

@@ -3,8 +3,8 @@ import time
 from http import HTTPStatus
 from unittest.mock import patch
 
-from samgis.io import lambda_helpers
-from samgis.io.lambda_helpers import get_parsed_bbox_points, get_parsed_request_body, get_response
+from samgis.io import wrappers_helpers
+from samgis.io.wrappers_helpers import get_parsed_bbox_points, get_parsed_request_body, get_response
 from samgis.utilities.type_hints import ApiRequestBody
 from samgis.utilities import utilities
 from tests import TEST_EVENTS_FOLDER
@@ -89,10 +89,10 @@ def test_get_parsed_request_body():
     assert output == ApiRequestBody.model_validate(expected_output_dict)
 
 
-@patch.object(lambda_helpers, "providers")
+@patch.object(wrappers_helpers, "providers")
 def test_get_url_tile(providers_mocked):
     import xyzservices
-    from samgis.io.lambda_helpers import get_url_tile
+    from samgis.io.wrappers_helpers import get_url_tile
 
     from tests import LOCAL_URL_TILE
 
@@ -112,7 +112,7 @@ def test_get_url_tile(providers_mocked):
 
 
 def test_get_url_tile_real():
-    from samgis.io.lambda_helpers import get_url_tile
+    from samgis.io.wrappers_helpers import get_url_tile
 
     assert get_url_tile("OpenStreetMap") == {
         'url': 'https://tile.openstreetmap.org/{z}/{x}/{y}.png', 'max_zoom': 19,

tests/test_fastapi_app.py

@@ -0,0 +1,172 @@
+import json
+import time
+import unittest
+from unittest.mock import patch
+
+from fastapi.testclient import TestClient
+
+from samgis import PROJECT_ROOT_FOLDER
+from tests import TEST_EVENTS_FOLDER
+from wrappers import fastapi_wrapper
+from wrappers.fastapi_wrapper import app
+
+client = TestClient(app)
+source = {
+    'url': 'https://tile.openstreetmap.org/{z}/{x}/{y}.png', 'max_zoom': 19,
+    'html_attribution': '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
+    'attribution': '(C) OpenStreetMap contributors', 'name': 'OpenStreetMap.Mapnik'
+}
+event = {
+    "bbox": {
+        "ne": {"lat": 39.036252959636606, "lng": 15.040283203125002},
+        "sw": {"lat": 38.302869955150044, "lng": 13.634033203125002}
+    },
+    "prompt": [{"type": "point", "data": {"lat": 38.48542007717153, "lng": 14.921846904165468}, "label": 0}],
+    "zoom": 10, "source_type": "OpenStreetMap"
+}
+response_bodies_post_test = {
+    "single_point": {
+        'bbox': [[39.036252959636606, 15.040283203125002], [38.302869955150044, 13.634033203125002]],
+        'prompt': [{'type': 'point', 'label': 0, 'data': [937, 514]}], 'zoom': 10,
+        'source': source
+    },
+    "multi_prompt": {
+        'bbox': [[39.011714588834074, 15.093841552734377], [38.278078995562105, 13.687591552734377]],
+        'prompt': [
+            {'type': 'point', 'label': 1, 'data': [839, 421]},
+            {'type': 'point', 'label': 1, 'data': [906, 489]},
+            {'type': 'point', 'label': 1, 'data': [936, 580]}
+        ], 'zoom': 10,
+        'source': source
+    },
+    "single_rectangle": {
+        'bbox': [[39.011714588834074, 15.093841552734377], [38.278078995562105, 13.687591552734377]],
+        'prompt': [{'type': 'rectangle', 'data': [875, 445, 951, 538]}], 'zoom': 10,
+        'source': source
+    }
+}
+
+
+class TestFastapiApp(unittest.TestCase):
+    def test_fastapi_handler_health_200(self):
+        response = client.get("/health")
+        assert response.status_code == 200
+        body = response.json()
+        assert body == {"msg": "still alive..."}
+
+    def test_fastapi_handler_post_test_200(self):
+        fn_name = "lambda_handler"
+        for json_filename in [
+            "single_point",
+            "multi_prompt",
+            "single_rectangle"
+        ]:
+            with open(TEST_EVENTS_FOLDER / f"{fn_name}_{json_filename}.json") as tst_json:
+                inputs_outputs = json.load(tst_json)
+                input_body = json.loads(inputs_outputs["input"]["body"])
+                response = client.post("/post_test", json=input_body)
+                assert response.status_code == 200
+                response_body = response.json()
+                assert response_body == response_bodies_post_test[json_filename]
+
+    def test_fastapi_handler_post_test_422(self):
+        response = client.post("/post_test", json={})
+        assert response.status_code == 422
+        body = response.json()
+        assert body == {'msg': 'Error - Unprocessable Entity'}
+
+    def test_index(self):
+        import subprocess
+
+        subprocess.run(["pnpm", "build"], cwd=PROJECT_ROOT_FOLDER / "static")
+        subprocess.run(["pnpm", "tailwindcss", "-i", "./src/input.css", "-o", "./dist/output.css"],
+                       cwd=PROJECT_ROOT_FOLDER / "static")
+        response = client.get("/")
+        assert response.status_code == 200
+        html_body = response.read().decode("utf-8")
+        assert "html" in html_body
+        assert "head" in html_body
+        assert "body" in html_body
+
+    def test_404(self):
+        response = client.get("/404")
+        assert response.status_code == 404
+
+    def test_infer_samgis_422(self):
+        response = client.post("/infer_samgis", json={})
+        print("response.status_code:", response.status_code)
+        assert response.status_code == 422
+        body_loaded = response.json()
+        print("response.body_loaded:", body_loaded)
+        assert body_loaded == {"msg": "Error - Unprocessable Entity"}
+
+    def test_infer_samgis_middleware_500(self):
+        from copy import deepcopy
+        local_event = deepcopy(event)
+
+        local_event["source_type"] = "source_fake"
+        response = client.post("/infer_samgis", json=local_event)
+        print("response.status_code:", response.status_code)
+        assert response.status_code == 500
+        body_loaded = response.json()
+        print("response.body_loaded:", body_loaded)
+        assert body_loaded == {'success': False}
+
+    @patch.object(time, "time")
+    @patch.object(fastapi_wrapper, "samexporter_predict")
+    def test_infer_samgis_500(self, samexporter_predict_mocked, time_mocked):
+        time_mocked.return_value = 0
+        samexporter_predict_mocked.side_effect = ValueError("I raise a value error!")
+
+        response = client.post("/infer_samgis", json=event)
+        print("response.status_code:", response.status_code)
+        assert response.status_code == 500
+        body = response.json()
+        print("response.body:", body)
+        assert body == {'msg': 'Error - Internal Server Error'}
+
+    @patch.object(time, "time")
+    def test_infer_samgis_real_200(self, time_mocked):
+        import shapely
+
+        time_mocked.return_value = 0
+
+        response = client.post("/infer_samgis", json=event)
+        print("response.status_code:", response.status_code)
+        assert response.status_code == 200
+        body_string = response.json()["body"]
+        body_loaded = json.loads(body_string)
+        print("response.body_loaded:", body_loaded)
+        assert "duration_run" in body_loaded
+        output = body_loaded["output"]
+        assert 'n_predictions' in output
+        assert "n_shapes_geojson" in output
+        geojson = output["geojson"]
+        output_geojson = shapely.from_geojson(geojson)
+        print("output_geojson::", type(output_geojson))
+        assert isinstance(output_geojson, shapely.GeometryCollection)
+        assert len(output_geojson.geoms) == 3
+
+    @patch.object(time, "time")
+    @patch.object(fastapi_wrapper, "samexporter_predict")
+    def test_infer_samgis_mocked_200(self, samexporter_predict_mocked, time_mocked):
+        self.maxDiff = None
+
+        time_mocked.return_value = 0
+        samexporter_output = {
+          "n_predictions": 1,
+          "geojson": "{\"type\": \"FeatureCollection\", \"features\": [{\"id\": \"0\", \"type\": \"Feature\", " +
+                     "\"properties\": {\"raster_val\": 255.0}, \"geometry\": {\"type\": \"Polygon\", " +
+                     "\"coordinates\": [[[148.359375, -40.4469470596005], [148.447265625, -40.4469470596005], " +
+                     "[148.447265625, -40.51379915504414], [148.359375, -40.4469470596005]]]}}]}",
+          "n_shapes_geojson": 2
+        }
+        samexporter_predict_mocked.return_value = samexporter_output
+
+        response = client.post("/infer_samgis", json=event)
+        print("response.status_code:", response.status_code)
+        assert response.status_code == 200
+        response_json = response.json()
+        body_loaded = json.loads(response_json["body"])
+        print("response.body_loaded:", body_loaded)
+        self.assertDictEqual(body_loaded, {'duration_run': 0, 'output': samexporter_output})

tests/{test_app.py → test_lambda_app.py}

@@ -3,14 +3,19 @@ import time
 import unittest
 from unittest.mock import patch
 
-from awslambdaric.lambda_context import LambdaContext
+try:
+    from awslambdaric.lambda_context import LambdaContext
+except ImportError:
+    import pip
+    pip.main(['install', 'awslambdaric'])
 
-from samgis.io import lambda_helpers
+
+from samgis.io import wrappers_helpers
 from wrappers import lambda_wrapper
 from tests.local_tiles_http_server import LocalTilesHttpServer
 
 
-class TestAppFailures(unittest.TestCase):
+class TestLambdaApp(unittest.TestCase):
     @patch.object(time, "time")
     @patch.object(lambda_wrapper, "samexporter_predict")
     @patch.object(lambda_wrapper, "get_parsed_bbox_points")
@@ -141,7 +146,7 @@ class TestAppFailures(unittest.TestCase):
         print(f"types: response_200:{type(response_200)}, expected:{type(expected_response_200)}.")
         assert response_200 == expected_response_200
 
-    @patch.object(lambda_helpers, "get_url_tile")
+    @patch.object(wrappers_helpers, "get_url_tile")
     def test_lambda_handler_200_real_single_multi_point(self, get_url_tile_mocked):
         import xyzservices
         import shapely

wrappers/fastapi_wrapper.py

@@ -5,11 +5,16 @@ from fastapi import FastAPI, HTTPException, Request, status
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
+from pydantic import ValidationError
 
-from samgis import app_logger
+from samgis import PROJECT_ROOT_FOLDER
 from samgis.io.wrappers_helpers import get_parsed_bbox_points
 from samgis.utilities.type_hints import ApiRequestBody
+from samgis.utilities.fastapi_logger import setup_logging
+from samgis.prediction_api.predictors import samexporter_predict
 
+
+app_logger = setup_logging(debug=True)
 app = FastAPI()
 
 
@@ -49,10 +54,7 @@ async def health() -> JSONResponse:
 
 
 @app.post("/infer_samgis")
-def samgis(request_input: ApiRequestBody):
-    import subprocess
-
-    from samgis.prediction_api.predictors import samexporter_predict
+def infer_samgis(request_input: ApiRequestBody):
     app_logger.info("starting inference request...")
 
     try:
@@ -74,15 +76,17 @@ def samgis(request_input: ApiRequestBody):
             }
             return JSONResponse(status_code=200, content={"body": json.dumps(body)})
         except Exception as inference_exception:
+            import subprocess
             home_content = subprocess.run(
                 "ls -l /var/task", shell=True, universal_newlines=True, stdout=subprocess.PIPE
             )
             app_logger.error(f"/home/user ls -l: {home_content.stdout}.")
             app_logger.error(f"inference error:{inference_exception}.")
-            return HTTPException(status_code=500, detail="Internal server error on inference")
-    except Exception as generic_exception:
-        app_logger.error(f"generic error:{generic_exception}.")
-        return HTTPException(status_code=500, detail="Generic internal server error")
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Internal server error on inference")
+    except ValidationError as va1:
+        app_logger.error(f"validation error: {str(va1)}.")
+        raise ValidationError("Unprocessable Entity")
 
 
 @app.exception_handler(RequestValidationError)
@@ -90,7 +94,7 @@ async def request_validation_exception_handler(request: Request, exc: RequestVal
     app_logger.error(f"exception errors: {exc.errors()}.")
     app_logger.error(f"exception body: {exc.body}.")
     headers = request.headers.items()
-    app_logger.error(f'request header: {dict(headers)}.' )
+    app_logger.error(f'request header: {dict(headers)}.')
     params = request.query_params.items()
     app_logger.error(f'request query params: {dict(params)}.')
     return JSONResponse(
@@ -103,7 +107,7 @@ async def request_validation_exception_handler(request: Request, exc: RequestVal
 async def http_exception_handler(request: Request, exc: HTTPException) -> JSONResponse:
     app_logger.error(f"exception: {str(exc)}.")
     headers = request.headers.items()
-    app_logger.error(f'request header: {dict(headers)}.' )
+    app_logger.error(f'request header: {dict(headers)}.')
     params = request.query_params.items()
     app_logger.error(f'request query params: {dict(params)}.')
     return JSONResponse(
@@ -113,7 +117,7 @@ async def http_exception_handler(request: Request, exc: HTTPException) -> JSONRe
 
 
 # important: the index() function and the app.mount MUST be at the end
-app.mount("/", StaticFiles(directory="static/dist", html=True), name="static")
+app.mount("/", StaticFiles(directory=PROJECT_ROOT_FOLDER / "static" / "dist", html=True), name="static")
 
 
 @app.get("/")