b1sl-python 0.1.0__py3-none-any.whl

b1sl/b1sl/tests/test_03_items_endpoint.py

@@ -0,0 +1,172 @@
+"""
+test_03_items_resource.py — ItemsResource unit tests (pure pytest, no Django).
+
+Renamed from test_03_items_endpoint.py which tested the deprecated endpoint
+class and required Django. These tests mock RestAdapter so no live SAP
+connection is needed.
+"""
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from b1sl.b1sl.exceptions.exceptions import B1Exception
+from b1sl.b1sl.models.item import Item
+from b1sl.b1sl.models.result import Result
+from b1sl.b1sl.resources.items import ItemsResource
+from b1sl.b1sl.rest_adapter import RestAdapter
+
+
+@pytest.fixture
+def mock_adapter():
+    adapter = MagicMock(spec=RestAdapter)
+    return adapter
+
+
+@pytest.fixture
+def items(mock_adapter):
+    return ItemsResource(adapter=mock_adapter)
+
+
+# ── get() ────────────────────────────────────────────────────────────────── #
+
+
+def test_get_returns_item(items, mock_adapter):
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={
+            "ItemCode": "ITEM-001",
+            "ItemName": "Widget",
+            "Valid": True,
+            "QuantityOnStock": 5.0,
+        },
+    )
+    item = items.get("ITEM-001")
+    assert isinstance(item, Item)
+    assert item.item_code == "ITEM-001"
+    assert item.item_name == "Widget"
+    assert item.valid is True
+
+
+def test_get_decodes_tyes_to_true(items, mock_adapter):
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={"ItemCode": "X", "Valid": "tYES"},
+    )
+    item = items.get("X")
+    assert item.valid is True
+
+
+def test_get_decodes_tno_to_false(items, mock_adapter):
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={"ItemCode": "X", "Valid": "tNO"},
+    )
+    item = items.get("X")
+    assert item.valid is False
+
+
+def test_get_with_custom_model(items, mock_adapter):
+    from pydantic import Field
+
+    from b1sl.b1sl.models.base import B1Model
+
+    class CustomItem(B1Model):
+        item_code: str = Field(alias="ItemCode")
+        custom_udf: str | None = Field(None, alias="U_Custom")
+
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={"ItemCode": "X", "U_Custom": "hello"},
+    )
+    result = items.get("X", model=CustomItem)
+    assert isinstance(result, CustomItem)
+    assert result.custom_udf == "hello"
+
+
+# ── list() ───────────────────────────────────────────────────────────────── #
+
+
+def test_list_returns_paginated_result(items, mock_adapter):
+    from b1sl.b1sl.models.paginated_result import PaginatedResult
+
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={
+            "value": [
+                {
+                    "ItemCode": "A",
+                    "ItemName": "Alpha",
+                    "Valid": "tYES",
+                    "QuantityOnStock": 1.0,
+                },
+                {
+                    "ItemCode": "B",
+                    "ItemName": "Beta",
+                    "Valid": "tNO",
+                    "QuantityOnStock": 0.0,
+                },
+            ]
+        },
+    )
+    page = items.list()
+    assert isinstance(page, PaginatedResult)
+    rows = page.to_list()
+    assert len(rows) == 2
+    assert rows[0].item_code == "A"
+    assert isinstance(rows[0], Item)  # default is now Item, not ItemPage
+    assert rows[0].valid is True
+    assert rows[1].valid is False
+
+
+def test_list_empty_value_key(items, mock_adapter):
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={"value": []},
+    )
+    page = items.list()
+    assert page.to_list() == []
+
+
+# ── update() returns fresh GET after 204 ─────────────────────────────────── #
+
+
+def test_update_re_fetches_item(items, mock_adapter):
+    from pydantic import Field
+
+    from b1sl.b1sl.models.base import B1Model
+
+    class ItemUpdate(B1Model):
+        valid: bool | None = Field(None, alias="Valid")
+
+    mock_adapter.patch.return_value = Result(
+        status_code=204, message="No Content", data=None
+    )
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={"ItemCode": "X", "ItemName": "Updated", "Valid": True},
+    )
+    result = items.update("X", ItemUpdate(valid=True))
+    assert result.item_name == "Updated"
+
+
+def test_update_raises_on_unexpected_status(items, mock_adapter):
+    from pydantic import Field
+
+    from b1sl.b1sl.models.base import B1Model
+
+    class ItemUpdate(B1Model):
+        valid: bool | None = Field(None, alias="Valid")
+
+    mock_adapter.patch.return_value = Result(
+        status_code=200, message="OK", data={"ItemCode": "X"}
+    )
+    with pytest.raises(B1Exception):
+        items.update("X", ItemUpdate(valid=True))

