gss-bi-udfs 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

gss_bi_udfs/utils.py

@@ -0,0 +1,185 @@
+import os
+from pyspark.sql.types import (IntegerType, LongType, ShortType, ByteType,
+                               DecimalType, DoubleType, FloatType,
+                               DateType, TimestampType, BooleanType, StringType)
+from pyspark.sql.functions import lit, concat_ws, col
+from pyspark.sql import DataFrame, Column
+
+
+def get_env(default="dev"):
+    """
+    Obtiene el entorno de ejecución a partir de la variable de entorno ENV.
+    Si no está definida, retorna el valor por defecto indicado.
+
+    Parámetros:
+    - default (str): entorno por defecto a utilizar si ENV no está definida.
+
+    Retorna:
+    - str: nombre del entorno de ejecución (por ejemplo: 'dev', 'qa', 'prod').
+    """
+    
+    return os.getenv("ENV", default)
+
+def get_env_catalog(catalog):
+    """
+    Genera el nombre del catálogo ajustado al environment.
+
+    Parámetros:
+      catalog (str): Nombre base del catálogo (ej. 'fi_comunes').
+
+    Retorna:
+      str: Nombre del catálogo ajustado al environment.
+           Ejemplo: 'fi_comunes_dev' si ENV='dev'
+                    'fi_comunes' si ENV='pro'
+    """
+    
+    if get_env() == "pro":
+        return catalog
+    else:
+        return f"{catalog}_{get_env()}"
+    
+    
+def get_env_table_path(catalog, table_path):
+    """
+    Genera el path completo de una tabla incluyendo el sufijo de ambiente en el catálogo.
+
+    Parámetros:
+      catalog (str): Nombre base del catálogo (ej. 'fi_comunes').
+      table_path (str): Path de la tabla incluyendo esquema y nombre (ej. 'silver.dim_afiliado').
+
+    Retorna:
+      str: Path completo de la tabla ajustado al environment.
+           Ejemplo: 'fi_comunes_dev.silver.dim_afiliado' si ENV='dev'
+                    'fi_comunes.silver.dim_afiliado' si ENV='pro'
+    """
+
+    # Concatena el catálogo modificado con el path de la tabla
+    return f"{get_env_catalog(catalog)}.{table_path}"
+
+def get_schema_root_location(spark, catalog, schema):
+    """
+    Obtiene la ruta física (RootLocation) de un esquema específico, considerando el catálogo ajustado al ambiente.
+
+    Parámetros:
+      catalog (str): Nombre base del catálogo (ej. 'fi_comunes').
+      schema (str): Nombre del esquema dentro del catálogo (ej. 'silver').
+
+    Retorna:
+      str: Ruta física donde se almacenan los datos del esquema.
+           Ejemplo: 's3://bucket/path/fi_comunes_dev/silver' si ENV='dev'
+    
+    Requiere:
+      - La función get_env_catalog debe estar definida y retornar el nombre de catálogo ajustado al ambiente.
+      - SparkSession activa y permisos para ejecutar `DESCRIBE SCHEMA EXTENDED`.
+
+    Ejemplo:
+      >>> get_schema_root_location("fi_comunes", "silver")
+      's3://mi-bucket/datalake/fi_comunes_dev/silver'
+    """
+    cat = get_env_catalog(catalog)
+    df = spark.sql(f"DESCRIBE SCHEMA EXTENDED {cat}.{schema}")
+    return df.filter("database_description_item = 'RootLocation'") \
+             .select("database_description_value") \
+             .collect()[0][0]
+             
+def get_table_info(
+    spark,
+    *,
+    full_table_name: str = None,
+    catalog: str = None,
+    schema: str = None,
+    table: str = None
+) -> dict:
+    """
+    Devuelve información de una tabla a partir de:
+    - full_table_name (catalog.schema.table)
+    o
+    - catalog + schema + table
+    """
+
+    # -----------------------------
+    # 1. Resolver inputs
+    # -----------------------------
+    if full_table_name:
+        parts = full_table_name.split(".")
+        if len(parts) != 3:
+            raise ValueError(
+                "full_table_name debe tener formato catalog.schema.table"
+            )
+        catalog, schema, table = parts
+
+    elif catalog and schema and table:
+        full_table_name = f"{catalog}.{schema}.{table}"
+
+    else:
+        raise ValueError(
+            "Debe informar full_table_name o catalog + schema + table"
+        )
+
+    # -----------------------------
+    # 2. Environment catalog
+    # -----------------------------
+    catalog_env = get_env_catalog(catalog)
+
+    # -----------------------------
+    # 3. Path físico
+    # -----------------------------
+    root_location = get_schema_root_location(spark, catalog, schema)
+    path = f"{root_location.rstrip('/')}/{table}"
+
+    # -----------------------------
+    # 4. Metadata Spark (si existe)
+    # -----------------------------
+    info = {
+        "catalog": catalog_env,
+        "schema": schema,
+        "table": table,
+        "full_table_name": f"{catalog_env}.{schema}.{table}",
+        "path": path,
+        "exists": False,
+        "provider": None,
+        "table_type": None,
+    }
+
+    if spark.catalog.tableExists(info["full_table_name"]):
+        info["exists"] = True
+
+        desc = (
+            spark.sql(f"DESCRIBE EXTENDED {info['full_table_name']}")
+            .filter("col_name in ('Location', 'Provider', 'Type')")
+            .collect()
+        )
+
+        for row in desc:
+            if row.col_name == "Location":
+                info["path"] = row.data_type
+            elif row.col_name == "Provider":
+                info["provider"] = row.data_type
+            elif row.col_name == "Type":
+                info["table_type"] = row.data_type
+
+    return info
+
+
+    
+def get_default_value_by_type(dtype):
+        """
+        Devuelve "default" por tipo de dato para registros 'default/unknown'.
+        Parámetros:
+            - dtype: Tipo de dato (DataType) de PySpark.
+        Retorna:
+            - valor por defecto correspondiente al tipo de dato.
+        """
+        if isinstance(dtype, (IntegerType, LongType, ShortType, ByteType)):
+            return lit(-999)
+        if isinstance(dtype, (DecimalType, DoubleType, FloatType)):
+            return lit(-999)
+        if isinstance(dtype, (DateType, TimestampType)):
+            return lit("1900-01-01").cast(dtype)
+        if isinstance(dtype, BooleanType):
+            return lit(False)
+        if isinstance(dtype, StringType):
+            return lit("N/A")
+        return lit(None)
+    
+

