fix tests

Author: pcrespov

services/web/server/src/simcore_service_webserver/products/_web_helpers.py

@@ -48,45 +48,60 @@ def _themed(dirname: str, template: str) -> Path:
     return path
 
 
-def _safe_get_current_product(request: web.Request) -> Product | None:
+def _get_current_product_or_none(request: web.Request) -> Product | None:
     try:
         product: Product = get_current_product(request)
         return product
     except KeyError:
         return None
 
 
-async def get_product_template_path(request: web.Request, filename: str) -> Path:
-    if product := _safe_get_current_product(request):
-        if template_name := product.get_template_name_for(filename):
-            template_dir: Path = request.app[APP_PRODUCTS_TEMPLATES_DIR_KEY]
-            template_path = template_dir / template_name
-            if not template_path.exists():
-                # cache
-                content = await _service.get_template_content(
-                    request.app, template_name=template_name
-                )
-                try:
-                    async with aiofiles.open(template_path, "w") as fh:
-                        await fh.write(content)
-                except Exception:
-                    # fails to write
-                    if template_path.exists():
-                        template_path.unlink()
-                    raise
-
-            return template_path
-
-        # check static resources under templates/
-        if (
-            template_path := _themed(f"templates/{product.name}", filename)
-        ) and template_path.exists():
-            return template_path
-
-    # If no product or template for product defined, we fall back to common templates
+async def _get_common_template_path(filename: str) -> Path:
     common_template = _themed("templates/common", filename)
     if not common_template.exists():
         msg = f"{filename} is not part of the templates/common"
         raise ValueError(msg)
-
     return common_template
+
+
+async def _cache_template_content(
+    request: web.Request, template_path: Path, template_name: str
+) -> None:
+    content = await _service.get_template_content(
+        request.app, template_name=template_name
+    )
+    try:
+        async with aiofiles.open(template_path, "w") as fh:
+            await fh.write(content)
+    except Exception:
+        if template_path.exists():
+            template_path.unlink()
+        raise
+
+
+async def _get_product_specific_template_path(
+    request: web.Request, product: Product, filename: str
+) -> Path | None:
+    if template_name := product.get_template_name_for(filename):
+        template_dir: Path = request.app[APP_PRODUCTS_TEMPLATES_DIR_KEY]
+        template_path = template_dir / template_name
+        if not template_path.exists():
+            await _cache_template_content(request, template_path, template_name)
+        return template_path
+
+    template_path = _themed(f"templates/{product.name}", filename)
+    if template_path.exists():
+        return template_path
+
+    return None
+
+
+async def get_product_template_path(request: web.Request, filename: str) -> Path:
+    if (product := _get_current_product_or_none(request)) and (
+        template_path := await _get_product_specific_template_path(
+            request, product, filename
+        )
+    ):
+        return template_path
+
+    return await _get_common_template_path(filename)

services/web/server/tests/unit/with_dbs/04/products/conftest.py

@@ -4,8 +4,15 @@
 
 
 import pytest
+from models_library.products import ProductName
 from pytest_simcore.helpers.monkeypatch_envs import setenvs_from_dict
 from pytest_simcore.helpers.typing_env import EnvVarsDict
+from simcore_service_webserver.constants import FRONTEND_APP_DEFAULT
+
+
+@pytest.fixture
+def default_product_name() -> ProductName:
+    return FRONTEND_APP_DEFAULT
 
 
 @pytest.fixture

services/web/server/tests/unit/with_dbs/04/products/test_products_service.py

@@ -6,26 +6,20 @@
 
 import pytest
 from aiohttp import web
-from aiohttp.test_utils import TestClient
+from aiohttp.test_utils import TestServer
 from models_library.products import ProductName
-from simcore_service_webserver.constants import FRONTEND_APP_DEFAULT
 from simcore_service_webserver.products import products_service
 from simcore_service_webserver.products._repository import ProductRepository
 from simcore_service_webserver.products.errors import ProductPriceNotDefinedError
 
 
 @pytest.fixture
 def app(
-    client: TestClient,
+    web_server: TestServer,
 ) -> web.Application:
-    # initialized app
-    assert client.app
-    return client.app
-
-
-@pytest.fixture
-def default_product_name() -> ProductName:
-    return FRONTEND_APP_DEFAULT
+    # app initialized and server running
+    assert web_server.app
+    return web_server.app
 
 
 async def test_get_product(app: web.Application, default_product_name: ProductName):

services/web/server/tests/unit/with_dbs/04/products/test_products_web.py