b1sl/b1sl/tests/test_04_serialnumberdetails_endpoint.py

@@ -0,0 +1,181 @@
+"""
+test_04_serial_numbers_resource.py — SerialNumbersResource unit tests (pure pytest).
+
+Renamed from test_04_serialnumberdetails_endpoint.py which required Django.
+All tests use a mocked RestAdapter — no live SAP connection required.
+"""
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from b1sl.b1sl.exceptions.exceptions import B1Exception
+from b1sl.b1sl.models.result import Result
+from b1sl.b1sl.models.serialnumberdetail import SerialNumberDetails
+from b1sl.b1sl.resources.serial_numbers import SerialNumbersResource
+from b1sl.b1sl.rest_adapter import RestAdapter
+
+
+@pytest.fixture
+def mock_adapter():
+    return MagicMock(spec=RestAdapter)
+
+
+@pytest.fixture
+def sn_resource(mock_adapter):
+    return SerialNumbersResource(adapter=mock_adapter)
+
+
+# ── get() ────────────────────────────────────────────────────────────────── #
+
+
+def test_get_returns_serial_number_details(sn_resource, mock_adapter):
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={
+            "DocEntry": 42,
+            "ItemCode": "SN-001",
+            "MfrSerialNo": "SN123",
+            "ItemDescription": "Widget",
+        },
+    )
+    result = sn_resource.get(42)
+    assert isinstance(result, SerialNumberDetails)
+    assert result.doc_entry == 42
+    assert result.item_code == "SN-001"
+
+
+def test_get_with_custom_model(sn_resource, mock_adapter):
+    from pydantic import Field
+
+    from b1sl.b1sl.models.base import B1Model
+
+    class CustomSerial(B1Model):
+        doc_entry: int = Field(alias="DocEntry")
+        user_location: str | None = Field(None, alias="U_Ubicacion")
+
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={"DocEntry": 99, "U_Ubicacion": "K-11-2"},
+    )
+    result = sn_resource.get(99, model=CustomSerial)
+    assert isinstance(result, CustomSerial)
+    assert result.user_location == "K-11-2"
+
+
+def test_get_wraps_b1exception(sn_resource, mock_adapter):
+    mock_adapter.get.side_effect = B1Exception("SAP Error -2028: Not found")
+    with pytest.raises(B1Exception, match="SerialNumbersResource.get"):
+        sn_resource.get(1)
+
+
+# ── list() ───────────────────────────────────────────────────────────────── #
+
+
+def test_list_returns_paginated_result(sn_resource, mock_adapter):
+    from b1sl.b1sl.models.paginated_result import PaginatedResult
+
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={
+            "value": [
+                {
+                    "DocEntry": 1,
+                    "ItemCode": "A",
+                    "MfrSerialNo": "SNA",
+                    "ItemDescription": "Alpha",
+                },
+                {
+                    "DocEntry": 2,
+                    "ItemCode": "B",
+                    "MfrSerialNo": "SNB",
+                    "ItemDescription": "Beta",
+                },
+            ]
+        },
+    )
+    page = sn_resource.list()
+    assert isinstance(page, PaginatedResult)
+    rows = page.to_list()
+    assert len(rows) == 2
+    assert rows[0].doc_entry == 1
+    assert rows[1].item_code == "B"
+
+
+def test_list_empty(sn_resource, mock_adapter):
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={"value": []},
+    )
+    page = sn_resource.list()
+    assert page.to_list() == []
+
+
+# ── update() ─────────────────────────────────────────────────────────────── #
+
+
+def test_update_re_fetches_on_204(sn_resource, mock_adapter):
+    from b1sl.b1sl.models.base import B1Model
+
+    class SerialNumberUpdateTest(B1Model):
+        pass
+
+    mock_adapter.patch.return_value = Result(
+        status_code=204, message="No Content", data=None
+    )
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={
+            "DocEntry": 42,
+            "ItemCode": "X",
+            "MfrSerialNo": "SN-X",
+            "ItemDescription": "Widget",
+        },
+    )
+    result = sn_resource.update(42, SerialNumberUpdateTest())
+    assert result.doc_entry == 42
+
+
+def test_update_raises_on_unexpected_status(sn_resource, mock_adapter):
+    from b1sl.b1sl.models.base import B1Model
+
+    class SerialNumberUpdateTest(B1Model):
+        pass
+
+    mock_adapter.patch.return_value = Result(
+        status_code=200, message="OK", data={"DocEntry": 42}
+    )
+    with pytest.raises(B1Exception):
+        sn_resource.update(42, SerialNumberUpdateTest())
+
+
+# ── PaginatedResult.to_list() caching ────────────────────────────────────── #
+
+
+def test_paginated_result_to_list_caches(sn_resource, mock_adapter):
+    """to_list() must return the same list object on repeated calls."""
+    mock_adapter.get.return_value = Result(
+        status_code=200,
+        message="OK",
+        data={
+            "value": [
+                {
+                    "DocEntry": 1,
+                    "ItemCode": "A",
+                    "MfrSerialNo": "S",
+                    "ItemDescription": "D",
+                }
+            ]
+        },
+    )
+    page = sn_resource.list()
+    first = page.to_list()
+    second = page.to_list()
+    assert first is second, "to_list() is not returning cached list"
+    third = list(page.data)
+    assert third == first, "data property does not replay cache"

