fix(athena): allow spark_connect_max_retries=0 at profile load

The retry-semantics fix turned `max_retries=0` into a valid setting
("no retries, single attempt"), but the profile-load validator at
`AthenaCredentials.__post_init__` still rejected anything below 1,
so the new value crashed before the runtime could see it.

Generalize the validator to a per-field minimum: max_retries allows
non-negative; counts / sizes / timeouts stay positive.

Author: dtaniwaki

dbt-athena/src/dbt/adapters/athena/connections.py

@@ -51,9 +51,9 @@
 from dbt.adapters.sql import SQLConnectionManager
 
 
-def _is_positive_int(value: Any) -> bool:
+def _is_int_at_least(value: Any, minimum: int) -> bool:
     try:
-        return int(value) >= 1
+        return int(value) >= minimum
     except (TypeError, ValueError):
         return False
 
@@ -102,19 +102,22 @@ class AthenaCredentials(Credentials):
     def __post_init__(self) -> None:
         # Validate Spark Connect integer fields at profile load so a typo
         # cannot wait until a python model is submitted to surface.
-        for field_name in (
-            "spark_connect_max_sessions",
-            "spark_connect_session_concurrency",
-            "spark_connect_dpu_budget",
-            "spark_connect_pool_acquire_timeout",
-            "spark_connect_max_retries",
+        # max_retries allows 0 (= no retries, single attempt); other knobs
+        # are counts/sizes/timeouts where 0 has no meaning.
+        for field_name, minimum in (
+            ("spark_connect_max_sessions", 1),
+            ("spark_connect_session_concurrency", 1),
+            ("spark_connect_dpu_budget", 1),
+            ("spark_connect_pool_acquire_timeout", 1),
+            ("spark_connect_max_retries", 0),
         ):
             raw = getattr(self, field_name)
             if raw is None:
                 continue
-            if not _is_positive_int(raw):
+            if not _is_int_at_least(raw, minimum):
+                bound = "non-negative" if minimum == 0 else "positive"
                 raise DbtRuntimeError(
-                    f"{field_name} must be a positive integer (got {raw!r}). "
+                    f"{field_name} must be a {bound} integer (got {raw!r}). "
                     "Omit the field to use the default."
                 )
             setattr(self, field_name, int(raw))

dbt-athena/tests/unit/test_credentials_validation.py

@@ -0,0 +1,71 @@
+import pytest
+
+from dbt.adapters.athena.connections import AthenaCredentials
+from dbt_common.exceptions import DbtRuntimeError
+
+from tests.unit import constants
+
+
+def _make(**overrides):
+    base = dict(
+        database=constants.DATA_CATALOG_NAME,
+        schema=constants.DATABASE_NAME,
+        s3_staging_dir=constants.S3_STAGING_DIR,
+        region_name=constants.AWS_REGION,
+        work_group=constants.ATHENA_WORKGROUP,
+        spark_work_group=constants.SPARK_WORKGROUP,
+    )
+    base.update(overrides)
+    return AthenaCredentials(**base)
+
+
+class TestSparkConnectIntegerValidation:
+    """Profile-load validation guards against typos in Spark Connect int fields."""
+
+    def test_max_retries_zero_is_accepted(self):
+        # 0 retries = single attempt; allowed semantic since rebuild 15 fix.
+        c = _make(spark_connect_max_retries=0)
+        assert c.spark_connect_max_retries == 0
+
+    def test_max_retries_positive_is_accepted(self):
+        c = _make(spark_connect_max_retries=3)
+        assert c.spark_connect_max_retries == 3
+
+    def test_max_retries_negative_is_rejected(self):
+        with pytest.raises(
+            DbtRuntimeError, match="spark_connect_max_retries must be a non-negative integer"
+        ):
+            _make(spark_connect_max_retries=-1)
+
+    @pytest.mark.parametrize(
+        "field_name",
+        [
+            "spark_connect_max_sessions",
+            "spark_connect_session_concurrency",
+            "spark_connect_dpu_budget",
+            "spark_connect_pool_acquire_timeout",
+        ],
+    )
+    def test_count_fields_reject_zero(self, field_name):
+        # Counts / sizes / timeouts have no meaning at 0 — keep the strict guard.
+        with pytest.raises(DbtRuntimeError, match=f"{field_name} must be a positive integer"):
+            _make(**{field_name: 0})
+
+    @pytest.mark.parametrize(
+        "field_name",
+        [
+            "spark_connect_max_sessions",
+            "spark_connect_session_concurrency",
+            "spark_connect_dpu_budget",
+            "spark_connect_pool_acquire_timeout",
+        ],
+    )
+    def test_count_fields_accept_one(self, field_name):
+        c = _make(**{field_name: 1})
+        assert getattr(c, field_name) == 1
+
+    def test_none_is_passed_through(self):
+        # Explicitly omitted fields stay None so the runtime falls back to defaults.
+        c = _make()
+        assert c.spark_connect_max_retries is None
+        assert c.spark_connect_dpu_budget is None