dbt-to-junit 0.1.3__py3-none-any.whl

dbt_to_junit-0.1.3.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: dbt-to-junit
+Version: 0.1.3
+Summary: Convert dbt's target/run_results.json into a JUnit XML report so Azure DevOps (ADO) can display dbt test results in the Tests tab.
+Project-URL: Documentation, https://github.com/jorgecontrerasostos/dbt-junit-xml#readme
+Project-URL: Issues, https://github.com/jorgecontrerasostos/dbt-junit-xml/issues
+Project-URL: Source, https://github.com/jorgecontrerasostos/dbt-junit-xml
+Author-email: Jorge Contreras <jorgecontrerasostos@gmail.com>
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: junit-xml>=1.9
+Provides-Extra: dev
+Requires-Dist: black>=24.8.0; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dbt to JUnit XML
+
+Convert dbt's `target/run_results.json` into a JUnit XML report so Azure DevOps (ADO) can display dbt test results in the Tests tab.
+
+This tool is designed for CI: it reads the run results produced by `dbt build`, generates a single JUnit report, and writes it to a file that can be published by ADO.
+
+## What it reads
+
+- **Input**: dbt `run_results.json` (typically `target/run_results.json`)
+- **Source of truth**: the `results` list inside that file
+- **Filtering**: by default, only dbt tests are included (`unique_id` starts with `test.`)
+
+## What it writes
+
+- **Output**: a JUnit XML file (default: `dbt-junit.xml`)
+- **Structure**: one `<testsuite>` containing one `<testcase>` per dbt test
+
+## Install / run (local)
+
+If you're using this repo with `uv`:
+
+```bash
+uv sync
+uv run dbt-junit-xml --input target/run_results.json --output dbt-junit.xml
+```
+
+You can also run it directly with Python:
+
+```bash
+python -m src.main --input target/run_results.json --output dbt-junit.xml
+```
+
+## CLI options
+
+- `--input`: path to `run_results.json` (default: `target/run_results.json`)
+- `--output`: output XML path (default: `dbt-junit.xml`)
+- `--log-level`: `DEBUG|INFO|WARNING|ERROR` (default: `INFO`)
+- `--include-models`: include non-test nodes as testcases (default: off)
+
+## Exit codes
+
+- **0**: report generated and no failing dbt tests
+- **1**: report generated and at least one dbt test failed/errored
+- **2**: could not generate report (missing file, invalid JSON, unexpected format, etc.)
+
+## Azure DevOps pipeline example
+
+Run dbt (which produces `target/run_results.json`), generate the JUnit XML, then publish it:
+
+```yaml
+- script: |
+    dbt build
+    dbt-junit-xml --input target/run_results.json --output dbt-junit.xml
+  displayName: "Run dbt and generate JUnit report"
+
+- task: PublishTestResults@2
+  displayName: "Publish dbt test results"
+  inputs:
+    testResultsFormat: "JUnit"
+    testResultsFiles: "dbt-junit.xml"
+    failTaskOnFailedTests: true
+```
+
+## Notes / tips
+
+- If your pipeline working directory is not the dbt project root, pass an explicit `--input` path.
+- If you only want dbt tests in ADO, do not pass `--include-models` (default behavior already filters to tests).

dbt_to_junit-0.1.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+src/__about__.py,sha256=oUBsQ9adNpfQDpe2S_hjfsQi5HKRYeNo1kJUJZbwV_k,68
+src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/main.py,sha256=-DlPCukpLhIrKZ8ptZ2l12B-3y3St6YgPV1jM6sAUl8,9969
+dbt_to_junit-0.1.3.dist-info/METADATA,sha256=KKLmUMrqU92CcfpFZF2LNKTQW4VrYBsDlZEl_gSyJQY,3500
+dbt_to_junit-0.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dbt_to_junit-0.1.3.dist-info/entry_points.txt,sha256=4gllZrQ06MnH2myqq-epC12fgbzKJsslqFrVxnNFauk,48
+dbt_to_junit-0.1.3.dist-info/licenses/LICENSE,sha256=uGf-ZjM9ze31xgitBaZZiWHnGf88sO5bnl3P2RO3Bik,1072
+dbt_to_junit-0.1.3.dist-info/RECORD,,

dbt_to_junit-0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dbt_to_junit-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dbt-junit-xml = src.main:main

dbt_to_junit-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jorge Contreras
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

src/__about__.py

@@ -0,0 +1,3 @@
+"""Version information for dbt-junit-xml."""
+
+__version__ = "0.1.3"

src/main.py