b1sl/b1sl/tests/test_observability.py

@@ -0,0 +1,153 @@
+import logging
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from b1sl.b1sl.async_rest_adapter import AsyncRestAdapter
+from b1sl.b1sl.base_adapter import HookContext, HookDispatcher, ObservabilityConfig
+from b1sl.b1sl.config import B1Config
+from b1sl.b1sl.rest_adapter import RestAdapter
+
+
+def test_hook_context_immutability():
+    ctx = HookContext(
+        req_id="123",
+        http_method="GET",
+        base_url="http://test",
+        endpoint="/Items",
+        query_params="",
+        db="db",
+        user="user",
+        status_code=200,
+        duration_ms=10.0,
+    )
+    with pytest.raises(AttributeError):  # frozen=True
+        ctx.status_code = 500
+
+
+def test_to_log_extra_contract():
+    extra_data = {"test_key": "test_val"}
+    ctx = HookContext(
+        req_id="123",
+        http_method="GET",
+        base_url="http://test",
+        endpoint="/Items",
+        query_params="",
+        db="db",
+        user="user",
+        status_code=200,
+        duration_ms=10.5,
+        extra=extra_data,
+    )
+    log_extra = ctx.to_log_extra()
+
+    assert log_extra["req_id"] == "123"
+    assert log_extra["duration_ms"] == 10.5
+    assert log_extra["test_key"] == "test_val"
+    assert (
+        "query_params" not in log_extra
+    )  # Should not be in log_extra by default for privacy
+
+
+def test_hook_dispatcher_isolation():
+    """Verify that a failing hook does not stop other hooks or the dispatcher."""
+    logger = MagicMock(spec=logging.Logger)
+
+    def failing_hook(ctx):
+        raise ValueError("Boom!")
+
+    success_mock = MagicMock()
+
+    dispatcher = HookDispatcher(hooks={"on_response": [failing_hook, success_mock]})
+    ctx = MagicMock(spec=HookContext)
+
+    # Should not raise exception
+    dispatcher.dispatch("on_response", ctx, logger)
+
+    # Second hook should have been called
+    success_mock.assert_called_once_with(ctx)
+    # Logger should have warned about the failure
+    assert logger.warning.called
+
+
+@pytest.mark.asyncio
+async def test_async_hook_dispatcher_isolation():
+    logger = MagicMock(spec=logging.Logger)
+
+    async def failing_async_hook(ctx):
+        raise ValueError("Async Boom!")
+
+    success_async_mock = AsyncMock()
+
+    dispatcher = HookDispatcher(
+        hooks={"on_response": [failing_async_hook, success_async_mock]}
+    )
+    ctx = MagicMock(spec=HookContext)
+
+    await dispatcher.adispatch("on_response", ctx, logger)
+
+    success_async_mock.assert_called_once_with(ctx)
+    assert logger.warning.called
+
+
+def test_rest_adapter_observability_integration():
+    """Integration test for RestAdapter with ObservabilityConfig."""
+    hook_mock = MagicMock()
+    obs = ObservabilityConfig(
+        hooks={"on_response": [hook_mock]}, context_extras={"tenant": "admin"}
+    )
+
+    config = B1Config("http://sap", "user", "pass", "db")
+    adapter = RestAdapter(config, observability=obs)
+
+    # Mock transport
+    adapter._execute_request = MagicMock()
+    mock_resp = MagicMock()
+    mock_resp.status_code = 200
+    mock_resp.reason = "OK"
+    mock_resp.content = b"{}"
+    mock_resp.json.return_value = {}
+    mock_resp.headers = {}
+    adapter._execute_request.return_value = mock_resp
+
+    adapter._do("GET", "Items", ep_params={"$top": 1})
+
+    # Verify hook was called
+    assert hook_mock.called
+    ctx = hook_mock.call_args[0][0]
+    assert isinstance(ctx, HookContext)
+    assert ctx.endpoint == "/Items"
+    assert ctx.query_params == "%24top=1"
+    assert ctx.extra["tenant"] == "admin"
+    assert ctx.duration_ms > 0
+
+
+@pytest.mark.asyncio
+async def test_async_rest_adapter_observability_integration():
+    hook_mock = MagicMock()
+    obs = ObservabilityConfig(hooks={"on_response": [hook_mock]})
+
+    config = B1Config("http://sap", "user", "pass", "db")
+    adapter = AsyncRestAdapter(config, observability=obs)
+
+    # Mock httpx client
+    adapter._client = AsyncMock()
+    mock_resp = MagicMock()
+    mock_resp.status_code = 200
+    mock_resp.reason_phrase = "OK"
+    mock_resp.content = b"{}"
+    mock_resp.json.return_value = {}
+    mock_resp.headers = {}
+    adapter._client.request.return_value = mock_resp
+
+    from datetime import datetime, timedelta
+
+    adapter.is_session_active = True
+    adapter.token_expiry = datetime.now() + timedelta(hours=1)
+
+    await adapter._do("GET", "Items")
+
+    assert hook_mock.called
+    ctx = hook_mock.call_args[0][0]
+    assert ctx.endpoint == "/Items"
+    assert ctx.duration_ms > 0