{gss_bi_udfs-0.1.0.dist-info → gss_bi_udfs-0.1.2.dist-info}/METADATA

@@ -1,13 +1,20 @@
 Metadata-Version: 2.4
 Name: gss-bi-udfs
-Version: 0.1.0
+Version: 0.1.2
 Summary: Utilidades reutilizables para Spark y Delta Lake en arquitecturas Lakehouse.
 Author: Geronimo Forconi
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: pyspark>=3.0.0
 
 # gss-bi-udfs
+
 Creo modulo para guardar UDFs comunes a todas las areas de BI.
 
 
+# para compilar
+
+python3 -m build
+
+# para publicar
+
+python3 -m twine upload dist/*

gss_bi_udfs-0.1.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+gss_bi_udfs/__init__.py,sha256=VNj2_l7MHiRGF497XVM4KtU7p6JOX1xddkvFJLG1vUQ,152
+gss_bi_udfs/io.py,sha256=BZVf1BACH71MQFn-png1828E2WnNEwqTq3AxZR_UZWk,17173
+gss_bi_udfs/merges.py,sha256=4YHfw6TWU08ZWEMKBtFlMqj_tzXzjqkuM_CJn0uRNUI,7977
+gss_bi_udfs/transforms.py,sha256=yDg7uvPFSTrGXgy5rOUKDdSrRBBZSubfi9K-6rATCWY,1876
+gss_bi_udfs/utils.py,sha256=ryyqrzhybC6mZFTUWsnnrQXReUcLkVqw6e2gIf4Id_g,5982
+scripts/run_tests.py,sha256=6yG35rkURojbHmEnLKkPnHSn5bmViP7yJwng5hXj9xs,4407
+tests/test_io.py,sha256=oFTJK6UZJXec53lPoArWSHKPRpNGbhI8ZVb1ZjfXW8U,4847
+tests/test_merges.py,sha256=_PHYRU0DwRn5Vg05clz8jL7_d8QutWiiTACHLiNPrZo,2221
+tests/test_transforms.py,sha256=4fqKyemSV-4nfMzhTamaE5mWXnglV08uvw67sWj84Og,2206
+tests/test_utils.py,sha256=FUap5pqqEDvmBmBLeSBN39FoQDQSz3hpN4qCQrUniEU,4541
+workspace/main.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workspace/prueba.py,sha256=n-zGeMhFRrMLp9cx-vvJYTSFMZHCYm_R-xmGiQvj1Fk,223
+workspace/prueba_calculadora.py,sha256=4pu4Wg-h_aALbqDsfSeJlPbyx9FpODIbHGNAse5Mz5M,512
+workspace/tests/test_prueba_calculadora.py,sha256=9cHXunht_EVwBgBELv5YlazkJMWSi97A5VnB9Mvs-kU,257
+gss_bi_udfs-0.1.2.dist-info/METADATA,sha256=xcsXvP6SEvUiMh2g6XG85DycKXsFqom_cpV4Xpz6rgI,393
+gss_bi_udfs-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gss_bi_udfs-0.1.2.dist-info/top_level.txt,sha256=NzlGPsUajFQDfmDbDhTCgu4LBvrm0d1shuPSJIBpLfw,36
+gss_bi_udfs-0.1.2.dist-info/RECORD,,

{gss_bi_udfs-0.1.0.dist-info → gss_bi_udfs-0.1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gss_bi_udfs-0.1.2.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+gss_bi_udfs
+scripts
+tests
+workspace

scripts/run_tests.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+import argparse
+import datetime as dt
+import html
+import os
+import sys
+import unittest
+
+
+class _CollectingTextTestResult(unittest.TextTestResult):
+    def __init__(self, stream, descriptions, verbosity):
+        super().__init__(stream, descriptions, verbosity)
+        self.successes = []
+
+    def addSuccess(self, test):
+        super().addSuccess(test)
+        self.successes.append(test)
+
+
+def _run_tests(start_dir: str, pattern: str, verbosity: int) -> unittest.TestResult:
+    suite = unittest.defaultTestLoader.discover(start_dir=start_dir, pattern=pattern)
+    runner = unittest.TextTestRunner(verbosity=verbosity, resultclass=_CollectingTextTestResult)
+    return runner.run(suite)
+
+
+def _timestamped_path(path: str) -> str:
+    ts = dt.datetime.now().strftime("%Y%m%d_%H%M%S")
+    base, ext = os.path.splitext(path)
+    if ext:
+        return f"{base}_{ts}{ext}"
+    return f"{path}_{ts}"
+
+
+def _render_html(result: unittest.TestResult, output_path: str) -> None:
+    rows = []
+    for test in getattr(result, "successes", []):
+        rows.append(("PASS", str(test), ""))
+
+    for test, tb in result.failures + result.errors:
+        rows.append(
+            (
+                "FAIL" if (test, tb) in result.failures else "ERROR",
+                str(test),
+                tb,
+            )
+        )
+
+    for test, reason in result.skipped:
+        rows.append(("SKIP", str(test), reason))
+
+    status = "PASSED" if result.wasSuccessful() else "FAILED"
+    now = dt.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    html_body = [
+        "<!doctype html>",
+        "<html lang='en'>",
+        "<head>",
+        "  <meta charset='utf-8'/>",
+        "  <title>Unit Test Report</title>",
+        "  <style>",
+        "    body { font-family: Arial, sans-serif; margin: 24px; }",
+        "    .ok { color: #0f5132; }",
+        "    .bad { color: #842029; }",
+        "    table { border-collapse: collapse; width: 100%; margin-top: 16px; }",
+        "    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; vertical-align: top; }",
+        "    th { background: #f5f5f5; }",
+        "    pre { white-space: pre-wrap; margin: 0; }",
+        "  </style>",
+        "</head>",
+        "<body>",
+        f"  <h1>Unit Test Report</h1>",
+        f"  <p><strong>Generated:</strong> {html.escape(now)}</p>",
+        f"  <p><strong>Status:</strong> <span class='{'ok' if result.wasSuccessful() else 'bad'}'>{status}</span></p>",
+        f"  <p><strong>Ran:</strong> {result.testsRun} tests</p>",
+        f"  <p><strong>Pass:</strong> {len(getattr(result, 'successes', []))} | <strong>Failures:</strong> {len(result.failures)} | <strong>Errors:</strong> {len(result.errors)} | <strong>Skipped:</strong> {len(result.skipped)}</p>",
+        "  <table>",
+        "    <thead><tr><th>Type</th><th>Test</th><th>Details</th></tr></thead>",
+        "    <tbody>",
+    ]
+
+    if rows:
+        for row_type, test_name, details in rows:
+            html_body.append(
+                "      <tr>"
+                f"<td>{html.escape(row_type)}</td>"
+                f"<td>{html.escape(test_name)}</td>"
+                f"<td><pre>{html.escape(details)}</pre></td>"
+                "</tr>"
+            )
+    else:
+        html_body.append("      <tr><td colspan='3'>No failures, errors or skipped tests.</td></tr>")
+
+    html_body += [
+        "    </tbody>",
+        "  </table>",
+        "</body>",
+        "</html>",
+    ]
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write("\n".join(html_body))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run unittests and optionally write HTML report.")
+    parser.add_argument("--start-dir", default="tests")
+    parser.add_argument("--pattern", default="test*.py")
+    parser.add_argument("--verbosity", type=int, default=2)
+    parser.add_argument("--html", default="")
+    parser.add_argument("--timestamped", action="store_true")
+    args = parser.parse_args()
+
+    result = _run_tests(args.start_dir, args.pattern, args.verbosity)
+
+    if args.html:
+        output_path = _timestamped_path(args.html) if args.timestamped else args.html
+        _render_html(result, output_path)
+        print(f"HTML report written to: {output_path}")
+
+    return 0 if result.wasSuccessful() else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tests/test_io.py

@@ -0,0 +1,128 @@
+import tempfile
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+from gss_bi_udfs import io
+
+
+class TestIO(unittest.TestCase):
+    def test_normalize_path(self):
+        self.assertEqual(io._normalize_path("dbfs:/tmp/a.parquet"), "/tmp/a.parquet")
+        self.assertEqual(io._normalize_path("/tmp/a.parquet"), "/tmp/a.parquet")
+
+    def test_ls_path_local(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = Path(tmpdir) / "file.txt"
+            file_path.write_text("x", encoding="utf-8")
+            (Path(tmpdir) / "folder").mkdir()
+
+            files = io._ls_path(tmpdir)
+            names = sorted([f.name for f in files])
+            self.assertEqual(names, ["file.txt", "folder"])
+
+        self.assertEqual(io._ls_path("/path/that/does/not/exist"), [])
+
+    @patch("gss_bi_udfs.io._ls_path")
+    def test_load_latest_parquet_returns_latest_match(self, mock_ls_path):
+        mock_ls_path.return_value = [
+            SimpleNamespace(name="clientes_20240101.parquet", path="/tmp/1"),
+            SimpleNamespace(name="clientes_20240102.parquet", path="/tmp/2"),
+            SimpleNamespace(name="otra_tabla_20240103.parquet", path="/tmp/3"),
+        ]
+        spark = MagicMock()
+        expected_df = object()
+        spark.read.parquet.return_value = expected_df
+
+        out = io.load_latest_parquet(spark, "db", "sch", "clientes", env="dev")
+
+        self.assertIs(out, expected_df)
+        spark.read.parquet.assert_called_once_with("/tmp/2")
+
+    @patch("gss_bi_udfs.io._ls_path")
+    def test_load_latest_parquet_returns_none_without_matches(self, mock_ls_path):
+        mock_ls_path.return_value = [SimpleNamespace(name="x.parquet", path="/tmp/x")]
+        spark = MagicMock()
+
+        out = io.load_latest_parquet(spark, "db", "sch", "clientes", env="dev")
+
+        self.assertIsNone(out)
+        spark.read.parquet.assert_not_called()
+
+    @patch("gss_bi_udfs.io.load_latest_parquet")
+    def test_return_parquets_and_register_temp_views(self, mock_load_latest):
+        df = MagicMock()
+        mock_load_latest.return_value = df
+        spark = MagicMock()
+        tables_load = {
+            "db1": {
+                "sch1": [
+                    {"table": "t1", "view": "vw_t1"},
+                    {"table": "t2", "view": "vw_t2"},
+                ]
+            }
+        }
+
+        out = io.return_parquets_and_register_temp_views(spark, tables_load, env="dev")
+
+        self.assertEqual(set(out.keys()), {"db1.sch1.t1", "db1.sch1.t2"})
+        self.assertEqual(mock_load_latest.call_count, 2)
+        self.assertEqual(df.createOrReplaceTempView.call_count, 2)
+
+    @patch("gss_bi_udfs.io.load_latest_parquet")
+    def test_parquets_register_temp_views(self, mock_load_latest):
+        df = MagicMock()
+        mock_load_latest.return_value = df
+        spark = MagicMock()
+        tables_load = {"db1": {"sch1": [{"table": "t1", "view": "vw_t1"}]}}
+
+        io.parquets_register_temp_views(spark, tables_load, env="dev")
+
+        df.createOrReplaceTempView.assert_called_once_with("vw_t1")
+
+    @patch("gss_bi_udfs.io._ls_path")
+    @patch("pandas.read_excel")
+    def test_load_latest_excel(self, mock_read_excel, mock_ls_path):
+        mock_ls_path.return_value = [
+            SimpleNamespace(name="a_old", path="dbfs:/tmp/a_old", isFile=lambda: True),
+            SimpleNamespace(name="b_new", path="dbfs:/tmp/b_new", isFile=lambda: True),
+        ]
+        mock_pdf = object()
+        mock_read_excel.return_value = mock_pdf
+        spark = MagicMock()
+        expected_df = object()
+        spark.createDataFrame.return_value = expected_df
+
+        out = io.load_latest_excel(spark, "dom/sub/file", env="dev")
+
+        self.assertIs(out, expected_df)
+        mock_read_excel.assert_called_once_with("/tmp/b_new", header=0, engine="xlrd")
+        spark.createDataFrame.assert_called_once_with(mock_pdf)
+
+    def test_load_and_materialize_views_unknown_action(self):
+        out = io.load_and_materialize_views("accion_inexistente")
+        self.assertEqual(out, {})
+
+    @patch("gss_bi_udfs.io.get_table_info")
+    def test_save_table_to_delta_writes_delta(self, mock_get_table_info):
+        mock_get_table_info.return_value = {
+            "path": "/tmp/tbl",
+            "full_table_name": "cat.sch.tbl",
+        }
+        df = MagicMock()
+        writer = MagicMock()
+        writer.format.return_value = writer
+        writer.option.return_value = writer
+        writer.mode.return_value = writer
+        df.write = writer
+
+        io.save_table_to_delta(df, "cat", "sch", "tbl")
+
+        writer.format.assert_called_once_with("delta")
+        writer.mode.assert_called_once_with("overwrite")
+        writer.saveAsTable.assert_called_once_with("cat.sch.tbl")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_merges.py

@@ -0,0 +1,65 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from gss_bi_udfs import merges
+
+
+class TestMerges(unittest.TestCase):
+    def test_merge_scd2_raises_if_business_key_is_missing(self):
+        spark = MagicMock()
+        df_dim_src = MagicMock()
+        df_dim_src.columns = ["id", "descripcion"]
+
+        with self.assertRaises(ValueError):
+            merges.merge_scd2(
+                spark=spark,
+                df_dim_src=df_dim_src,
+                table_name="cat.sch.dim",
+                business_keys="codigo_negocio",
+                surrogate_key="sk_dim",
+            )
+
+    @patch("gss_bi_udfs.merges.save_table_to_delta")
+    @patch("gss_bi_udfs.merges.add_hashid")
+    @patch("gss_bi_udfs.merges.get_table_info")
+    def test_merge_scd2_full_load_path(self, mock_get_table_info, mock_add_hashid, mock_save_table):
+        spark = MagicMock()
+        spark.catalog.tableExists.return_value = False
+        mock_get_table_info.return_value = {
+            "catalog": "cat_dev",
+            "schema": "sch",
+            "table": "dim_cliente",
+            "full_table_name": "cat_dev.sch.dim_cliente",
+        }
+
+        df_dim_src = MagicMock()
+        df_dim_src.columns = ["codigo_negocio", "descripcion"]
+        df_dim_src.withColumn.return_value = df_dim_src
+
+        df_hashed = MagicMock()
+        writer = MagicMock()
+        writer.format.return_value = writer
+        writer.mode.return_value = writer
+        writer.option.return_value = writer
+        df_hashed.write = writer
+        mock_add_hashid.return_value = df_hashed
+
+        merges.merge_scd2(
+            spark=spark,
+            df_dim_src=df_dim_src,
+            table_name="cat.sch.dim_cliente",
+            business_keys="codigo_negocio",
+            surrogate_key="sk_dim_cliente",
+        )
+
+        mock_add_hashid.assert_called_once()
+        add_hashid_args = mock_add_hashid.call_args.args
+        self.assertEqual(add_hashid_args[1], ["codigo_negocio", "valid_from"])
+        self.assertEqual(add_hashid_args[2], "sk_dim_cliente")
+
+        self.assertEqual(mock_save_table.call_count, 1)
+        writer.saveAsTable.assert_called_once_with("cat.sch.dim_cliente")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_transforms.py

@@ -0,0 +1,66 @@
+import unittest
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+from gss_bi_udfs import transforms
+
+
+class _FakeCol:
+    def __init__(self, name):
+        self.name = name
+
+    def cast(self, dtype):
+        return f"{self.name}:{dtype}"
+
+
+class TestTransforms(unittest.TestCase):
+    def test_add_hashid_raises_when_columns_empty(self):
+        with self.assertRaises(ValueError):
+            transforms.add_hashid(MagicMock(), [])
+
+    @patch("gss_bi_udfs.transforms.xxhash64")
+    @patch("gss_bi_udfs.transforms.concat_ws")
+    @patch("gss_bi_udfs.transforms.col")
+    def test_add_hashid_builds_hash_and_reorders_columns(self, mock_col, mock_concat_ws, mock_xxhash64):
+        mock_col.side_effect = lambda name: _FakeCol(name)
+        mock_concat_ws.return_value = "concat_expr"
+        mock_xxhash64.return_value = "hash_expr"
+
+        df = MagicMock()
+        df.columns = ["id", "name"]
+        df_with_hash = MagicMock()
+        df.withColumn.return_value = df_with_hash
+        df_with_hash.select.return_value = "result_df"
+
+        out = transforms.add_hashid(df, ["id", "name"], "hash_pk")
+
+        self.assertEqual(out, "result_df")
+        df.withColumn.assert_called_once_with("hash_pk", "hash_expr")
+        df_with_hash.select.assert_called_once_with("hash_pk", "id", "name")
+
+    @patch("gss_bi_udfs.transforms.get_default_value_by_type")
+    def test_get_default_record_builds_single_row_with_schema_defaults(self, mock_defaults):
+        mock_defaults.side_effect = lambda dtype: f"default_for_{dtype}"
+        spark = MagicMock()
+        expected = object()
+        spark.createDataFrame.return_value = expected
+
+        df = MagicMock()
+        df.schema = SimpleNamespace(
+            fields=[
+                SimpleNamespace(name="id", dataType="int"),
+                SimpleNamespace(name="desc", dataType="string"),
+            ]
+        )
+
+        out = transforms.get_default_record(spark, df)
+
+        self.assertIs(out, expected)
+        spark.createDataFrame.assert_called_once_with(
+            [{"id": "default_for_int", "desc": "default_for_string"}],
+            schema=df.schema,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()