b1sl-python 0.1.0__py3-none-any.whl

b1sl/b1sl/rest_adapter.py

@@ -0,0 +1,351 @@
+from __future__ import annotations
+
+import functools
+import logging
+import threading
+import time
+from datetime import datetime, timedelta
+from json import JSONDecodeError
+from typing import Optional
+from urllib.parse import urlencode, urlsplit
+
+import httpx
+
+from b1sl.b1sl.base_adapter import BaseRestAdapter, HookContext, ObservabilityConfig
+from b1sl.b1sl.config import B1Config
+from b1sl.b1sl.exceptions.exceptions import (
+    B1AuthError,
+    B1Exception,
+    B1NotFoundError,
+    B1ValidationError,
+    SAPConcurrencyError,
+)
+from b1sl.b1sl.models.result import Result
+
+_HTTP_STATUS_TO_EXC: dict[int, type] = {
+    400: B1ValidationError,
+    401: B1AuthError,
+    404: B1NotFoundError,
+}
+
+
+class RestAdapter(BaseRestAdapter):
+    """
+    Synchronous HTTP adapter for SAP B1 Service Layer using requests.
+
+    This adapter manages session lifecycle (login/logout), re-authentication
+    on 401 errors, and ETag-based optimistic concurrency for single-threaded
+    or WSGI environments. It uses httpx.Client for parity with the async client.
+
+    AI Role: Use for synchronous workflows or legacy integrations.
+    Handles basic CRUD operations and session resilience automatically.
+    """
+
+
+
+    def __init__(self, *args, **kwargs):
+        """
+        Initializes the synchronous httpx client.
+        """
+        super().__init__(*args, **kwargs)
+        self._lock = threading.Lock()
+        self.session = httpx.Client(
+            verify=self._ssl_verify,
+            timeout=httpx.Timeout(
+                self._connect_timeout,
+                read=self._read_timeout,
+                write=self._read_timeout,
+                pool=self._connect_timeout,
+            ),
+            follow_redirects=True,
+        )
+
+    def close(self) -> None:
+        """Closes the underlying HTTP client."""
+        if self.session:
+            self.session.close()
+
+    @property
+    def session_id(self) -> str | None:
+        """
+        Retrieves the current SAP session ID from the cookie jar.
+
+        Returns:
+            str: The B1SESSION cookie value or None.
+        """
+        return self.session.cookies.get("B1SESSION")
+
+    @staticmethod
+    def handle_token(manage_token: bool = True):
+        """
+        Decorator for methods requiring a valid SAP session.
+
+        Logs in before the method call if needed and potentially logs out
+        afterwards depending on the reuse_token configuration.
+
+        Args:
+            manage_token (bool): Whether to perform session lifecycle management.
+        """
+
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(self, *args, **kwargs):
+                if manage_token:
+                    self._handle_token_login()
+                try:
+                    result = func(self, *args, **kwargs)
+                finally:
+                    if manage_token:
+                        self._handle_token_logout()
+                return result
+
+            return wrapper
+
+        return decorator
+
+    def login(self):
+        """Authenticate with the SAP B1 Service Layer."""
+        return self._login()
+
+    def logout(self):
+        """Release the SAP B1 session license."""
+        return self._logout()
+
+    def _login(self):
+        """
+        Internal login implementation.
+
+        Calls POST /Login and updates session state and expiry.
+
+        Returns:
+            Result: Response from the Login endpoint.
+        """
+        data = {
+            "UserName": self._username,
+            "Password": self._password,
+            "CompanyDB": self._db,
+        }
+        self._logger.info(f"Logging in to SAP B1 at {self.raw_base_url}...")
+
+        response = self._do(
+            http_method="POST", endpoint="/Login", data=data, _is_login=True
+        )
+        if response.status_code == 200:
+            self.is_session_active = True
+            timeout_min = response.data.get("SessionTimeout", 30)
+            self.token_expiry = datetime.now() + timedelta(minutes=timeout_min - 2)
+        return response
+
+    def _logout(self):
+        """
+        Internal logout implementation.
+
+        Returns:
+            Result: Response from the Logout endpoint.
+        """
+        response = self._do(http_method="POST", endpoint="/Logout", _is_login=True)
+        if response.status_code == 204:
+            self.is_session_active = False
+            self.token_expiry = None
+        return response
+
+    def _is_token_expire(self) -> bool:
+        """
+        Checks if the current session token is missing or expired.
+
+        Returns:
+            bool: True if a new login is required.
+        """
+        return self.token_expiry is None or datetime.now() >= self.token_expiry
+
+    def _handle_token_login(self):
+        """Standard login handler used by the decorator."""
+        if self.reuse_token:
+            if self._is_token_expire():
+                with self._lock:
+                    if self._is_token_expire():
+                        self._login()
+        else:
+            with self._lock:
+                self._login()
+
+    def _handle_token_logout(self):
+        """Standard logout handler used by the decorator."""
+        if not self.reuse_token:
+            self._logout()
+
+    def _get_full_url(self, next_link: str) -> str:
+        """Normalizes a nextLink to a relative resource path."""
+        return "/" + urlsplit(next_link).path.lstrip("/")
+
+    def _process_next_link(self, next_link: str) -> tuple[str, str, dict]:
+        """Parses an OData nextLink for multi-page results."""
+        return (
+            self._clean_url(next_link),
+            self._get_full_url(next_link),
+            self._get_ep_params(next_link),
+        )
+
+    @staticmethod
+    def _parse_sap_error(response: httpx.Response) -> tuple[str, str]:
+        """Parses error information from an Httpx response object."""
+        try:
+            body = response.json()
+        except Exception:
+            body = None
+        return RestAdapter._parse_sap_error_shared(response.status_code, response.reason_phrase, body)
+
+    def _execute_request(
+        self,
+        http_method: str,
+        full_url: str,
+        headers: dict,
+        ep_params: dict | None,
+        data: dict | None,
+    ) -> httpx.Response:
+        """Executes the raw HTTP request using the httpx client."""
+        return self.session.request(
+            method=http_method,
+            url=full_url,
+            headers=headers,
+            params=ep_params,
+            json=data,
+        )
+
+    def _do(
+        self,
+        http_method: str,
+        endpoint: str,
+        ep_params: dict | None = None,
+        data: dict | None = None,
+        _is_login: bool = False,
+    ) -> Result:
+        """
+        Dispatches a standardized HTTP request to SAP.
+        Implements Senior Observability (Timing + Structured Logging + Hooks).
+        """
+        # Removed redundant imports moved to module level
+        req_id = self._generate_req_id()
+        endpoint_path = endpoint if endpoint.startswith("/") else f"/{endpoint}"
+        full_url = self.raw_base_url + endpoint_path
+
+        # ── ETag: inject If-None-Match (GET) or If-Match (PATCH/DELETE/POST) ──
+        headers = self._build_headers(http_method, endpoint_path)
+
+        log_data = self._redact_data(data)
+        self._logger.debug(f"[{req_id}] data={log_data}")
+
+        start_time = time.perf_counter()
+        exc_captured: Exception | None = None
+        response: httpx.Response | None = None
+        is_success = False
+
+        try:
+            response = self._execute_request(
+                http_method, full_url, headers, ep_params, data
+            )
+            response.raise_for_status()
+            is_success = True
+        except httpx.HTTPStatusError as e:
+            if response is not None and response.status_code == 401 and not _is_login:
+                self._logger.warning(f"[{req_id}] 401 Unauthorized - retrying login...")
+                try:
+                    old_token_expiry = self.token_expiry
+                    with self._lock:
+                        if self.token_expiry == old_token_expiry:
+                            self._login()
+                    response = self._execute_request(
+                        http_method, full_url, headers, ep_params, data
+                    )
+                    response.raise_for_status()
+                    is_success = True
+                except Exception as retry_exc:
+                    exc_captured = retry_exc
+                    raise B1Exception(
+                        "Request failed after session retry"
+                    ) from retry_exc
+            else:
+                exc_captured = e
+                sap_code, sap_msg = self._parse_sap_error(response)
+                # ── Raise specialised exception before falling back to B1Exception ──
+                try:
+                    body = response.json() if response.content else None
+                except Exception:
+                    body = None
+                self._raise_if_concurrency_error(
+                    response.status_code, sap_code, sap_msg, endpoint_path, body
+                )
+                raise B1Exception(f"SAP Error {sap_code}: {sap_msg}") from e
+        except Exception as e:
+            exc_captured = e
+            raise B1Exception(f"Request failed: {e}") from e
+        finally:
+            duration_ms = (time.perf_counter() - start_time) * 1000
+            status_code = response.status_code if response is not None else None
+
+            ctx = HookContext(
+                req_id=req_id,
+                http_method=http_method,
+                base_url=self.raw_base_url,
+                endpoint=endpoint_path,
+                query_params=urlencode(ep_params) if ep_params else "",
+                db=self._db,
+                user=self._username,
+                status_code=status_code,
+                duration_ms=duration_ms,
+                extra=dict(self._obs.context_extras),
+                exc=exc_captured,
+            )
+
+            self._log_response(ctx)
+            self._hooks.dispatch(
+                "on_error" if exc_captured else "on_response", ctx, self._logger
+            )
+
+        if is_success and response is not None:
+            if response.content:
+                try:
+                    data_out = response.json()
+                    # ── ETag: extract from header (preferred) or body fallback ──
+                    self._extract_etag(endpoint_path, dict(response.headers), data_out)
+                    return Result(
+                        status_code=response.status_code,
+                        message=response.reason_phrase,
+                        data=data_out,
+                        next_link=data_out.get("odata.nextLink"),
+                        next_params=self._get_ep_params(data_out.get("odata.nextLink"))
+                        if data_out.get("odata.nextLink")
+                        else None,
+                        metadata=data_out.get("odata.metadata"),
+                    )
+                except Exception:
+                    raise B1Exception("Bad JSON response")
+            else:
+                self._extract_etag(endpoint_path, dict(response.headers), None)
+                return Result(
+                    status_code=response.status_code, message=response.reason_phrase, data=None
+                )
+        else:
+            raise B1Exception(
+                f"HTTP Error {response.status_code if response else 'Unknown'}"
+            )
+
+    @handle_token()
+    def get(self, endpoint, ep_params=None, data=None):
+        """Execute a synchronous GET request."""
+        return self._do("GET", endpoint, ep_params, data)
+
+    @handle_token()
+    def post(self, endpoint, ep_params=None, data=None):
+        """Execute a synchronous POST request."""
+        return self._do("POST", endpoint, ep_params, data)
+
+    @handle_token()
+    def patch(self, endpoint, ep_params=None, data=None):
+        """Execute a synchronous PATCH request."""
+        return self._do("PATCH", endpoint, ep_params, data)
+
+    @handle_token()
+    def delete(self, endpoint, ep_params=None, data=None):
+        """Execute a synchronous DELETE request."""
+        return self._do("DELETE", endpoint, ep_params, data)

