test: cover union argument boundary cases (null payload, non-contiguous codes, dense)

Add unit tests for _scalar_to_py/TaggedUnion exercising the previously
untested branches: non-contiguous type codes (tag resolved via
type_codes.index, not member position), dense unions (what DuckDB emits),
and the null-valued union slot branch.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: rustyconover

tests/test_union_argument.py

@@ -48,6 +48,61 @@ def test_union_arg_other_member() -> None:
     assert got.value == {"C": [1.0, 10.0], "kernel": ["rbf", "linear"]}
 
 
+def test_union_arg_null_payload() -> None:
+    """A null union slot decodes its value to None (the ``inner is None`` branch).
+
+    Note: pyarrow reports ``type_code == 0`` for any null union slot regardless of
+    the codes buffer, so the active member's tag is not recoverable at the scalar
+    level for a null payload — only the value is. (Tag preservation for a
+    non-null payload of a non-zero-code member is covered above and through the
+    batch-level round-trip in the echo integration suite.)
+    """
+    scalar = _union_scalar(1, {"svc": None})
+    got = Arguments(named={"config": scalar}).get("config")
+    assert isinstance(got, TaggedUnion)
+    assert got.value is None
+
+
+def test_union_arg_non_contiguous_type_codes() -> None:
+    """Tag resolution maps via type_codes, not member position.
+
+    Type codes need not be 0,1,2,...; ``_scalar_to_py`` must locate the active
+    member by ``type_codes.index(code)`` rather than treating the code as a
+    positional index.
+    """
+    arr = pa.UnionArray.from_sparse(
+        pa.array([9], type=pa.int8()),
+        [
+            pa.array([{"n_estimators": [1], "max_depth": [2]}], type=_RF),
+            pa.array([{"C": [1.0], "kernel": ["rbf"]}], type=_SVC),
+        ],
+        field_names=["random_forest_classifier", "svc"],
+        type_codes=[5, 9],
+    )
+    got = Arguments(named={"config": arr[0]}).get("config")
+    assert isinstance(got, TaggedUnion)
+    assert got.tag == "svc"
+    assert got.value == {"C": [1.0], "kernel": ["rbf"]}
+
+
+def test_union_arg_dense_union() -> None:
+    """Dense unions (what DuckDB emits) decode the same as sparse."""
+    arr = pa.UnionArray.from_dense(
+        pa.array([1], type=pa.int8()),
+        pa.array([0], type=pa.int32()),
+        [
+            pa.array([], type=_RF),
+            pa.array([{"C": [2.0], "kernel": ["linear"]}], type=_SVC),
+        ],
+        field_names=["random_forest_classifier", "svc"],
+        type_codes=[0, 1],
+    )
+    got = Arguments(named={"config": arr[0]}).get("config")
+    assert isinstance(got, TaggedUnion)
+    assert got.tag == "svc"
+    assert got.value == {"C": [2.0], "kernel": ["linear"]}
+
+
 def test_non_union_args_unchanged() -> None:
     """Non-union arguments still decode via plain as_py()."""
     args = Arguments(named={"n": pa.scalar(5), "s": pa.scalar("hi")}, positional=(pa.scalar(1.5),))