bisslog-flask 0.0.2__tar.gz → 0.0.3__tar.gz

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bisslog_flask
-Version: 0.0.2
+Version: 0.0.3
 Summary: It is an extension of the bisslog library to support processes with flask
 Author-email: Darwin Stiven Herrera Cartagena <darwinsherrerac@gmail.com>
 Project-URL: Homepage, https://github.com/darwinhc/bisslog-flask
@@ -10,13 +10,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: bisslog>=0.0.7
-Requires-Dist: bisslog-schema>=0.0.6
+Requires-Dist: bisslog>=0.0.9
+Requires-Dist: bisslog-schema>=0.0.10
 Requires-Dist: flask
 Provides-Extra: websocket
 Requires-Dist: flask-socketio; extra == "websocket"
 Provides-Extra: cors
 Requires-Dist: flask-cors>=6.0.0; extra == "cors"
+Provides-Extra: async
+Requires-Dist: Flask[async]>=2.2; extra == "async"
 Dynamic: license-file
 
 # bisslog-flask

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask/builder/builder_flask_app_manager.py

@@ -8,6 +8,7 @@ configuration, and runtime setup.
 The generated code is returned as a full Python script and can be written to a file (e.g.,
 `flask_app.py`).
 """
+
 from typing import Optional, Callable
 import json
 
@@ -17,6 +18,7 @@ from bisslog_schema.schema import UseCaseInfo, TriggerHttp, TriggerWebsocket
 from bisslog_schema.setup import get_setup_metadata
 from bisslog_schema.use_case_code_inspector.use_case_code_metadata import UseCaseCodeInfo, \
     UseCaseCodeInfoClass, UseCaseCodeInfoObject
+
 from .static_python_construct_data import StaticPythonConstructData
 
 
@@ -147,6 +149,9 @@ if "JWT_SECRET_KEY" in os.environ:
         StaticPythonConstructData
             The generated code for the HTTP trigger.
         """
+        imports = {
+            "flask": {"jsonify"}
+        }
         starting_build = ""
         mapper_code_lines = []
         if trigger_info.mapper is not None:
@@ -155,7 +160,7 @@ if "JWT_SECRET_KEY" in os.environ:
                                f"base={json.dumps(trigger_info.mapper)})")
             mapper_code_lines.append(f"""
     res_map = {mapper_name}.map({{
-        "path_query": request.view_args or {{}},
+        "path_query": route_vars,
         "body": request.get_json(silent=True) or {{}},
         "params": request.args.to_dict(),
         "headers": request.headers,
@@ -166,20 +171,33 @@ if "JWT_SECRET_KEY" in os.environ:
 
         lines = [
             f'@app.route("{flask_path}", methods=["{method}"])',
-            f'def {handler_name}():',
         ]
+
+        if use_case_code_info.is_coroutine:
+            lines.append(f"async def {handler_name}(**route_vars):")
+        else:
+            lines.append(f"def {handler_name}(**route_vars):")
+
         if not mapper_code_lines:
             lines.append("    kwargs = {}")
-            lines.append("    kwargs.update(request.view_args or {})")
+            lines.append("    kwargs.update(route_vars)")
             lines.append("    kwargs.update(request.get_json(silent=True) or {})")
             lines.append("    kwargs.update(request.args.to_dict())")
             lines.append("    kwargs.update(dict(request.headers))")
-            lines.append(f"    return {uc_callable}(**kwargs)\n")
+            var_to_unpack = "kwargs"
         else:
             lines.extend(mapper_code_lines)
-            lines.append(f'    return {uc_callable}(**res_map)\n')
+            var_to_unpack = "res_map"
+
+        if use_case_code_info.is_coroutine:
+            lines.append(f'    result = await {uc_callable}(**{var_to_unpack})')
+        else:
+            lines.append(f'    result = {uc_callable}(**{var_to_unpack})\n')
+
+        lines.append('    return jsonify(result)\n')
 
-        return StaticPythonConstructData(build=starting_build, body="\n".join(lines))
+        return StaticPythonConstructData(build=starting_build,
+                                         body="\n".join(lines), importing=imports)
 
     @staticmethod
     def _generate_use_case_code_websocket_trigger(
@@ -217,7 +235,7 @@ if "JWT_SECRET_KEY" in os.environ:
         imports = {
             use_case_code_info.module: {use_case_code_info.name},
             "flask_sock": {"Sock"},
-            "flask": {"request"},
+            "flask": {"request", "jsonify"},
             "bisslog.utils.mapping": {"Mapper"},
             "json": None
         }

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask/cli/__init__.py

@@ -1,10 +1,11 @@
+"""Command-line interface for the `bisslog_flask` package."""
+import argparse
 import os
 import sys
-import argparse
 import traceback
 
-from .commands.run import run
 from .commands.build import build_boiler_plate_flask
+from .commands.run import run
 
 
 def main():
@@ -62,7 +63,8 @@ def main():
     build_parser.add_argument("--encoding", type=str, default="utf-8",
                               help="File encoding (default: utf-8).")
     build_parser.add_argument("--target-filename", type=str, default="flask_app.py",
-                              help="Filename to write the generated boilerplate (default: flask_app.py)")
+                              help="Filename to write the generated "
+                                   "boilerplate (default: flask_app.py)")
 
     args = parser.parse_args()
 
@@ -82,7 +84,7 @@ def main():
                 encoding=args.encoding,
                 target_filename=args.target_filename
             )
-    except Exception as e:
+    except Exception as e:  # pylint: disable=broad-except
         traceback.print_exc()
         print(e)
         sys.exit(1)

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask/cli/commands/build.py

@@ -10,8 +10,10 @@ The generated code supports HTTP and WebSocket routes, environment-based securit
 configuration, and respects the Bisslog runtime setup defined via decorators.
 """
 from typing import Optional
+
 from ...builder.builder_flask_app_manager import bisslog_flask_builder
 
+
 def build_boiler_plate_flask(
         metadata_file: Optional[str] = None,
         use_cases_folder_path: Optional[str] = None,

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask/cli/commands/run.py

@@ -18,7 +18,7 @@ def run(metadata_file: Optional[str] = None,
         secret_key: Optional[str] = None,
         jwt_secret_key: Optional[str] = None):
     """
-    Run a Flask application using metadata and use case source.
+    Run a Flask application using metadata and use-case source.
 
     This function creates and runs a Flask app configured through the
     BisslogFlask integration layer. It loads metadata definitions,

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask/initializer/bisslog_flask_http_resolver.py

@@ -16,10 +16,12 @@ Dependencies
 - bisslog_schema
 - bisslog.utils.mapping
 """
+import inspect
 from copy import deepcopy
-from typing import Callable, Optional, Dict
+from typing import Callable, Optional, Dict, Union, Awaitable, Any
 
 from flask import Flask, request, jsonify
+
 try:
     from flask_cors import cross_origin
 except ImportError:
@@ -82,10 +84,10 @@ class BisslogFlaskHttpResolver(BisslogFlaskResolver):
 
     @staticmethod
     def _use_case_factory(
-            use_case_name: str,
-            fn: Callable,
-            mapper: Optional[Dict[str, str]] = None,
-            trigger: Optional[TriggerHttp] = None
+        use_case_name: str,
+        fn: Callable,
+        mapper: Optional[Dict[str, str]] = None,
+        trigger: Optional[TriggerHttp] = None
     ):
         """
         Factory to produce a Flask view function with optional mapping and CORS.
@@ -109,10 +111,49 @@ class BisslogFlaskHttpResolver(BisslogFlaskResolver):
         use_case_fn_copy = deepcopy(fn)
         __mapper__ = Mapper(name=f"Mapper {use_case_name}", base=mapper) if mapper else None
 
-        def uc(*args, **kwargs):
-            return BisslogFlaskHttpResolver._lambda_fn(
-                *args, fn=use_case_fn_copy, __mapper__=__mapper__, **kwargs
-            )
+        is_async = (
+            inspect.iscoroutinefunction(fn)
+            or inspect.iscoroutinefunction(getattr(fn, "__call__", None))
+        )
+
+        if is_async:
+            async def uc(*args, **kwargs):
+                if __mapper__ is None:
+                    more_kwargs = {}
+                    if request.method.lower() != "get":
+                        more_kwargs.update(request.get_json(silent=True) or {})
+                    res = await use_case_fn_copy(*args, **kwargs, **more_kwargs)
+                    return jsonify(res)
+
+                res_map = __mapper__.map({
+                    "path_query": request.view_args or {},
+                    "body": request.get_json(silent=True) or {},
+                    "params": request.args.to_dict(),
+                    "headers": request.headers,
+                })
+                res = await use_case_fn_copy(**res_map)
+                return jsonify(res)
+
+            view = uc
+        else:
+            def uc(*args, **kwargs):
+                if __mapper__ is None:
+                    more_kwargs = {}
+                    if request.method.lower() != "get":
+                        more_kwargs.update(request.get_json(silent=True) or {})
+                    res = use_case_fn_copy(*args, **kwargs, **more_kwargs)
+                    return jsonify(res)
+
+                res_map = __mapper__.map({
+                    "path_query": request.view_args or {},
+                    "body": request.get_json(silent=True) or {},
+                    "params": request.args.to_dict(),
+                    "headers": request.headers,
+                })
+                res = use_case_fn_copy(**res_map)
+                return jsonify(res)
+
+            view = uc
 
         # Apply CORS dynamically if allowed
         if trigger and trigger.allow_cors:
@@ -124,13 +165,13 @@ class BisslogFlaskHttpResolver(BisslogFlaskResolver):
                 "allow_headers": ["Content-Type", "Authorization"],
                 "supports_credentials": True
             }
-            return cross_origin(**cors_kwargs)(uc)
+            return cross_origin(**cors_kwargs)(view)
 
-        return uc
+        return view
 
     @classmethod
     def _add_use_case(cls, app: Flask, use_case_info: UseCaseInfo, trigger: TriggerInfo,
-                      use_case_function):
+                      use_case_function: Union[Callable[..., Any], Callable[..., Awaitable[Any]]]):
         """
         Adds an HTTP endpoint to the Flask app for a given use case.
 

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask/initializer/bisslog_flask_resolver.py

@@ -9,7 +9,6 @@ from abc import ABC, abstractmethod
 from typing import Callable
 
 from bisslog_schema.schema import UseCaseInfo, TriggerInfo
-
 from flask import Flask
 
 

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask/initializer/bisslog_flask_ws_resolver.py

@@ -5,7 +5,9 @@ This module defines the `BisslogFlaskWebSocketResolver` class, which dynamically
 WebSocket-based use case triggers in a Flask app. The class uses metadata definitions to
 configure event routes (via `route_key`) and binds them to corresponding use case functions.
 """
+import inspect
 from typing import Callable
+
 from flask import Flask, request
 
 try:
@@ -64,13 +66,27 @@ class BisslogFlaskWebSocketResolver(BisslogFlaskResolver):
             base=trigger_info.options.mapper
         ) if trigger_info.options.mapper else None
 
-        @socket_io_obj.on(route_key)
-        def on_event(data):
-            mapped_data = mapper.map({
-                "route_key": route_key,
-                "connection_id": request.sid,
-                "body": data,
-                "headers": dict(request.headers)
-            }) if mapper else data
+        is_async = inspect.iscoroutinefunction(use_case_callable)
+
+        if is_async:
+            @socket_io_obj.on(route_key)
+            async def on_event(data):
+                mapped_data = mapper.map({
+                    "route_key": route_key,
+                    "connection_id": request.sid,
+                    "body": data,
+                    "headers": dict(request.headers)
+                }) if mapper else data
+
+                return await use_case_callable(**mapped_data) if mapper else use_case_callable(data)
+        else:
+            @socket_io_obj.on(route_key)
+            def on_event(data):
+                mapped_data = mapper.map({
+                    "route_key": route_key,
+                    "connection_id": request.sid,
+                    "body": data,
+                    "headers": dict(request.headers)
+                }) if mapper else data
 
-            return use_case_callable(**mapped_data) if mapper else use_case_callable(data)
+                return use_case_callable(**mapped_data) if mapper else use_case_callable(data)

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bisslog_flask
-Version: 0.0.2
+Version: 0.0.3
 Summary: It is an extension of the bisslog library to support processes with flask
 Author-email: Darwin Stiven Herrera Cartagena <darwinsherrerac@gmail.com>
 Project-URL: Homepage, https://github.com/darwinhc/bisslog-flask
@@ -10,13 +10,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: bisslog>=0.0.7
-Requires-Dist: bisslog-schema>=0.0.6
+Requires-Dist: bisslog>=0.0.9
+Requires-Dist: bisslog-schema>=0.0.10
 Requires-Dist: flask
 Provides-Extra: websocket
 Requires-Dist: flask-socketio; extra == "websocket"
 Provides-Extra: cors
 Requires-Dist: flask-cors>=6.0.0; extra == "cors"
+Provides-Extra: async
+Requires-Dist: Flask[async]>=2.2; extra == "async"
 Dynamic: license-file
 
 # bisslog-flask

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask.egg-info/SOURCES.txt

@@ -28,10 +28,12 @@ bisslog_flask/initializer/bisslog_flask_ws_resolver.py
 bisslog_flask/initializer/init_flask_app_manager.py
 bisslog_flask/socket_helper/__init__.py
 bisslog_flask/socket_helper/socket_helper.py
+requirements/requirements-async.txt
 requirements/requirements-flask-optional.txt
 tests/__init__.py
 tests/unit/__init__.py
 tests/unit/test_http_resolver.py
+tests/unit/test_http_resolver_lambda_fn.py
 tests/unit/test_init_app_manager.py
 tests/unit/test_ws_resolver.py
 tests/unit/builder/__init__.py

bisslog_flask-0.0.3/bisslog_flask.egg-info/requires.txt

@@ -0,0 +1,12 @@
+bisslog>=0.0.9
+bisslog-schema>=0.0.10
+flask
+
+[async]
+Flask[async]>=2.2
+
+[cors]
+flask-cors>=6.0.0
+
+[websocket]
+flask-socketio

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/pyproject.toml

@@ -12,8 +12,8 @@ authors = [
 ]
 requires-python = ">=3.7"
 dependencies = [
-    "bisslog>=0.0.7",
-    "bisslog-schema>=0.0.6",
+    "bisslog>=0.0.9",
+    "bisslog-schema>=0.0.10",
     "flask"
 ]
 classifiers = [
@@ -28,6 +28,7 @@ Homepage = "https://github.com/darwinhc/bisslog-flask"
 [project.optional-dependencies]
 websocket = ["flask-socketio"]
 cors = ["flask-cors>=6.0.0"]
+async = ["Flask[async]>=2.2"]
 
 [project.scripts]
 bisslog_flask = "bisslog_flask.cli:main"

bisslog_flask-0.0.3/requirements/requirements-async.txt

@@ -0,0 +1 @@
+Flask[async]>=2.2

bisslog_flask-0.0.3/requirements.txt

@@ -0,0 +1,3 @@
+bisslog>=0.0.7
+bisslog-schema>=0.0.9
+flask

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/tests/unit/builder/test_builder_flask_app_manager.py

@@ -1,15 +1,15 @@
 # test_builder_flask_app_manager.py
 
-import pytest
-import json
 from unittest.mock import patch, MagicMock
-from bisslog_flask.builder.builder_flask_app_manager import BuilderFlaskAppManager
-from bisslog_flask.builder.static_python_construct_data import StaticPythonConstructData
+
+import pytest
 from bisslog_schema.schema import TriggerHttp, TriggerWebsocket
 from bisslog_schema.use_case_code_inspector.use_case_code_metadata import (
     UseCaseCodeInfoClass, UseCaseCodeInfoObject, UseCaseCodeInfo
 )
 
+from bisslog_flask.builder.builder_flask_app_manager import BuilderFlaskAppManager
+
 
 @pytest.mark.parametrize("n_params,expected", [
     (0, "setup_func()"),
@@ -41,14 +41,16 @@ def test_get_bisslog_setup_none(mock_get_setup):
 
 
 def test_generate_use_case_code_build_class():
-    uc = UseCaseCodeInfoClass(name="my_uc", docs="", module="mymodule", class_name="MyClass")
+    uc = UseCaseCodeInfoClass(name="my_uc", docs="", module="mymodule", class_name="MyClass",
+                              is_coroutine=False)
     name, result = BuilderFlaskAppManager._generate_use_case_code_build(uc)
     assert name == "my_uc_uc"
     assert "MyClass()" in result.build
 
 
 def test_generate_use_case_code_build_object():
-    uc = UseCaseCodeInfoObject(name="my_uc", docs="", module="mymodule", var_name="uc_var")
+    uc = UseCaseCodeInfoObject(name="my_uc", docs="", module="mymodule", var_name="uc_var",
+                               is_coroutine=False)
     name, result = BuilderFlaskAppManager._generate_use_case_code_build(uc)
     assert name == "uc_var"
     assert result.build == ""
@@ -57,22 +59,24 @@ def test_generate_use_case_code_build_object():
 def test_generate_use_case_code_build_invalid_type():
     with pytest.raises(ValueError):
         class Invalid(UseCaseCodeInfo): pass
-        BuilderFlaskAppManager._generate_use_case_code_build(Invalid("x", "", ""))
+        BuilderFlaskAppManager._generate_use_case_code_build(Invalid("x", "", "", False))
 
 
 def test_generate_use_case_code_http_trigger_without_mapper():
     trigger = TriggerHttp(path="/hello", method="POST", mapper=None)
-    uc_info = UseCaseCodeInfoClass(name="myuc", docs="", module="mymod", class_name="UCClass")
+    uc_info = UseCaseCodeInfoClass(name="myuc", docs="", module="mymod", class_name="UCClass",
+                                   is_coroutine=False)
     result = BuilderFlaskAppManager._generate_use_case_code_http_trigger(
         "my_uc", "my_uc_uc", uc_info, trigger, 1)
-    assert "def my_uc_handler_1()" in result.body
+    assert "def my_uc_handler_1(**route_vars)" in result.body
     assert "my_uc_uc(**kwargs)" in result.body
     assert "request.get_json" in result.body
 
 
 def test_generate_use_case_code_http_trigger_with_mapper():
     trigger = TriggerHttp(path="/hi", method="GET", mapper={"body": {"x": "int"}})
-    uc_info = UseCaseCodeInfoClass(name="myuc", docs="", module="mymod", class_name="UCClass")
+    uc_info = UseCaseCodeInfoClass(name="myuc", docs="", module="mymod", class_name="UCClass",
+                                   is_coroutine=False)
     result = BuilderFlaskAppManager._generate_use_case_code_http_trigger(
         "my_uc", "my_uc_uc", uc_info, trigger, 2)
     assert "res_map" in result.body
@@ -81,7 +85,8 @@ def test_generate_use_case_code_http_trigger_with_mapper():
 
 def test_generate_use_case_code_websocket_trigger_with_mapper():
     trigger = TriggerWebsocket(route_key="room", mapper={"body": {"msg": "str"}})
-    uc_info = UseCaseCodeInfoObject(name="ws_uc", docs="", module="wsmod", var_name="ws_callable")
+    uc_info = UseCaseCodeInfoObject(name="ws_uc", docs="", module="wsmod", var_name="ws_callable",
+                                    is_coroutine=False)
     result = BuilderFlaskAppManager._generate_use_case_code_websocket_trigger(
         "chat", "ws_callable", uc_info, trigger, 0)
     assert "res_map = chat_ws_mapper_0.map" in result.build
@@ -91,7 +96,8 @@ def test_generate_use_case_code_websocket_trigger_with_mapper():
 
 def test_generate_use_case_code_websocket_trigger_without_mapper():
     trigger = TriggerWebsocket(route_key=None, mapper=None)
-    uc_info = UseCaseCodeInfoObject(name="ws_uc", docs="", module="wsmod", var_name="ws_callable")
+    uc_info = UseCaseCodeInfoObject(name="ws_uc", docs="", module="wsmod", var_name="ws_callable",
+                                    is_coroutine=False)
     result = BuilderFlaskAppManager._generate_use_case_code_websocket_trigger(
         "chat", "ws_callable", uc_info, trigger, 1)
     assert "payload = json.loads(data)" in result.build

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/tests/unit/builder/test_builder_full.py

@@ -1,14 +1,15 @@
 # test_builder_flask_app_manager_call.py
 
-import pytest
 from unittest.mock import patch, MagicMock
-from bisslog_flask.builder.builder_flask_app_manager import BuilderFlaskAppManager
-from bisslog_flask.builder.static_python_construct_data import StaticPythonConstructData
+
 from bisslog_schema.schema import TriggerHttp, TriggerWebsocket, UseCaseInfo
 from bisslog_schema.use_case_code_inspector.use_case_code_metadata import (
-    UseCaseCodeInfoClass, UseCaseCodeInfoObject
+    UseCaseCodeInfoClass
 )
 
+from bisslog_flask.builder.builder_flask_app_manager import BuilderFlaskAppManager
+from bisslog_flask.builder.static_python_construct_data import StaticPythonConstructData
+
 
 @patch("bisslog_flask.builder.builder_flask_app_manager.read_full_service_metadata")
 @patch.object(BuilderFlaskAppManager, "_get_bisslog_setup")
@@ -41,7 +42,8 @@ def test_call_generates_complete_flask_code(
 
     discovered_use_cases = {
         "my_use_case": UseCaseCodeInfoClass(
-            name="my_use_case", docs=None, module="uc_module", class_name="UseCase"
+            name="my_use_case", docs=None, module="uc_module", class_name="UseCase",
+            is_coroutine=False
         )
     }
 

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/tests/unit/cli/test_build.py

@@ -1,8 +1,6 @@
-# test_cli_build_boilerplate.py
-
-import builtins
-import pytest
+"""Tests for the build command."""
 from unittest.mock import patch, mock_open
+
 from bisslog_flask.cli.commands.build import build_boiler_plate_flask
 
 

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/tests/unit/cli/test_cli.py

@@ -1,7 +1,9 @@
-import pytest
-import sys
 import os
+import sys
 from unittest.mock import patch, MagicMock
+
+import pytest
+
 from bisslog_flask import cli as cli_module
 
 

bisslog_flask-0.0.3/tests/unit/test_http_resolver.py

@@ -0,0 +1,268 @@
+"""Tests for bisslog_flask.initializer.bisslog_flask_http_resolver."""
+
+from __future__ import annotations
+
+import asyncio
+from unittest.mock import Mock
+
+import pytest
+import flask
+from flask import Flask
+
+from bisslog_schema.schema import UseCaseInfo, TriggerHttp, TriggerInfo
+from bisslog_schema.schema.triggers.trigger_mappable import TriggerMappable
+
+from bisslog_flask.initializer.bisslog_flask_http_resolver import BisslogFlaskHttpResolver
+
+
+pytestmark = pytest.mark.skipif(
+    tuple(map(int, flask.__version__.split(".")[:2])) < (2, 2),
+    reason="Async views need Flask >= 2.2",
+)
+
+@pytest.fixture
+def flask_app():
+    app = Flask(__name__)
+    return app
+
+
+@pytest.fixture
+def resolver():
+    return BisslogFlaskHttpResolver()
+
+
+def make_uc_info(key="uc"):
+    return UseCaseInfo(
+        keyname=key, name=key, description="", type="sync", triggers=[]
+    )
+
+
+
+def test_register_get_route_without_mapper(flask_app, resolver):
+    def mock_uc():
+        return {"status": "ok"}
+
+    info = make_uc_info("test_uc")
+    trig_http = TriggerHttp(method="GET", path="/test", allow_cors=False)
+    trig = TriggerInfo(keyname="t", type="http", options=trig_http)
+
+    resolver(flask_app, info, trig, mock_uc)
+
+    client = flask_app.test_client()
+    r = client.get("/test")
+
+    assert r.status_code == 200
+    assert r.json == {"status": "ok"}
+
+
+def test_register_post_route_with_json(flask_app, resolver):
+    def mock_uc(**data):
+        return {"echo": data.get("name")}
+
+    info = make_uc_info("echo_uc")
+    trig_http = TriggerHttp(method="POST", path="/echo", allow_cors=False)
+    trig = TriggerInfo(keyname="t", type="http", options=trig_http)
+
+    resolver(flask_app, info, trig, mock_uc)
+
+    client = flask_app.test_client()
+    r = client.post("/echo", json={"name": "ChatGPT"})
+
+    assert r.status_code == 200
+    assert r.json == {"echo": "ChatGPT"}
+
+
+def test_register_post_route_without_body_ok(flask_app, resolver):
+
+    def mock_uc(**kwargs):
+        return {"kwargs": kwargs}
+
+    info = make_uc_info("no_body")
+    trig_http = TriggerHttp(method="POST", path="/no-body", allow_cors=False)
+    trig = TriggerInfo(keyname="t", type="http", options=trig_http)
+
+    resolver(flask_app, info, trig, mock_uc)
+
+    client = flask_app.test_client()
+    r = client.post("/no-body")
+
+    assert r.status_code == 200
+    assert r.json == {"kwargs": {}}
+
+
+
+def test_register_post_route_with_mapper(flask_app, resolver):
+    def mock_uc(*, a=None, b=None, c=None, d=None, e=None, f=None):
+        return {"a": a, "b": b, "c": c, "d": d, "e": e, "f": f}
+
+    info = make_uc_info("echo_uc")
+    mapper = {
+        "body.algo1": "a",
+        "body.algo2": "b",
+        "path_query.algo3": "c",
+        "headers.algo4": "d",
+        "params.algo5": "e",
+        "params.algo6": "f",
+    }
+    trig_http = TriggerHttp(
+        method="POST",
+        path="/echo/{algo3}",
+        allow_cors=False,
+        mapper=mapper,
+    )
+    assert isinstance(trig_http, TriggerMappable)
+    trig = TriggerInfo(keyname="t", type="http", options=trig_http)
+
+    resolver(flask_app, info, trig, mock_uc)
+
+    client = flask_app.test_client()
+    r = client.post(
+        "/echo/something",
+        json={"algo1": 2356, "algo2": "casa"},
+        headers=[("algo4", "prueba4")],
+        query_string={"algo5": 7554, "algo6": "prueba6"},
+    )
+
+    assert r.status_code == 200
+    payload = r.get_json()
+    assert payload["a"] == 2356
+    assert payload["b"] == "casa"
+    assert payload["c"] == "something"
+    assert payload["d"] == "prueba4"
+    assert payload["e"] == "7554"
+    assert payload["f"] == "prueba6"
+
+
+
+def test_register_async_function(flask_app, resolver):
+    async def mock_uc(**data):
+        await asyncio.sleep(0)
+        return {"ok": True, "data": data}
+
+    info = make_uc_info("async_fn")
+    trig_http = TriggerHttp(method="POST", path="/async-fn", allow_cors=False)
+    trig = TriggerInfo(keyname="t", type="http", options=trig_http)
+
+    resolver(flask_app, info, trig, mock_uc)
+
+    client = flask_app.test_client()
+    r = client.post("/async-fn", json={"a": 1})
+    assert r.status_code == 200
+    assert r.json == {"ok": True, "data": {"a": 1}}
+
+
+def test_register_async_callable_object(flask_app, resolver):
+    class UC:
+        async def __call__(self, *, a=None):
+            await asyncio.sleep(0)
+            return {"a": a}
+
+    info = make_uc_info("async_obj")
+    trig_http = TriggerHttp(
+        method="POST",
+        path="/async-obj",
+        allow_cors=False,
+        mapper={"body.a": "a"},
+    )
+    trig = TriggerInfo(keyname="t", type="http", options=trig_http)
+
+    resolver(flask_app, info, trig, UC())
+
+    client = flask_app.test_client()
+    r = client.post("/async-obj", json={"a": 7})
+    assert r.status_code == 200
+    assert r.json == {"a": 7}
+
+
+
+def test_invalid_trigger_type_is_ignored(flask_app, resolver):
+    trig = TriggerInfo(keyname="invalid", type="websocket", options=Mock())
+    mock_uc = Mock()
+    info = make_uc_info("invalid_uc")
+
+    resolver(flask_app, info, trig, mock_uc)
+
+    client = flask_app.test_client()
+    r = client.get("/invalid")
+    assert r.status_code == 404
+
+
+def test_endpoint_name_contains_key_and_path(flask_app, resolver):
+    def mock_uc(id):
+        return {"ok": 1}
+
+    info = make_uc_info("keyX")
+    trig_http = TriggerHttp(method="GET", path="/items/{id}", allow_cors=False)
+    trig = TriggerInfo(keyname="t", type="http", options=trig_http)
+
+    resolver(flask_app, info, trig, mock_uc)
+
+
+    expected_rule = "keyX " + "/items/<id>"
+    found = any(r.rule == "/items/<id>" and r.endpoint == expected_rule for r in flask_app.url_map.iter_rules())
+    assert found
+
+    client = flask_app.test_client()
+    r = client.get("/items/42")
+    assert r.status_code == 200
+    assert r.json == {"ok": 1}
+
+
+
+def test_cors_applied_when_allowed(monkeypatch, flask_app, resolver):
+
+    captured = {}
+
+    def fake_cross_origin(**kwargs):
+        captured.update(kwargs)
+        def decorator(fn):
+            return fn
+        return decorator
+
+
+    import bisslog_flask.initializer.bisslog_flask_http_resolver as mod
+    monkeypatch.setattr(mod, "cross_origin", fake_cross_origin, raising=True)
+
+    def mock_uc():
+        return {"ok": True}
+
+    info = make_uc_info("cors_uc")
+    trig_http = TriggerHttp(
+        method="GET",
+        path="/cors",
+        allow_cors=True,
+        allowed_origins=["https://a.com", "https://b.com"],
+    )
+    trig = TriggerInfo(keyname="t", type="http", options=trig_http)
+
+    resolver(flask_app, info, trig, mock_uc)
+
+
+    assert captured["origins"] == ["https://a.com", "https://b.com"]
+    assert captured["methods"] == ["GET"]
+    assert captured["supports_credentials"] is True
+    assert "allow_headers" in captured
+
+    client = flask_app.test_client()
+    r = client.get("/cors")
+    assert r.status_code == 200
+    assert r.json == {"ok": True}
+
+
+def test_cors_raises_when_flask_cors_missing(monkeypatch, flask_app):
+
+    import bisslog_flask.initializer.bisslog_flask_http_resolver as mod
+    monkeypatch.setattr(mod, "cross_origin", None, raising=True)
+
+    resolver = BisslogFlaskHttpResolver()
+
+    def mock_uc():
+        return {"ok": True}
+
+    info = make_uc_info("cors_missing")
+    trig_http = TriggerHttp(method="GET", path="/cors-missing", allow_cors=True)
+    trig = TriggerInfo(keyname="t", type="http", options=trig_http)
+
+    with pytest.raises(ImportError):
+
+        resolver(flask_app, info, trig, mock_uc)

bisslog_flask-0.0.3/tests/unit/test_http_resolver_lambda_fn.py

@@ -0,0 +1,93 @@
+
+from __future__ import annotations
+
+from flask import Flask
+from unittest.mock import Mock
+import flask
+import pytest
+
+from bisslog_flask.initializer.bisslog_flask_http_resolver import BisslogFlaskHttpResolver
+
+pytestmark = pytest.mark.skipif(
+    tuple(map(int, flask.__version__.split(".")[:2])) < (2, 2),
+    reason="Async views need Flask >= 2.2",
+)
+
+@pytest.fixture
+def app():
+    return Flask(__name__)
+
+
+def test_lambda_fn_without_mapper_get_does_not_include_body(app):
+    called = {}
+
+    def uc(**kwargs):
+        called.update(kwargs)
+        return {"ok": True}
+
+    with app.test_request_context("/items/42?q=abc", method="GET"):
+        resp = BisslogFlaskHttpResolver._lambda_fn(fn=uc, __mapper__=None, id="42")
+        assert resp.mimetype == "application/json"
+        assert resp.get_json() == {"ok": True}
+
+    assert called == {"id": "42"}
+
+
+def test_lambda_fn_without_mapper_post_includes_body(app):
+    captured = {}
+
+    def uc(**kwargs):
+        captured.update(kwargs)
+        return {"received": kwargs}
+
+    with app.test_request_context("/echo", method="POST", json={"a": 1, "b": "x"}):
+        resp = BisslogFlaskHttpResolver._lambda_fn(fn=uc, __mapper__=None)
+        assert resp.status_code == 200
+        assert resp.get_json() == {"received": {"a": 1, "b": "x"}}
+
+    assert captured == {"a": 1, "b": "x"}
+
+
+def test_lambda_fn_with_mapper_maps_all_parts_and_calls_uc(app):
+    class FakeMapper:
+        def __init__(self):
+            self.last_input = None
+        def map(self, payload):
+            self.last_input = payload
+            return {"x": 99}
+
+    mapper = FakeMapper()
+    uc = Mock(return_value={"ok": True})
+
+    with app.test_request_context(
+        "/do/7?key=vv",
+        method="POST",
+        json={"foo": 1},
+        headers={"X-Test": "hdr"},
+    ):
+        from flask import request
+        request.view_args = {"id": "7"}
+
+        resp = BisslogFlaskHttpResolver._lambda_fn(fn=uc, __mapper__=mapper)
+
+        assert resp.status_code == 200
+        assert resp.get_json() == {"ok": True}
+
+    inp = mapper.last_input
+    assert set(inp.keys()) == {"path_query", "body", "params", "headers"}
+    assert inp["path_query"] == {"id": "7"}
+    assert inp["body"] == {"foo": 1}
+    assert inp["params"] == {"key": "vv"}
+    assert inp["headers"].get("X-Test") == "hdr"
+
+    uc.assert_called_once_with(x=99)
+
+
+def test_lambda_fn_returns_json_response_type(app):
+    def uc():
+        return {"hello": "world"}
+
+    with app.test_request_context("/hi", method="GET"):
+        resp = BisslogFlaskHttpResolver._lambda_fn(fn=uc, __mapper__=None)
+        assert resp.mimetype == "application/json"
+        assert resp.get_json() == {"hello": "world"}

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/tests/unit/test_init_app_manager.py

@@ -1,13 +1,14 @@
-import pytest
-from flask import Flask
+from types import SimpleNamespace
 from unittest.mock import MagicMock
 
-from bisslog_flask.initializer.init_flask_app_manager import InitFlaskAppManager
+import pytest
 from bisslog_schema.schema import TriggerInfo
 from bisslog_schema.schema.triggers.trigger_http import TriggerHttp
 from bisslog_schema.schema.triggers.trigger_websocket import TriggerWebsocket
 from bisslog_schema.schema.use_case_info import UseCaseInfo
-from types import SimpleNamespace
+from flask import Flask
+
+from bisslog_flask.initializer.init_flask_app_manager import InitFlaskAppManager
 
 
 @pytest.fixture
@@ -23,6 +24,18 @@ def fake_use_case_info():
         triggers=[http_trigger, ws_trigger]
     )
 
+@pytest.fixture
+def fake_use_case_info_with_async():
+    http_trigger = TriggerInfo(keyname="http_trigger", type="http", options=TriggerHttp(method="GET", path="/test2"))
+
+    return UseCaseInfo(
+        keyname="sample_coroutine_uc",
+        name="sample_coroutine_uc",
+        description="desc",
+        type="async",
+        triggers=[http_trigger]
+    )
+
 @pytest.fixture
 def fake_force_import():
     force_import = MagicMock()
@@ -30,13 +43,17 @@ def fake_force_import():
 
 
 @pytest.fixture
-def mock_read_service_info_with_code(fake_use_case_info):
+def mock_read_service_info_with_code(fake_use_case_info, fake_use_case_info_with_async):
+
+    async def mock_coroutine(*args, **kwargs):
+        return {"sample_coroutine_res": 23}
+
     return SimpleNamespace(
         declared_metadata=SimpleNamespace(
             name="TestService",
-            use_cases={"sample_uc": fake_use_case_info}
+            use_cases={"sample_uc": fake_use_case_info, "sample_coroutine_uc": fake_use_case_info_with_async}
         ),
-        discovered_use_cases={"sample_uc": lambda: {"ok": True}}
+        discovered_use_cases={"sample_uc": lambda: {"ok": True}, "sample_coroutine_uc": mock_coroutine},
     )
 
 
@@ -57,7 +74,7 @@ def test_init_flask_app_registers_routes(monkeypatch, fake_use_case_info,
 
     # Assert
     assert isinstance(app, Flask)
-    mock_http.assert_called_once()
+    assert mock_http.call_count == 2
     mock_ws.assert_called_once()
 
 

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/tests/unit/test_ws_resolver.py

@@ -1,11 +1,12 @@
+from unittest.mock import Mock, MagicMock
+
 import pytest
+from bisslog_schema.schema import UseCaseInfo, TriggerInfo, TriggerConsumer
+from bisslog_schema.schema.triggers.trigger_websocket import TriggerWebsocket
 from flask import Flask
 from flask_socketio import SocketIO
-from unittest.mock import Mock, MagicMock
 
 from bisslog_flask.initializer.bisslog_flask_ws_resolver import BisslogFlaskWebSocketResolver
-from bisslog_schema.schema import UseCaseInfo, TriggerInfo, TriggerConsumer
-from bisslog_schema.schema.triggers.trigger_websocket import TriggerWebsocket
 
 
 @pytest.fixture

bisslog_flask-0.0.2/bisslog_flask.egg-info/requires.txt

@@ -1,9 +0,0 @@
-bisslog>=0.0.7
-bisslog-schema>=0.0.6
-flask
-
-[cors]
-flask-cors>=6.0.0
-
-[websocket]
-flask-socketio

bisslog_flask-0.0.2/requirements.txt

@@ -1,3 +0,0 @@
-bisslog>=0.0.7
-bisslog-schema>=0.0.6
-flask

bisslog_flask-0.0.2/tests/unit/test_http_resolver.py

@@ -1,97 +0,0 @@
-import pytest
-from flask import Flask
-from unittest.mock import Mock
-
-from bisslog_flask.initializer.bisslog_flask_http_resolver import BisslogFlaskHttpResolver
-from bisslog_schema.schema import UseCaseInfo, TriggerHttp, TriggerInfo
-
-
-@pytest.fixture
-def flask_app():
-    app = Flask(__name__)
-    return app
-
-
-@pytest.fixture
-def resolver():
-    return BisslogFlaskHttpResolver()
-
-
-def test_register_get_route_without_mapper(flask_app, resolver):
-    def mock_uc():
-        return {"status": "ok"}
-
-    use_case_info = UseCaseInfo(
-        keyname="test_uc", name="Test UC", description="", type="sync", triggers=[]
-    )
-    trigger_http = TriggerHttp(method="GET", path="/test", allow_cors=False)
-    trigger = TriggerInfo(keyname="test_trigger", type="http", options=trigger_http)
-
-    resolver(flask_app, use_case_info, trigger, mock_uc)
-
-    client = flask_app.test_client()
-    response = client.get("/test")
-
-    assert response.status_code == 200
-    assert response.json == {"status": "ok"}
-
-
-def test_register_post_route_with_json(flask_app, resolver):
-    def mock_uc(**data):
-        return {"echo": data.get("name")}
-
-    use_case_info = UseCaseInfo(
-        keyname="echo_uc", name="Echo UC", description="", type="sync", triggers=[]
-    )
-    trigger_http = TriggerHttp(method="POST", path="/echo", allow_cors=False)
-    trigger = TriggerInfo(keyname="echo_trigger", type="http", options=trigger_http)
-
-    resolver(flask_app, use_case_info, trigger, mock_uc)
-
-    client = flask_app.test_client()
-    response = client.post("/echo", json={"name": "ChatGPT"})
-
-    assert response.status_code == 200
-    assert response.json == {"echo": "ChatGPT"}
-
-
-def test_register_post_route_with_mapper(flask_app, resolver):
-    def mock_uc(*, a = None, b = None, c = None, d = None, e = None, f = None):
-        return {"a": a, "b": b, "c": c, "d": d, "e": e, "f": f}
-
-    use_case_info = UseCaseInfo(
-        keyname="echo_uc", name="Echo UC", description="", type="sync", triggers=[]
-    )
-    trigger_http = TriggerHttp(method="POST", path="/echo/{algo3}", allow_cors=False,
-                               mapper={"body.algo1": "a", "body.algo2": "b",
-                                       "path_query.algo3": "c", "headers.algo4": "d",
-                                       "params.algo5": "e", "params.algo6": "f"})
-    trigger = TriggerInfo(keyname="echo_trigger", type="http", options=trigger_http)
-
-    resolver(flask_app, use_case_info, trigger, mock_uc)
-
-    client = flask_app.test_client()
-    response = client.post("/echo/something", json={"algo1": 2356, "algo2": "casa"},
-                           headers=[("algo4", "prueba4")], query_string={"algo5": 7554, "algo6": "prueba6"})
-
-    assert response.status_code == 200
-    assert response.json["a"] == 2356
-    assert response.json["b"] == "casa"
-    assert response.json["c"] == "something"
-    assert response.json["d"] == "prueba4"
-    assert response.json["e"] == "7554"
-    assert response.json["f"] == "prueba6"
-
-def test_invalid_trigger_type_is_ignored(flask_app, resolver):
-    trigger = TriggerInfo(keyname="invalid", type="websocket", options=Mock())
-    mock_uc = Mock()
-    use_case_info = UseCaseInfo(
-        keyname="invalid_uc", name="", description="", type="sync", triggers=[]
-    )
-
-    resolver(flask_app, use_case_info, trigger, mock_uc)
-
-    client = flask_app.test_client()
-    response = client.get("/invalid")
-
-    assert response.status_code == 404

{bisslog_flask-0.0.2 → bisslog_flask-0.0.3}/bisslog_flask/initializer/init_flask_app_manager.py

@@ -19,8 +19,8 @@ from typing import Optional, Callable
 
 from bisslog_schema import read_service_info_with_code
 from bisslog_schema.eager_import_module_or_package import EagerImportModulePackage
-from bisslog_schema.setup import run_setup
 from bisslog_schema.schema import UseCaseInfo, TriggerHttp, TriggerWebsocket
+from bisslog_schema.setup import run_setup
 from flask import Flask
 
 from .bisslog_flask_http_resolver import BisslogFlaskHttpResolver