b1sl/b1sl/testing.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class B1TestHelper:
+    """
+    Test helper for SAP B1 environments.
+    Groups test_data logic away from the core runtime SDK.
+    """
+    def __init__(self, test_data: dict[str, Any]):
+        self.test_data = test_data
+
+    def get_test_item(self, profile: str = "simple") -> str:
+        """Retrieves a test item code from the environment test data."""
+        return self.test_data.get("items", {}).get(profile, "")
+
+    def get_test_customer(self, profile: str = "retail") -> str:
+        """Retrieves a test customer code from the environment test data."""
+        return self.test_data.get("customers", {}).get(profile, "")
+
+    def get_test_bp(self, profile: str = "simple") -> str:
+        """Retrieves a test Business Partner code from the environment test data."""
+        return self.test_data.get("business_partners", {}).get(profile, "")

b1sl/b1sl/tests/test_01_settings.py

@@ -0,0 +1,60 @@
+"""
+test_01_config.py — B1Config unit tests (pure pytest, no Django).
+
+Renamed from test_01_settings.py which required Django settings.
+"""
+
+from datetime import timedelta
+
+import pytest
+
+from b1sl.b1sl.config import B1Config
+
+
+def test_config_rejects_empty_base_url():
+    with pytest.raises(ValueError, match="base_url"):
+        B1Config(base_url="", username="u", password="p", company_db="db")
+
+
+def test_config_rejects_empty_credentials():
+    with pytest.raises(ValueError, match="credentials"):
+        B1Config(base_url="https://x", username="", password="", company_db="db")
+
+
+def test_config_rejects_empty_company_db():
+    with pytest.raises(ValueError, match="company_db"):
+        B1Config(base_url="https://x", username="u", password="p", company_db="")
+
+
+def test_config_defaults():
+    cfg = B1Config(base_url="https://x", username="u", password="p", company_db="db")
+    assert cfg.ssl_verify is True
+    assert cfg.reuse_token is True
+    assert cfg.token_timeout == timedelta(seconds=900)
+    assert cfg.max_page_size == 20
+    assert cfg.connect_timeout == 10.0
+    assert cfg.read_timeout == 60.0
+
+
+def test_config_from_env_success():
+    with pytest.MonkeyPatch.context() as mp:
+        mp.setenv("SAPB1CLIENT_BASE_URL", "https://sap:50000/b1s/v1")
+        mp.setenv("SAPB1CLIENT_USERNAME", "admin")
+        mp.setenv("SAPB1CLIENT_PASSWORD", "pass")
+        mp.setenv("SAPB1CLIENT_COMPANY_DB", "MYDB")
+        cfg = B1Config.from_env()
+    assert cfg.base_url == "https://sap:50000/b1s/v1"
+    assert cfg.company_db == "MYDB"
+
+
+def test_config_from_env_missing_raises():
+    with pytest.MonkeyPatch.context() as mp:
+        for key in (
+            "SAPB1CLIENT_BASE_URL",
+            "SAPB1CLIENT_USERNAME",
+            "SAPB1CLIENT_PASSWORD",
+            "SAPB1CLIENT_COMPANY_DB",
+        ):
+            mp.delenv(key, raising=False)
+        with pytest.raises(EnvironmentError):
+            B1Config.from_env()

