etlplus 0.8.4__tar.gz → 0.8.6__tar.gz

{etlplus-0.8.4/etlplus.egg-info → etlplus-0.8.6}/PKG-INFO

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

{etlplus-0.8.4 → etlplus-0.8.6/etlplus.egg-info}/PKG-INFO

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

{etlplus-0.8.4 → etlplus-0.8.6}/tests/unit/cli/test_u_cli_handlers.py

@@ -374,7 +374,7 @@ class TestCheckHandler:
         dummy_cfg: PipelineConfig,
         capture_io: dict[str, list],
     ) -> None:
-        """Test that ``check`` prints requested sections."""
+        """Test that :func:`check_handler` prints requested sections."""
         monkeypatch.setattr(
             handlers,
             'load_pipeline_config',
@@ -399,7 +399,9 @@ class TestExtractHandler:
         monkeypatch: pytest.MonkeyPatch,
         capture_io: dict[str, list],
     ) -> None:
-        """Test that non-stdin sources invoke extract and emit results."""
+        """
+        Test that :func:`extract_handler` uses extract for non-stdin sources.
+        """
         observed: dict[str, object] = {}
 
         def fake_extract(
@@ -439,7 +441,7 @@ class TestExtractHandler:
         capture_io: dict[str, list],
     ) -> None:
         """
-        Test that explicit format hints are forwarded for file extractions.
+        Test that :func:`extract_handler` forwards explicit file format hints.
         """
         captured: dict[str, object] = {}
 
@@ -472,7 +474,9 @@ class TestExtractHandler:
         monkeypatch: pytest.MonkeyPatch,
         capture_io: dict[str, list],
     ) -> None:
-        """Test that stdin source bypasses extract and emits parsed data."""
+        """
+        Test that :func:`extract_handler` reads stdin and emits parsed data.
+        """
         monkeypatch.setattr(
             handlers.cli_io,
             'read_stdin_text',
@@ -504,13 +508,14 @@ class TestExtractHandler:
         ]
         assert capture_io['emit_or_write'] == []
 
-    def test_suppresses_emit_when_output_written(
+    def test_writes_output_file_and_skips_emit(
         self,
         monkeypatch: pytest.MonkeyPatch,
         capture_io: dict[str, list],
     ) -> None:
         """
-        Test that Extract skips stdout emission when output file is provided.
+        Test that :func:`extract_handler` writes to a file and skips stdout
+        emission.
         """
         observed: dict[str, object] = {}
 
@@ -554,7 +559,7 @@ class TestLoadHandler:
         monkeypatch: pytest.MonkeyPatch,
         capture_io: dict[str, list],
     ) -> None:
-        """Test that file target streams payload."""
+        """Test that :func:`load_handler` streams payload for file targets."""
         recorded: dict[str, object] = {}
 
         def fake_materialize(
@@ -601,7 +606,7 @@ class TestLoadHandler:
         capture_io: dict[str, list],
     ) -> None:
         """
-        Test that stdin payloads are parsed and routed through :func:`load`.
+        Test that :func:`load_handler` parses stdin and routes through load.
         """
         read_calls = {'count': 0}
 
@@ -685,7 +690,8 @@ class TestLoadHandler:
         capture_io: dict[str, list],
     ) -> None:
         """
-        Test that writing to a file skips stdout emission after :func:`load`.
+        Test that :func:`load_handler` writes to a file and skips stdout
+        emission.
         """
         load_record: dict[str, object] = {}
 
@@ -740,7 +746,7 @@ class TestRenderHandler:
         self,
         capsys: pytest.CaptureFixture[str],
     ) -> None:
-        """Test that missing configs/specs surfaces a helpful error."""
+        """Test that :func:`render_handler` reports missing specs."""
 
         assert (
             handlers.render_handler(
@@ -762,7 +768,7 @@ class TestRenderHandler:
         widget_spec_paths: tuple[Path, Path],
         capsys: pytest.CaptureFixture[str],
     ) -> None:
-        """Test rendering a standalone spec to a file."""
+        """Test that :func:`render_handler` writes SQL for standalone specs."""
         spec_path, output_path = widget_spec_paths
         assert (
             handlers.render_handler(
@@ -788,14 +794,310 @@ class TestRenderHandler:
 class TestRunHandler:
     """Unit test suite for :func:`run_handler`."""
 
+    def test_emits_pipeline_summary_without_job(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        dummy_cfg: PipelineConfig,
+        capture_io: dict[str, list],
+    ) -> None:
+        """Test that :func:`run_handler` emits a summary when no job set."""
+        monkeypatch.setattr(
+            handlers,
+            'load_pipeline_config',
+            lambda path, substitute: dummy_cfg,
+        )
+
+        assert (
+            handlers.run_handler(
+                config='pipeline.yml',
+                job=None,
+                pipeline=None,
+                pretty=True,
+            )
+            == 0
+        )
+
+        assert capture_io['emit_json'] == [
+            (
+                (
+                    {
+                        'name': dummy_cfg.name,
+                        'version': dummy_cfg.version,
+                        'sources': ['s1'],
+                        'targets': ['t1'],
+                        'jobs': ['j1'],
+                    },
+                ),
+                {'pretty': True},
+            ),
+        ]
+
+    def test_runs_job_and_emits_result(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        dummy_cfg: PipelineConfig,
+        capture_io: dict[str, list],
+    ) -> None:
+        """
+        Test that :func:`run_handler` executes a named job and emits status.
+        """
+        monkeypatch.setattr(
+            handlers,
+            'load_pipeline_config',
+            lambda path, substitute: dummy_cfg,
+        )
+        run_calls: dict[str, object] = {}
+
+        def fake_run(*, job: str, config_path: str) -> dict[str, object]:
+            run_calls['params'] = (job, config_path)
+            return {'job': job, 'ok': True}
+
+        monkeypatch.setattr(handlers, 'run', fake_run)
+
+        assert (
+            handlers.run_handler(
+                config='pipeline.yml',
+                job='job1',
+                pretty=False,
+            )
+            == 0
+        )
+        assert run_calls['params'] == ('job1', 'pipeline.yml')
+        assert capture_io['emit_json'] == [
+            (
+                ({'status': 'ok', 'result': {'job': 'job1', 'ok': True}},),
+                {'pretty': False},
+            ),
+        ]
+
 
 class TestTransformHandler:
     """Unit test suite for :func:`transform_handler`."""
 
+    def test_emits_result_without_target(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        capture_io: dict[str, list],
+    ) -> None:
+        """Test that :func:`transform_handler` emits results with no target."""
+        resolve_calls: list[tuple[object, str | None, bool]] = []
+
+        def fake_resolve(
+            source: object,
+            *,
+            format_hint: str | None,
+            format_explicit: bool,
+        ) -> object:
+            resolve_calls.append((source, format_hint, format_explicit))
+            if source == 'data.json':
+                return [{'id': 1}]
+            return {'select': ['id']}
+
+        monkeypatch.setattr(
+            handlers.cli_io,
+            'resolve_cli_payload',
+            fake_resolve,
+        )
+        monkeypatch.setattr(
+            handlers,
+            'transform',
+            lambda payload, ops: {'rows': payload, 'ops': ops},
+        )
+
+        assert (
+            handlers.transform_handler(
+                source='data.json',
+                operations='ops.json',
+                source_format='json',
+                target=None,
+                pretty=False,
+            )
+            == 0
+        )
+        assert resolve_calls == [
+            ('data.json', 'json', True),
+            ('ops.json', None, True),
+        ]
+        assert capture_io['emit_json'] == [
+            (
+                ({'rows': [{'id': 1}], 'ops': {'select': ['id']}},),
+                {'pretty': False},
+            ),
+        ]
+
+    def test_writes_target_file(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        """Test that :func:`transform_handler` writes data to a target file."""
+        monkeypatch.setattr(
+            handlers.cli_io,
+            'resolve_cli_payload',
+            lambda source, **_kwargs: {'source': source}
+            if source == 'data.json'
+            else {'select': ['id']},
+        )
+        monkeypatch.setattr(
+            handlers,
+            'transform',
+            lambda payload, ops: {'payload': payload, 'ops': ops},
+        )
+        write_calls: dict[str, object] = {}
+
+        def fake_write(
+            path: str,
+            data: object,
+            *,
+            file_format: str | None,
+        ) -> None:
+            write_calls['params'] = (path, data, file_format)
+
+        monkeypatch.setattr(handlers.File, 'write_file', fake_write)
+
+        assert (
+            handlers.transform_handler(
+                source='data.json',
+                operations='ops.json',
+                target='out.json',
+                target_format='json',
+                pretty=True,
+            )
+            == 0
+        )
+        assert write_calls['params'] == (
+            'out.json',
+            {
+                'payload': {'source': 'data.json'},
+                'ops': {'select': ['id']},
+            },
+            'json',
+        )
+        assert (
+            'Data transformed and saved to out.json' in capsys.readouterr().out
+        )
+
 
 class TestValidateHandler:
     """Unit test suite for :func:`validate_handler`."""
 
+    def test_emits_result_without_target(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        capture_io: dict[str, list],
+    ) -> None:
+        """Test that :func:`validate_handler` emits results with no target."""
+        monkeypatch.setattr(
+            handlers.cli_io,
+            'resolve_cli_payload',
+            lambda source, **_kwargs: {'source': source}
+            if source == 'data.json'
+            else {'id': {'required': True}},
+        )
+        monkeypatch.setattr(
+            handlers,
+            'validate',
+            lambda payload, rules: {'data': payload, 'rules': rules},
+        )
+
+        assert (
+            handlers.validate_handler(
+                source='data.json',
+                rules='rules.json',
+                pretty=False,
+            )
+            == 0
+        )
+        assert capture_io['emit_json'] == [
+            (
+                (
+                    {
+                        'data': {'source': 'data.json'},
+                        'rules': {'id': {'required': True}},
+                    },
+                ),
+                {'pretty': False},
+            ),
+        ]
+
+    def test_reports_missing_data_for_target(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture[str],
+    ) -> None:
+        """Test that :func:`validate_handler` reports missing output data."""
+        monkeypatch.setattr(
+            handlers.cli_io,
+            'resolve_cli_payload',
+            lambda source, **_kwargs: {'source': source}
+            if source == 'data.json'
+            else {'id': {'required': True}},
+        )
+        monkeypatch.setattr(
+            handlers,
+            'validate',
+            lambda *_args, **_kwargs: {'data': None},
+        )
+
+        assert (
+            handlers.validate_handler(
+                source='data.json',
+                rules='rules.json',
+                target='out.json',
+                pretty=True,
+            )
+            == 0
+        )
+        assert (
+            'Validation failed, no data to save for out.json'
+            in capsys.readouterr().err
+        )
+
+    def test_writes_target_file(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """Test that: func: `validate_handler` writes data to a target file."""
+        monkeypatch.setattr(
+            handlers.cli_io,
+            'resolve_cli_payload',
+            lambda source, **_kwargs: {'source': source}
+            if source == 'data.json'
+            else {'id': {'required': True}},
+        )
+        monkeypatch.setattr(
+            handlers,
+            'validate',
+            lambda *_args, **_kwargs: {'data': {'id': 1}},
+        )
+        write_calls: dict[str, object] = {}
+
+        def fake_write(
+            data: object,
+            path: str | None,
+            *,
+            success_message: str,
+        ) -> bool:
+            write_calls['params'] = (data, path, success_message)
+            return True
+
+        monkeypatch.setattr(handlers.cli_io, 'write_json_output', fake_write)
+
+        assert (
+            handlers.validate_handler(
+                source='data.json',
+                rules='rules.json',
+                target='out.json',
+                pretty=True,
+            )
+            == 0
+        )
+        assert write_calls['params'] == (
+            {'id': 1},
+            'out.json',
+            'Validation result saved to',
+        )
+
 
 @pytest.mark.parametrize(
     'kwargs,expected_keys',