@@ -0,0 +1,160 @@
+# pylint: disable=redefined-outer-name
+# pylint: disable=unused-argument
+# pylint: disable=unused-variable
+# pylint: disable=too-many-arguments
+
+
+import pytest
+from aiohttp import web
+from aiohttp.test_utils import TestClient, make_mocked_request
+from common_library.json_serialization import json_dumps
+from models_library.products import ProductName
+from pytest_mock import MockerFixture, MockType
+from servicelib.rest_constants import X_PRODUCT_NAME_HEADER
+from simcore_service_webserver._meta import API_VTAG
+from simcore_service_webserver.products import products_web
+from simcore_service_webserver.products.plugin import setup_products
+
+
+@pytest.fixture
+def setup_products_mocked(mocker: MockerFixture) -> MockType:
+    def _wrap(app: web.Application):
+        setup_products(app)
+
+        # register test handlers
+        app.router.add_get(
+            f"/{API_VTAG}/test-helpers",
+            _test_helpers_handler,
+            name=_test_helpers_handler.__name__,
+        )
+        app.router.add_get(
+            f"/{API_VTAG}/test-product-template-helpers",
+            _test_product_template_handler,
+            name=_test_product_template_handler.__name__,
+        )
+
+        return True
+
+    return mocker.patch(
+        "simcore_service_webserver.application.setup_products",
+        autospec=True,
+        side_effect=_wrap,
+    )
+
+
+@pytest.fixture
+def client(
+    setup_products_mocked: MockType,  # keep before client fixture!
+    client: TestClient,
+) -> TestClient:
+    assert setup_products_mocked.called
+
+    assert client.app
+    assert client.app.router
+
+    registered_routes = {
+        route.resource.canonical
+        for route in client.app.router.routes()
+        if route.resource
+    }
+    assert f"/{API_VTAG}/test-helpers" in registered_routes
+
+    return client
+
+
+async def _test_helpers_handler(request: web.Request):
+    product_name = products_web.get_product_name(request)
+    current_product = products_web.get_current_product(request)
+
+    assert current_product.name == product_name
+
+    credit_price_info = await products_web.get_current_product_credit_price_info(
+        request
+    )
+    assert credit_price_info is None
+
+    return web.json_response(
+        json_dumps(
+            {
+                "current_product": current_product,
+                "get_producproduct_namet_name": product_name,
+                "credit_price_info": credit_price_info,
+            }
+        )
+    )
+
+
+async def test_request_helpers(client: TestClient, default_product_name: ProductName):
+
+    resp = await client.get(
+        f"/{API_VTAG}/test-helpers",
+        headers={X_PRODUCT_NAME_HEADER: default_product_name},
+    )
+
+    assert resp.ok, f"Got {await resp.text()}"
+
+    got = await resp.json()
+    assert got["current_product"] == default_product_name
+
+
+async def _test_product_template_handler(request: web.Request):
+    product_name = products_web.get_product_name(request)
+
+    # if no product, it should return common
+
+    # if no template for product, it should return common
+    # template/common/close_account.jinja2"
+    template_path = await products_web.get_product_template_path(
+        request, filename="close_account.jinja2"
+    )
+    assert template_path.exists()
+    assert template_path.name == "close_account.jinja2"
+    assert "common/" in f"{template_path.resolve().absolute()}"
+
+    # if specific template, it gets and caches in file
+    # "templates/osparc/registration_email.jinja2"
+    template_path = await products_web.get_product_template_path(
+        request, filename="registration_email.jinja2"
+    )
+    assert template_path.exists()
+    assert template_path.name == "registration_email.jinja2"
+    assert f"{product_name}/" in f"{template_path.resolve().absolute()}"
+
+    # get again and should use file
+
+    for _ in range(2):
+        got = await products_web.get_product_template_path(
+            request, filename="registration_email.jinja2"
+        )
+        assert got == template_path
+
+    path = await products_web.get_product_template_path(
+        request, filename="invalid-template-name.jinja"
+    )
+    assert path
+    return web.json_response()
+
+
+async def test_product_template_helpers(
+    client: TestClient, default_product_name: ProductName
+):
+
+    resp = await client.get(
+        f"/{API_VTAG}/test-product-template-helpers",
+        headers={X_PRODUCT_NAME_HEADER: default_product_name},
+    )
+
+    assert resp.ok, f"Got {await resp.text()}"
+
+
+async def test_get_product_template_path_without_product():
+    fake_request = make_mocked_request("GET", "/fake", app=web.Application())
+
+    # if no product, it should return common
+    template_path = await products_web.get_product_template_path(
+        fake_request, filename="close_account.jinja2"
+    )
+
+    assert template_path.exists()
+    assert template_path.name == "close_account.jinja2"
+    assert "common/" in f"{template_path.resolve().absolute()}"