b1sl/b1sl/tests/test_02_rest_adapter.py

@@ -0,0 +1,177 @@
+"""
+test_02_rest_adapter.py — RestAdapter unit tests (pure pytest, no Django).
+
+These are offline tests using mocks — no live SAP connection required.
+Integration tests that require a live SAP instance belong in a separate
+``tests/integration/`` directory that is skipped in CI.
+"""
+
+from datetime import timedelta
+from json import JSONDecodeError
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from b1sl.b1sl.config import B1Config
+from b1sl.b1sl.rest_adapter import RestAdapter
+
+
+@pytest.fixture
+def config():
+    return B1Config(
+        base_url="https://sap:50000/b1s/v1",
+        username="manager",
+        password="s3cr3t",
+        company_db="TESTDB",
+        reuse_token=False,
+        connect_timeout=5.0,
+        read_timeout=30.0,
+    )
+
+
+@pytest.fixture
+def adapter(config):
+    return RestAdapter.from_config(config)
+
+
+# ── Singleton removed ────────────────────────────────────────────────────── #
+
+
+def test_no_singleton(config):
+    """Two from_config() calls must return two distinct objects."""
+    a = RestAdapter.from_config(config)
+    b = RestAdapter.from_config(config)
+    assert a is not b
+
+
+# ── Constructor ──────────────────────────────────────────────────────────── #
+
+
+def test_adapter_stores_config_fields(adapter, config):
+    assert adapter.url == config.base_url
+    assert adapter._username == config.username
+    assert adapter._connect_timeout == 5.0
+    assert adapter._read_timeout == 30.0
+
+
+# ── Token expiry ─────────────────────────────────────────────────────────── #
+
+
+def test_is_token_expire_when_no_expiry(adapter):
+    adapter.token_expiry = None
+    assert adapter._is_token_expire() is True
+
+
+def test_is_token_expire_when_future(adapter):
+    from datetime import datetime
+
+    adapter.token_expiry = datetime.now() + timedelta(hours=1)
+    assert adapter._is_token_expire() is False
+
+
+def test_is_token_expire_when_past(adapter):
+    from datetime import datetime
+
+    adapter.token_expiry = datetime.now() - timedelta(seconds=1)
+    assert adapter._is_token_expire() is True
+
+
+# ── _parse_sap_error ─────────────────────────────────────────────────────── #
+
+
+def _mock_resp(status, body=None, json_raises=False):
+    r = MagicMock()
+    r.status_code = status
+    r.reason = "Error"
+    if json_raises:
+        r.json.side_effect = JSONDecodeError("", "", 0)
+    else:
+        r.json.return_value = body
+    return r
+
+
+@pytest.mark.parametrize(
+    "body,exp_code,exp_fragment",
+    [
+        (
+            {"error": {"code": -2028, "message": {"value": "Item does not exist"}}},
+            "-2028",
+            "Item does not exist",
+        ),
+        (
+            {"error": {"code": "-5002", "message": "No records found"}},
+            "-5002",
+            "No records found",
+        ),
+        (
+            {"error": {"code": 0, "message": {"lang": "en", "value": "Auth error"}}},
+            "0",
+            "Auth error",
+        ),
+        ({"detail": "not SAP format"}, "unknown", "HTTP 400"),
+    ],
+)
+def test_parse_sap_error_shapes(body, exp_code, exp_fragment):
+    r = _mock_resp(400, body)
+    code, msg = RestAdapter._parse_sap_error(r)
+    assert code == exp_code
+    assert exp_fragment in msg
+
+
+def test_parse_sap_error_non_json():
+    r = _mock_resp(500, json_raises=True)
+    r.reason = "Internal Server Error"
+    code, msg = RestAdapter._parse_sap_error(r)
+    assert code == "unknown"
+    assert "500" in msg
+
+
+# ── Password never appears in debug logs ─────────────────────────────────── #
+
+
+def test_password_not_logged(adapter, caplog):
+    """The Password field must be redacted before any log statement in _do."""
+    import logging
+
+    with caplog.at_level(logging.DEBUG, logger="b1sl.b1sl.rest_adapter"):
+        with patch.object(adapter, "_execute_request") as mock_exec:
+            mock_resp = MagicMock()
+            mock_resp.status_code = 200
+            mock_resp.reason = "OK"  # must be str for Result.message
+            mock_resp.content = b'{"SessionId":"abc","Version":"1","SessionTimeout":30}'
+            mock_resp.json.return_value = {
+                "SessionId": "abc",
+                "Version": "1",
+                "SessionTimeout": 30,
+            }
+            mock_resp.headers = {}
+            mock_resp.raise_for_status.return_value = None
+            mock_exec.return_value = mock_resp
+            adapter._do(
+                http_method="POST",
+                endpoint="/Login",
+                data={
+                    "UserName": "manager",
+                    "Password": "s3cr3t",
+                    "CompanyDB": "TESTDB",
+                },
+                _is_login=True,
+            )
+    full_log = " ".join(caplog.messages)
+    assert "s3cr3t" not in full_log, "Raw password found in log output!"
+    assert "***" in full_log, "Password redaction marker '***' missing from log"
+
+
+# ── Timeout passed to session.request ────────────────────────────────────── #
+
+
+def test_execute_request_passes_timeout(adapter):
+    with patch.object(adapter.session, "request") as mock_req:
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.headers = {}
+        mock_req.return_value = mock_resp
+        adapter._execute_request("GET", "https://sap/b1s/v1/Items", {}, None, None)
+    _, kwargs = mock_req.call_args
+    assert "timeout" in kwargs
+    assert kwargs["timeout"] == (5.0, 30.0)