etlplus 0.3.19__tar.gz → 0.3.22__tar.gz

{etlplus-0.3.19/etlplus.egg-info → etlplus-0.3.22}/PKG-INFO

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

{etlplus-0.3.19 → etlplus-0.3.22/etlplus.egg-info}/PKG-INFO

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

{etlplus-0.3.19 → etlplus-0.3.22}/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
@@ -111,7 +113,9 @@ 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.19 → etlplus-0.3.22}/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.19 → etlplus-0.3.22}/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
 -----

{etlplus-0.3.19 → etlplus-0.3.22}/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.22/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.19 → etlplus-0.3.22}/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
 -----
@@ -101,6 +101,7 @@ class TestBuildHttpAdapter:
         """
         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'}},

{etlplus-0.3.19 → etlplus-0.3.22}/tests/unit/api/test_u_types.py

@@ -1,8 +1,7 @@
 """
 :mod:`tests.unit.api.test_u_types` module.
 
-Unit tests for custom type aliases and data structures in
-:mod:`etlplus.api.types`.
+Unit tests for :mod:`etlplus.api.types`.
 """
 
 import pytest

etlplus-0.3.22/tests/unit/config/test_u_config_utils.py

@@ -0,0 +1,129 @@
+"""
+:mod:`tests.unit.config.test_u_config_utils` module.
+
+Unit tests for :mod:`etlplus.config.utils`.
+
+Notes
+-----
+- These tests are intentionally focused on functional behavior (input → output)
+    and avoid asserting implementation details.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from etlplus.config import utils as config_utils
+
+# SECTION: HELPERS ========================================================== #
+
+
+pytestmark = pytest.mark.unit
+
+
+# SECTION: FIXTURES ========================================================= #
+
+
+@pytest.fixture(name='vars_map_basic')
+def vars_map_basic_fixture() -> dict[str, str]:
+    """Provide a basic variables mapping for token substitution."""
+
+    return {'FOO': 'foo', 'BAR': 'bar'}
+
+
+@pytest.fixture(name='vars_map_nested')
+def vars_map_nested_fixture() -> dict[str, int]:
+    """Provide an integer variables mapping used in nested substitutions."""
+
+    return {'X': 1, 'Y': 2, 'Z': 3}
+
+
+# SECTION: TESTS ============================================================ #
+
+
+class TestDeepSubstitute:
+    """Unit test suite for :func:`etlplus.config.utils.deep_substitute`."""
+
+    def test_basic_substitution(self, vars_map_basic: dict[str, str]) -> None:
+        """Test substituting tokens across nested mappings and sequences."""
+
+        value = {'a': '${FOO}', 'b': 2, 'c': ['${BAR}', 3]}
+        result = config_utils.deep_substitute(value, vars_map_basic, None)
+
+        assert result == {'a': 'foo', 'b': 2, 'c': ['bar', 3]}
+
+    @pytest.mark.parametrize(
+        'value, expected',
+        [
+            pytest.param('', '', id='empty-string'),
+            pytest.param({}, {}, id='empty-dict'),
+            pytest.param([], [], id='empty-list'),
+            pytest.param(None, None, id='none'),
+        ],
+    )
+    def test_empty_inputs_passthrough(
+        self,
+        value: object,
+        expected: object,
+    ) -> None:
+        """Test that empty inputs are returned unchanged."""
+
+        result = config_utils.deep_substitute(value, None, None)
+        if expected is None:
+            assert result is None
+        else:
+            assert result == expected
+
+    def test_env_overrides_vars_map(
+        self,
+        vars_map_basic: dict[str, str],
+    ) -> None:
+        """
+        Test that ``env_map`` values are preferred over ``vars_map`` values.
+        """
+
+        value = {'a': '${FOO}', 'b': '${BAR}'}
+        env_map = {'FOO': 'envfoo'}
+
+        result = config_utils.deep_substitute(value, vars_map_basic, env_map)
+
+        assert result == {'a': 'envfoo', 'b': 'bar'}
+
+    def test_nested_structures(self, vars_map_nested: dict[str, int]) -> None:
+        """Test substituting tokens in nested structures, including tuples."""
+
+        value = {'a': ['${X}', {'b': '${Y}'}], 'c': ({'d': '${Z}'},)}
+        result = config_utils.deep_substitute(value, vars_map_nested, None)
+
+        # deep_substitute coerces substituted values to strings.
+        assert result == {'a': ['1', {'b': '2'}], 'c': ({'d': '3'},)}
+
+    def test_no_substitutions_needed(self) -> None:
+        """
+        Test returning the original value when no substitutions are required.
+        """
+
+        value = {'a': 1, 'b': [2, 3], 'c': {'d': 4}}
+        result = config_utils.deep_substitute(value, None, None)
+
+        assert result == value
+
+    def test_sets_and_frozensets(self) -> None:
+        """Test substituting tokens within set-like container structures."""
+
+        value = {'a': {'${FOO}', 'bar'}, 'b': frozenset(['${FOO}', 'baz'])}
+        result = config_utils.deep_substitute(value, {'FOO': 'f'}, None)
+
+        assert result['a'] == {'f', 'bar'}
+        assert result['b'] == frozenset({'f', 'baz'})
+
+    def test_token_not_found_returns_original(self) -> None:
+        """
+        Test that unknown tokens are left unchanged when no mapping provides a
+        value.
+        """
+
+        value = 'Hello ${MISSING}'
+        result = config_utils.deep_substitute(value, {'FOO': 'foo'}, None)
+
+        assert result == 'Hello ${MISSING}'

{etlplus-0.3.19 → etlplus-0.3.22}/tests/unit/config/test_u_connector.py

@@ -1,7 +1,7 @@
 """
 :mod:`tests.unit.config.test_u_connector` module.
 
-Unit tests for ``etlplus.config.connector``.
+Unit tests for :mod:`etlplus.config.connector`.
 
 Notes
 -----