b1sl/b1sl/tests/test_utils.py

@@ -0,0 +1,24 @@
+import logging
+
+
+def get_test_logger(name="test_logger", level=logging.DEBUG):
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    if not logger.handlers:
+        # Create console handler and set level to debug
+        ch = logging.StreamHandler()
+        ch.setLevel(level)
+
+        # Create formatter
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+
+        # Add formatter to ch
+        ch.setFormatter(formatter)
+
+        # Add ch to logger
+        logger.addHandler(ch)
+
+    return logger

b1sl/contrib/django/__init__.py

@@ -0,0 +1,15 @@
+"""
+b1sl.contrib.django
+~~~~~~~~~~~~~~~~~~~~~
+Django-specific contributions for SAP B1 integration, including middleware.
+"""
+
+from .base import SapMiddlewareBase
+from .odata_decode_middleware import ODataDecodeMiddleware
+from .odata_transform_url_middleware import ODataTransformURLMiddleware
+
+__all__ = [
+    "SapMiddlewareBase",
+    "ODataDecodeMiddleware",
+    "ODataTransformURLMiddleware",
+]

b1sl/contrib/django/base.py

@@ -0,0 +1,89 @@
+"""
+b1sl.contrib.django.base
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+Framework-agnostic base class for all SAP-aware Django middleware.
+Supports both WSGI (__call__) and ASGI (__acall__) deployments.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+
+class SapMiddlewareBase:
+    """
+    Drop-in Django middleware base that works with both:
+      - WSGI: Django calls __call__(request) synchronously.
+      - ASGI: Django calls __call__(scope, receive, send) or uses
+              the middleware with channels / uvicorn via __acall__.
+
+    Subclass and override `process_request` / `process_response`
+    for custom logic.
+    """
+
+    sync_capable = True
+    async_capable = True
+
+    def __init__(self, get_response: Callable) -> None:
+        self.get_response = get_response
+        # Detect if the downstream handler is async
+        import asyncio
+
+        self._is_coroutine = asyncio.iscoroutinefunction(self.get_response)
+
+    # ------------------------------------------------------------------ #
+    # Hooks — override in subclasses                                       #
+    # ------------------------------------------------------------------ #
+
+    def process_request(self, request):
+        """Synchronous pre-processing hook. Return None to continue."""
+
+    def process_response(self, request, response):
+        """Synchronous post-processing hook. Must return response."""
+        return response
+
+    async def async_process_request(self, request):
+        """Async pre-processing hook. Return None to continue."""
+
+    async def async_process_response(self, request, response):
+        """Async post-processing hook. Must return response."""
+        return response
+
+    # ------------------------------------------------------------------ #
+    # WSGI path                                                            #
+    # ------------------------------------------------------------------ #
+
+    def __call__(self, request):
+        if self._is_coroutine:
+            # Do not call this synchronously on an async handler —
+            # Django will always use __acall__ in that case.
+            import asyncio
+
+            return asyncio.get_event_loop().run_until_complete(self.__acall__(request))
+
+        short_circuit = self.process_request(request)
+        if short_circuit is not None:
+            return short_circuit
+
+        response = self.get_response(request)
+
+        return self.process_response(request, response)
+
+    # ------------------------------------------------------------------ #
+    # ASGI path                                                            #
+    # ------------------------------------------------------------------ #
+
+    async def __acall__(self, request):
+        short_circuit = await self.async_process_request(request)
+        if short_circuit is not None:
+            return short_circuit
+
+        if self._is_coroutine:
+            response = await self.get_response(request)
+        else:
+            response = self.get_response(request)
+
+        return await self.async_process_response(request, response)

b1sl/contrib/django/odata_decode_middleware.py

@@ -0,0 +1,14 @@
+from urllib.parse import unquote
+
+from .base import SapMiddlewareBase
+
+
+class ODataDecodeMiddleware(SapMiddlewareBase):
+    """URL-decodes percent-encoded OData query strings before Django routing."""
+
+    def process_request(self, request):
+        if qs := request.META.get("QUERY_STRING"):
+            request.META["QUERY_STRING"] = unquote(qs)
+
+    async def async_process_request(self, request):
+        self.process_request(request)  # pure string op, no I/O

b1sl/contrib/django/odata_transform_url_middleware.py

@@ -0,0 +1,15 @@
+from .base import SapMiddlewareBase
+
+
+class ODataTransformURLMiddleware(SapMiddlewareBase):
+    """Transforms OData-style URLs (replacing parenthesis) before Django routing."""
+
+    def process_request(self, request):
+        path = request.path
+        if "(" in path and ")" in path:
+            # Reemplazar '(' y ')' con '/'
+            request.path = path.replace("(", "/").replace(")", "")
+            print(request.path)
+
+    async def async_process_request(self, request):
+        self.process_request(request)  # pure string op, no I/O

b1sl/saphdb/__init__.py

@@ -0,0 +1,19 @@
+"""
+SAP HANA Database client SDK — public interface.
+"""
+
+from b1sl.saphdb.client import SapHDBClient
+from b1sl.saphdb.config import SapHDBConfig
+from b1sl.saphdb.exceptions.exceptions import (
+    SapHAClientConnectionError,
+    SapHAClientException,
+    SapHAClientResponseError,
+)
+
+__all__ = [
+    "SapHDBClient",
+    "SapHDBConfig",
+    "SapHAClientException",
+    "SapHAClientConnectionError",
+    "SapHAClientResponseError",
+]