@@ -0,0 +1,269 @@
+import argparse
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from junit_xml import TestCase, TestSuite, to_xml_report_string
+
+logger = logging.getLogger(__name__)
+
+
+def _configure_logging(log_level: str) -> None:
+    """Configure logging for this command-line tool.
+
+    This function configures Python's standard library logging (the root logger)
+    with a simple, pipeline-friendly format so messages show up in the terminal
+    output of local runs and CI systems (e.g., Azure DevOps).
+
+    Notes:
+        - This uses `logging.basicConfig(...)`, which only has an effect the first
+          time it is called (unless the logging system is reset elsewhere).
+        - Any unknown `log_level` value falls back to `INFO`.
+
+    Args:
+        log_level: Logging level name (case-insensitive), for example:
+            - "DEBUG" to see verbose troubleshooting output
+            - "INFO" for normal operation
+            - "WARNING" / "ERROR" for quieter runs
+
+    Returns:
+        None.
+    """
+    logging.basicConfig(
+        level=getattr(logging, log_level.upper(), logging.INFO),
+        format="%(levelname)s %(message)s",
+    )
+
+
+def _read_run_results(path: Path) -> dict[str, Any]:
+    """Read and parse a dbt `run_results.json` file from disk.
+
+    dbt writes `run_results.json` to the `target/` directory when `--write-json`
+    is enabled (it is enabled by default for most dbt invocations). This tool
+    treats that file as the source of truth for building a JUnit XML report that
+    Azure DevOps can render in the "Tests" tab.
+
+    Args:
+        path: Path to the `run_results.json` file. This can be an absolute path
+            or a path relative to the current working directory.
+
+    Returns:
+        A dictionary representing the parsed JSON document.
+
+        The expected top-level shape (simplified) is:
+        - `metadata`: dict (optional but common)
+        - `results`: list of per-node result dictionaries (required for report)
+        - `args`: dict with invocation details such as `which` (optional)
+
+    Raises:
+        FileNotFoundError: If `path` does not exist or cannot be opened.
+        ValueError: If the file exists but is not valid JSON.
+    """
+    try:
+        with path.open(encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"run_results.json not found: {path}") from e
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Invalid JSON in {path}: {e}") from e
+
+
+def _to_junit_xml(
+    run_results: dict[str, Any], *, include_models: bool
+) -> tuple[str, int]:
+    """Convert parsed dbt run results into a JUnit XML report.
+
+    This function transforms dbt's `run_results.json` structure into a single
+    JUnit `<testsuite>` containing `<testcase>` entries. The resulting XML can
+    be published to Azure DevOps using the `PublishTestResults@2` task with
+    `testResultsFormat: JUnit`.
+
+    What gets included:
+        - By default (`include_models=False`), only dbt tests are included.
+          These can be identified by `unique_id` starting with `"test."`.
+        - If `include_models=True`, non-test nodes (e.g., models) are also
+          included as testcases.
+
+    How dbt statuses are mapped:
+        - "pass": testcase has no failure/error child elements (success)
+        - "skipped": testcase gets a `<skipped>` element
+        - "fail": testcase gets a `<failure>` element
+        - "error": testcase gets an `<error>` element
+        - anything else: if it's a dbt test, it's treated as an `<error>`
+
+    Naming and grouping:
+        - `classname` is derived from the first two `unique_id` segments so ADO
+          groups results nicely (e.g., `test.jaffle_shop`).
+        - `name` is the remaining portion of `unique_id`.
+        - If `metadata.invocation_id` is present, it is included in the suite name.
+
+    Args:
+        run_results: Parsed contents of dbt `run_results.json` (output of
+            `_read_run_results`).
+        include_models: Whether to include non-test nodes as JUnit testcases.
+            Keep this False if you only want dbt tests to appear in ADO.
+
+    Returns:
+        A tuple of:
+        - xml_report: A UTF-8 JUnit XML string (includes XML declaration).
+        - failing_test_count: Number of dbt *tests* (not models) that failed or
+          errored. This is useful for deciding process exit code in CI.
+
+    Raises:
+        ValueError: If:
+            - `args.which` is present and not `"build"` (this tool expects dbt
+              build artifacts), or
+            - the JSON does not contain a top-level `results` list.
+    """
+    which = run_results.get("args", {}).get("which")
+    if which and which != "build":
+        raise ValueError(f"Expected a dbt build artifact, got: {which}")
+
+    results = run_results.get("results")
+    if not isinstance(results, list):
+        raise ValueError("run_results.json missing a top-level 'results' list")
+
+    test_cases: list[TestCase] = []
+    failing_tests = 0
+
+    for result in results:
+        if not isinstance(result, dict):
+            continue
+
+        unique_id = str(result.get("unique_id", "unknown"))
+        status = str(result.get("status", "unknown"))
+        execution_time = result.get("execution_time")
+        elapsed_sec = (
+            float(execution_time) if isinstance(execution_time, (int, float)) else None
+        )
+
+        is_test = unique_id.startswith("test.")
+        if not include_models and not is_test:
+            continue
+
+        parts = unique_id.split(".")
+        classname = ".".join(parts[:2]) if len(parts) >= 2 else parts[0]
+        name = ".".join(parts[2:]) if len(parts) >= 3 else unique_id
+
+        test_case = TestCase(name=name, classname=classname, elapsed_sec=elapsed_sec)
+
+        message = result.get("message")
+        if message is None and isinstance(result.get("adapter_response"), dict):
+            message = result["adapter_response"].get("_message")
+        message_str = "" if message is None else str(message)
+
+        if status == "pass":
+            pass
+
+        if status == "skipped":
+            test_case.add_skipped_info(message=message_str or "skipped")
+
+        if status == "fail":
+            test_case.add_failure_info(
+                message=message_str or "dbt test failed", output=unique_id
+            )
+            if is_test:
+                failing_tests += 1
+
+        if status == "error":
+            test_case.add_error_info(
+                message=message_str or "dbt error", output=unique_id
+            )
+            if is_test:
+                failing_tests += 1
+
+        if status not in ["pass", "skipped", "fail", "error"]:
+            if is_test:
+                test_case.add_error_info(
+                    message=f"Unknown dbt status: {status}", output=unique_id
+                )
+                failing_tests += 1
+
+        test_cases.append(test_case)
+
+    suite_name = "dbt"
+    if "metadata" in run_results and isinstance(run_results["metadata"], dict):
+        invocation_id = run_results["metadata"].get("invocation_id")
+        if invocation_id:
+            suite_name = f"dbt ({invocation_id})"
+
+    suite = TestSuite(suite_name, test_cases=test_cases)
+
+    xml = to_xml_report_string([suite], encoding="utf-8")
+    return xml, failing_tests
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the CLI to convert dbt `run_results.json` into JUnit XML.
+
+    This is the entrypoint used by the `dbt-junit-xml` console script declared
+    in `pyproject.toml`. It reads a dbt `run_results.json` file, converts dbt
+    test results into a JUnit report, and writes the report to disk.
+
+    Typical usage (local):
+        - `dbt-junit-xml --input target/run_results.json --output dbt-junit.xml`
+
+    Typical usage (Azure DevOps):
+        1) Run `dbt build` (which produces `target/run_results.json`).
+        2) Run this tool to produce an XML file in the working directory.
+        3) Publish with `PublishTestResults@2` and `testResultsFormat: JUnit`.
+
+    Exit codes are designed for CI:
+        - 0 means the report was generated and there were no failing dbt tests.
+        - 1 means the report was generated but at least one dbt test failed.
+        - 2 means the report could not be generated (bad input, missing file, etc.).
+
+    Args:
+        argv: Optional list of CLI arguments (primarily for tests). If omitted,
+            arguments are read from `sys.argv` by `argparse`.
+
+    Returns:
+        The process exit code (0/1/2 as described above).
+    """
+    parser = argparse.ArgumentParser(
+        description="Convert dbt run_results.json to JUnit XML."
+    )
+    parser.add_argument(
+        "--input",
+        default=str(Path("target") / "run_results.json"),
+        help="Path to dbt run_results.json (default: target/run_results.json)",
+    )
+    parser.add_argument(
+        "--output",
+        default="dbt-junit.xml",
+        help="Path to write JUnit XML (default: dbt-junit.xml)",
+    )
+    parser.add_argument(
+        "--include-models",
+        action="store_true",
+        help="Include model results as testcases (default: only dbt tests).",
+    )
+    parser.add_argument(
+        "--log-level",
+        default="INFO",
+        help="Logging level (DEBUG, INFO, WARNING, ERROR). Default: INFO",
+    )
+    args = parser.parse_args(argv)
+    _configure_logging(args.log_level)
+
+    input_path = Path(args.input)
+    output_path = Path(args.output)
+
+    try:
+        run_results = _read_run_results(input_path)
+        xml, failing_tests = _to_junit_xml(
+            run_results, include_models=args.include_models
+        )
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(xml, encoding="utf-8")
+    except Exception as e:
+        logger.error(str(e))
+        return 2
+
+    logger.info("Wrote JUnit XML to %s", output_path)
+    return 1 if failing_tests > 0 else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())