etlplus 0.3.17__tar.gz → 0.3.21__tar.gz

{etlplus-0.3.17/etlplus.egg-info → etlplus-0.3.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: etlplus
-Version: 0.3.17
+Version: 0.3.21
 Summary: A Swiss Army knife for simple ETL operations
 Home-page: https://github.com/Dagitali/ETLPlus
 Author: ETLPlus Team

{etlplus-0.3.17 → etlplus-0.3.21/etlplus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: etlplus
-Version: 0.3.17
+Version: 0.3.21
 Summary: A Swiss Army knife for simple ETL operations
 Home-page: https://github.com/Dagitali/ETLPlus
 Author: ETLPlus Team

{etlplus-0.3.17 → etlplus-0.3.21}/etlplus.egg-info/SOURCES.txt

@@ -91,12 +91,14 @@ tests/unit/test_u_enums.py
 tests/unit/test_u_extract.py
 tests/unit/test_u_file.py
 tests/unit/test_u_load.py
+tests/unit/test_u_main.py
 tests/unit/test_u_mixins.py
 tests/unit/test_u_run.py
 tests/unit/test_u_run_helpers.py
 tests/unit/test_u_transform.py
 tests/unit/test_u_utils.py
 tests/unit/test_u_validate.py
+tests/unit/test_u_version.py
 tests/unit/api/conftest.py
 tests/unit/api/test_u_auth.py
 tests/unit/api/test_u_config.py
@@ -110,7 +112,10 @@ tests/unit/api/test_u_rate_limiter.py
 tests/unit/api/test_u_request_manager.py
 tests/unit/api/test_u_retry_manager.py
 tests/unit/api/test_u_transport.py
+tests/unit/api/test_u_types.py
+tests/unit/config/test_u_config_utils.py
 tests/unit/config/test_u_connector.py
+tests/unit/config/test_u_jobs.py
 tests/unit/config/test_u_pipeline.py
 tests/unit/validation/test_u_validation_utils.py
 tools/run_pipeline.py

{etlplus-0.3.17 → etlplus-0.3.21}/tests/integration/test_i_cli.py

@@ -21,8 +21,8 @@ from typing import TYPE_CHECKING
 import pytest
 
 if TYPE_CHECKING:  # pragma: no cover - typing helpers only
-    from tests._typing import CliInvoke
-    from tests._typing import JsonFactory
+    from tests.conftest import CliInvoke
+    from tests.conftest import JsonFactory
 
 
 # SECTION: HELPERS ========================================================== #

{etlplus-0.3.17 → etlplus-0.3.21}/tests/unit/api/test_u_auth.py

@@ -1,7 +1,7 @@
 """
 :mod:`tests.unit.api.test_u_auth` module.
 
-Unit tests for ``etlplus.api.auth``.
+Unit tests for :mod:`etlplus.api.auth`.
 
 Notes
 -----

{etlplus-0.3.17 → etlplus-0.3.21}/tests/unit/api/test_u_endpoint_client.py

@@ -1,7 +1,7 @@
 """
 :mod:`tests.unit.api.test_u_endpoint_client` module.
 
-Unit tests for ``etlplus.api.endpoint_client``.
+Unit tests for :mod:`etlplus.api.endpoint_client`.
 
 Notes
 -----
@@ -41,6 +41,12 @@ pytestmark = pytest.mark.unit
 
 EXAMPLE_BASE_URL = 'https://example.test'
 
+type CursorConfigFactory = Callable[..., CursorPaginationConfigMap]
+type StubRequestManager = Callable[
+    [Sequence[dict[str, Any]]],
+    list[dict[str, Any]],
+]
+
 # Optional Hypothesis import with safe stubs when missing.
 try:  # pragma: no try
     from hypothesis import given  # type: ignore[import-not-found]
@@ -110,6 +116,7 @@ def _page_responder(
     Callable[..., list[dict[str, Any]]]
         Handler compatible with ``patch_request_once``.
     """
+    # pylint: disable=unused-argument
 
     def _handler(
         self: EndpointClient,
@@ -155,6 +162,7 @@ def _stub_request_manager(
     ValueError
         If ``responses`` is empty.
     """
+    # pylint: disable=unused-argument
 
     if not responses:
         msg = 'responses must contain at least one payload'
@@ -375,12 +383,9 @@ class TestCursorPagination:
     )
     def test_page_size_normalizes(
         self,
-        cursor_cfg: Callable[..., CursorPaginationConfigMap],
+        cursor_cfg: CursorConfigFactory,
         client_factory: Callable[..., EndpointClient],
-        stub_request_manager: Callable[
-            [Sequence[dict[str, Any]]],
-            list[dict[str, Any]],
-        ],
+        stub_request_manager: StubRequestManager,
         raw_page_size: Any,
         expected_limit: int,
     ) -> None:
@@ -389,12 +394,11 @@ class TestCursorPagination:
 
         Parameters
         ----------
-        cursor_cfg : Callable[..., CursorPaginationConfigMap]
+        cursor_cfg : CursorConfigFactory
             Factory for cursor pagination config.
         client_factory : Callable[..., EndpointClient]
             Factory fixture used to construct :class:`EndpointClient`.
-        stub_request_manager : Callable[[Sequence[dict[str, Any]]],
-                                       list[dict[str, Any]]]
+        stub_request_manager : StubRequestManager
             Fixture that patches the underlying :class:`RequestManager`.
         raw_page_size : Any
             Raw page size input.
@@ -473,6 +477,7 @@ class TestRequestOptionIntegration:
         client_factory: Callable[..., EndpointClient],
     ) -> None:
         """Paginated iterations override RequestOptions params per call."""
+        # pylint: disable=unused-argument
 
         client = client_factory(base_url=EXAMPLE_BASE_URL, endpoints={})
         observed: list[RequestOptions] = []
@@ -512,24 +517,20 @@ class TestRequestOptionIntegration:
 
     def test_adds_limit_and_advances_cursor(
         self,
-        cursor_cfg: Callable[..., CursorPaginationConfigMap],
+        cursor_cfg: CursorConfigFactory,
         client_factory: Callable[..., EndpointClient],
-        stub_request_manager: Callable[
-            [Sequence[dict[str, Any]]],
-            list[dict[str, Any]],
-        ],
+        stub_request_manager: StubRequestManager,
     ) -> None:
         """
         Test that limit is added and cursor advances correctly.
 
         Parameters
         ----------
-        cursor_cfg : Callable[..., CursorPaginationConfigMap]
+        cursor_cfg : CursorConfigFactory
             Factory for cursor pagination config.
         client_factory : Callable[..., EndpointClient]
             Factory fixture used to construct :class:`EndpointClient`.
-        stub_request_manager : Callable[[Sequence[dict[str, Any]]],
-                                       list[dict[str, Any]]]
+        stub_request_manager : StubRequestManager
             Fixture that patches :class:`RequestManager` responses.
         """
         calls = stub_request_manager(
@@ -561,7 +562,7 @@ class TestRequestOptionIntegration:
         self,
         base_url: str,
         patch_request_once: Callable[[Callable[..., Any]], Callable[..., Any]],
-        cursor_cfg: Callable[..., CursorPaginationConfigMap],
+        cursor_cfg: CursorConfigFactory,
         client_factory: Callable[..., EndpointClient],
     ) -> None:
         """
@@ -577,7 +578,7 @@ class TestRequestOptionIntegration:
             Common base URL used across tests.
         patch_request_once : Callable[[Callable[..., Any]], Callable[..., Any]]
             Helper that patches the request helper for deterministic failures.
-        cursor_cfg : Callable[..., CursorPaginationConfigMap]
+        cursor_cfg : CursorConfigFactory
             Factory for cursor pagination config.
         client_factory : Callable[..., EndpointClient]
             Factory fixture used to construct :class:`EndpointClient`.
@@ -700,7 +701,7 @@ class TestRequestOptionIntegration:
 
     def test_retry_backoff_sleeps(
         self,
-        cursor_cfg: Callable[..., CursorPaginationConfigMap],
+        cursor_cfg: CursorConfigFactory,
         capture_sleeps: list[float],
         jitter: Callable[[list[float]], list[float]],
         patch_request_once: Callable[[Callable[..., Any]], Callable[..., Any]],
@@ -713,7 +714,7 @@ class TestRequestOptionIntegration:
 
         Parameters
         ----------
-        cursor_cfg : Callable[..., CursorPaginationConfigMap]
+        cursor_cfg : CursorConfigFactory
             Factory for cursor pagination config.
         capture_sleeps : list[float]
             List to capture sleep durations.

{etlplus-0.3.17 → etlplus-0.3.21}/tests/unit/api/test_u_rate_limiter.py

@@ -48,7 +48,7 @@ def fixed_limiter_fixture() -> RateLimiter:
     return RateLimiter.fixed(0.25)
 
 
-# SECTION: TESTS =========================================================== #
+# SECTION: TESTS ============================================================ #
 
 
 @pytest.mark.unit

etlplus-0.3.21/tests/unit/api/test_u_request_manager.py

@@ -0,0 +1,349 @@
+"""
+:mod:`tests.unit.api.test_u_request_manager` module.
+
+Unit tests for :class:`etlplus.api.request_manager.RequestManager`.
+
+These tests focus on:
+
+- Session-adapter plumbing (building and closing sessions).
+- Context-manager semantics (reuse + cleanup).
+- Delegation to request callables.
+
+The suite is intentionally lightweight and uses small doubles/mocks rather than
+real network sessions.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from typing import cast
+from unittest.mock import Mock
+
+import pytest
+
+from etlplus.api.request_manager import RequestManager
+
+# SECTION: HELPERS ========================================================== #
+
+
+pytestmark = pytest.mark.unit
+
+
+def _make_request_callable(
+    probe: RequestProbe,
+) -> Callable[..., dict[str, Any]]:
+    """Create a request callable that records inputs into ``probe``."""
+
+    def _request(
+        _method: str,
+        url: str,
+        *,
+        session: Any,
+        timeout: Any,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        probe.sessions_used.append(session)
+        probe.timeouts.append(timeout)
+        probe.urls.append(url)
+        probe.extra_kwargs.append(kwargs)
+        return {'url': url}
+
+    return _request
+
+
+@dataclass(slots=True)
+class DummySession:
+    """Lightweight session double-tracking ``close`` calls."""
+
+    closed: bool = False
+
+    def close(self) -> None:
+        """Close the session."""
+        self.closed = True
+
+
+@dataclass(slots=True)
+class SessionBuilderProbe:
+    """Callable probe for session-builder usage."""
+
+    session: DummySession
+    calls: list[Any]
+
+    def __call__(self, cfg: Any) -> DummySession:
+        self.calls.append(cfg)
+        return self.session
+
+
+@dataclass(slots=True)
+class RequestProbe:
+    """Callable probe for capturing arguments passed to a request callable."""
+
+    sessions_used: list[Any]
+    timeouts: list[Any]
+    urls: list[str]
+    extra_kwargs: list[dict[str, Any]]
+
+
+# SECTION: FIXTURES ========================================================= #
+
+
+@pytest.fixture(name='dummy_session')
+def dummy_session_fixture() -> DummySession:
+    """Return a fresh dummy session for each test."""
+
+    return DummySession()
+
+
+@pytest.fixture(name='session_builder')
+def session_builder_fixture(
+    dummy_session: DummySession,
+) -> SessionBuilderProbe:
+    """Provide a probe callable for adapter-session creation."""
+
+    return SessionBuilderProbe(session=dummy_session, calls=[])
+
+
+# SECTION: TESTS ============================================================ #
+
+
+class TestRequestManager:
+    """Unit tests for :class:`etlplus.api.request_manager.RequestManager`."""
+
+    def test_adapter_session_built_and_closed(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        session_builder: SessionBuilderProbe,
+    ) -> None:
+        """
+        Test that adapter configs yield a managed session that gets closed.
+        """
+
+        monkeypatch.setattr(
+            'etlplus.api.request_manager.build_session_with_adapters',
+            session_builder,
+        )
+
+        manager = RequestManager(
+            session_adapters=[{'prefix': 'https://', 'pool_connections': 2}],
+        )
+
+        probe = RequestProbe([], [], [], [])
+        request_callable = _make_request_callable(probe)
+
+        result = manager.request(
+            'GET',
+            'https://example.com/resource',
+            request_callable=request_callable,
+        )
+
+        assert result == {'url': 'https://example.com/resource'}
+        assert probe.sessions_used == [session_builder.session]
+        assert isinstance(session_builder.calls[0], tuple)
+        assert session_builder.session.closed is True
+
+    def test_context_manager_reuses_adapter_session(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        session_builder: SessionBuilderProbe,
+    ) -> None:
+        """Test that context manager reuses one adapter-backed session."""
+
+        monkeypatch.setattr(
+            'etlplus.api.request_manager.build_session_with_adapters',
+            session_builder,
+        )
+
+        manager = RequestManager(
+            session_adapters=[{'prefix': 'https://', 'pool_connections': 1}],
+        )
+
+        probe = RequestProbe([], [], [], [])
+        request_callable = _make_request_callable(probe)
+
+        with manager:
+            manager.request(
+                'GET',
+                'https://example.com/a',
+                request_callable=request_callable,
+            )
+            manager.request(
+                'GET',
+                'https://example.com/b',
+                request_callable=request_callable,
+            )
+            assert session_builder.session.closed is False
+
+        assert session_builder.session.closed is True
+        assert len(session_builder.calls) == 1
+        assert probe.sessions_used == [session_builder.session] * 2
+        assert probe.urls == ['https://example.com/a', 'https://example.com/b']
+        assert probe.timeouts == [
+            manager.default_timeout,
+            manager.default_timeout,
+        ]
+        assert probe.extra_kwargs == [{}, {}]
+
+    def test_invalid_session_adapters(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """
+        Test that bad adapter config does not raise during context enter/exit.
+        """
+        bad_adapters = cast(
+            Any,
+            [{'prefix': 'https://', 'pool_connections': 'bad'}],
+        )
+        manager = RequestManager(session_adapters=bad_adapters)
+
+        def _bad_builder(cfg: Any) -> None:  # pragma: no cover
+            raise ValueError('bad config')
+
+        monkeypatch.setattr(
+            'etlplus.api.request_manager.build_session_with_adapters',
+            _bad_builder,
+        )
+
+        # If this raises, pytest will fail the test automatically.
+        with manager:
+            pass
+
+    def test_request_delegates_to_request_once(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """
+        Test that ``request`` passes through the ``request_callable`` to
+        :meth:`request_once`.
+        """
+
+        manager = RequestManager()
+        request_once = Mock(return_value={'ok': True})
+        cb = Mock(return_value={'ok': 'cb'})
+
+        monkeypatch.setattr(
+            type(manager),
+            'request_once',
+            staticmethod(request_once),
+        )
+
+        result = manager.request('POST', 'http://test', request_callable=cb)
+
+        assert result == {'ok': True}
+        assert request_once.call_count == 1
+        args = request_once.call_args.args
+        kwargs = request_once.call_args.kwargs
+        assert args[:2] == ('POST', 'http://test')
+        assert kwargs['session'] is None
+        assert kwargs['timeout'] == manager.default_timeout
+        assert kwargs['request_callable'] is cb
+
+    def test_default_init_values(self) -> None:
+        """
+        Test that :class:`RequestManager` default initialization values are
+        stable and explicit.
+        """
+        manager = RequestManager()
+        assert manager.retry is None
+        assert manager.retry_network_errors is False
+        assert manager.default_timeout == 10.0
+        assert manager.session is None
+        assert manager.session_factory is None
+        assert manager.retry_cap == 30.0
+        assert manager.session_adapters is None
+
+    def test_context_manager_handles_exceptions(self) -> None:
+        """
+        Test that :meth:`__exit__` cleans up even when the managed block
+        raises an exception.
+        """
+        # pylint: disable=protected-access
+
+        manager = RequestManager()
+
+        class DummyExc(Exception):
+            """Dummy exception for context-manager testing."""
+
+        manager._ctx_session = DummySession()
+        manager._ctx_owns_session = True
+
+        with pytest.raises(DummyExc):
+            with manager:
+                raise DummyExc()
+
+        assert manager._ctx_session is None
+        assert manager._ctx_owns_session is False
+
+    def test_request_once_returns_callable(self) -> None:
+        """
+        Test that :meth:`request_once` returns the underlying callable's
+        result.
+        """
+        # pylint: disable=unused-argument
+
+        manager = RequestManager()
+
+        def _callable(*args: Any, **kwargs: Any) -> dict[str, Any]:
+            return {'ok': True}
+
+        result = manager.request_once(
+            'GET',
+            'http://x',
+            session=None,
+            timeout=1,
+            request_callable=_callable,
+        )
+
+        assert result == {'ok': True}
+
+    @pytest.mark.parametrize(
+        ('api_method', 'expected_method'),
+        [('get', 'GET'), ('post', 'POST')],
+    )
+    def test_http_shortcuts_delegate_to_request_once(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        api_method: str,
+        expected_method: str,
+    ) -> None:
+        """
+        Test that ``GET``/``POST`` call into :meth:`request_once` with the
+        right method.
+        """
+
+        manager = RequestManager()
+        request_once = Mock(return_value={'ok': True})
+
+        monkeypatch.setattr(
+            type(manager),
+            'request_once',
+            staticmethod(request_once),
+        )
+
+        func = getattr(manager, api_method)
+        assert callable(func)
+
+        assert func('http://x') == {'ok': True}
+        assert request_once.call_args.args[:2] == (expected_method, 'http://x')
+
+    def test_request_accepts_unknown_methods(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """
+        Test that unknown HTTP method strings are passed through unchanged.
+        """
+
+        manager = RequestManager()
+        request_once = Mock(return_value={'ok': True})
+
+        monkeypatch.setattr(
+            type(manager),
+            'request_once',
+            staticmethod(request_once),
+        )
+
+        assert manager.request('FOO', 'http://x') == {'ok': True}
+        assert request_once.call_args.args[:2] == ('FOO', 'http://x')

{etlplus-0.3.17 → etlplus-0.3.21}/tests/unit/api/test_u_transport.py

@@ -1,7 +1,7 @@
 """
 :mod:`tests.unit.api.test_u_transport` module.
 
-Unit tests for ``etlplus.api.transport``.
+Unit tests for :mod:`etlplus.api.transport`.
 
 Notes
 -----
@@ -20,6 +20,7 @@ import pytest
 import requests  # type: ignore[import]
 
 from etlplus.api.transport import build_http_adapter
+from etlplus.api.transport import build_session_with_adapters
 
 # SECTION: HELPERS ========================================================== #
 
@@ -67,6 +68,52 @@ class TestBuildHttpAdapter:
             total = getattr(mr, 'total', None)
             assert total in (0, 3)
 
+    def test_build_http_adapter_invalid_config(self):
+        """
+        Test that invalid config does not raise and returns a usable adapter.
+        """
+        cfg = {
+            'pool_connections': 'not-an-int',
+            'max_retries': {'total': 'bad'},
+        }
+        adapter = build_http_adapter(cfg)
+        assert isinstance(adapter, requests.adapters.HTTPAdapter)
+
+    def test_build_http_adapter_missing_keys(self):
+        """Test that missing keys are handled gracefully."""
+        cfg = {}
+        adapter = build_http_adapter(cfg)
+        assert isinstance(adapter, requests.adapters.HTTPAdapter)
+
+    def test_build_http_adapter_retry_dict_edge(self):
+        """Test retry dict with unknown keys is ignored."""
+        cfg = {
+            'max_retries': {'total': 2, 'unknown_key': 123},
+        }
+        adapter = build_http_adapter(cfg)
+        mr = adapter.max_retries
+        if isinstance(mr, int):
+            assert mr in (0, 2)
+        else:
+            assert getattr(mr, 'total', None) in (0, 2)
+
+    def test_build_session_with_adapters_invalid(self):
+        """
+        Test that invalid adapter configs are skipped but session is usable.
+        """
+        # pylint: disable=broad-exception-caught
+        adapters_cfg = [
+            {'prefix': 'https://', 'pool_connections': 'bad'},
+            {'prefix': 'http://', 'max_retries': {'total': 'bad'}},
+        ]
+        session = requests.Session()
+        # Should not raise
+        try:
+            session = build_session_with_adapters(adapters_cfg)
+        except Exception:
+            pytest.fail('build_session_with_adapters should not raise')
+        assert isinstance(session, requests.Session)
+
     def test_integer_retries_fallback(self) -> None:
         """Test handling integer max_retries fallback."""
         cfg = {