refactor(adms): drop broad except in factories, simplify _BindingData

M1 — ``create_client`` and ``create_async_client`` wrapped any
``Exception`` in ``ClientCreationError``.  Because ``load_from_env_or_mount``
already maps real config failures to ``ConfigError`` and explicit
``ValueError`` paths re-raise unchanged, the broad except only ever
caught internal SDK bugs (``KeyError``, ``AttributeError``, ``TypeError``)
and reported them to callers as "client creation failed", masking the
real fault.  Drop the catch-all so genuine bugs surface as themselves.

The ``ClientCreationError`` symbol remains exported from
``sap_cloud_sdk.adms.exceptions`` for any caller still catching it, but
the factories no longer raise it.  Update the test that asserted the
wrapping behaviour to assert pass-through instead.

M2 — ``_BindingData.validate`` iterated a hard-coded list of field names
via ``getattr(self, f)``.  Since the list is static and matches the
dataclass shape, switch to direct attribute access (a list of
``(name, value)`` tuples) — both clearer and friendlier to type checkers.

Author: adwitiyasushant

src/sap_cloud_sdk/adms/client.py

@@ -59,11 +59,7 @@
     _SERVICE_PATH,
     load_from_env_or_mount,
 )
-from sap_cloud_sdk.adms.exceptions import (
-    ClientCreationError,
-    ConfigError,
-    ScanNotCleanError,
-)
+from sap_cloud_sdk.adms.exceptions import ScanNotCleanError
 from sap_cloud_sdk.core.auth import TokenCache
 from sap_cloud_sdk.core.telemetry import Module, Operation, record_metrics
 
@@ -1581,23 +1577,16 @@ def create_client(
 
     Raises:
         ConfigError: If the binding configuration is missing or incomplete.
-        ClientCreationError: If client instantiation fails.
+        ValueError: If ``instance`` is an empty string.
     """
-    try:
-        if instance is not None and instance == "":
-            raise ValueError(
-                "instance must not be an empty string; omit it to use 'default'"
-            )
-        binding = config or load_from_env_or_mount(instance)
-        token_fetcher = IasTokenFetcher(config=binding, cache=token_cache)
-        http = AdmsHttp(config=binding, token_fetcher=token_fetcher, user_jwt=user_jwt)
-        return AdmsClient(http)
-    except (ConfigError, ValueError):
-        raise
-    except Exception as exc:
-        raise ClientCreationError(
-            f"Failed to create ADMS client for instance '{instance or 'default'}': {exc}"
-        ) from exc
+    if instance is not None and instance == "":
+        raise ValueError(
+            "instance must not be an empty string; omit it to use 'default'"
+        )
+    binding = config or load_from_env_or_mount(instance)
+    token_fetcher = IasTokenFetcher(config=binding, cache=token_cache)
+    http = AdmsHttp(config=binding, token_fetcher=token_fetcher, user_jwt=user_jwt)
+    return AdmsClient(http)
 
 
 def create_async_client(
@@ -1623,25 +1612,18 @@ def create_async_client(
 
     Raises:
         ConfigError: If binding configuration is missing or incomplete.
-        ClientCreationError: If client instantiation fails.
+        ValueError: If ``instance`` is an empty string.
     """
-    try:
-        if instance is not None and instance == "":
-            raise ValueError(
-                "instance must not be an empty string; omit it to use 'default'"
-            )
-        binding = config or load_from_env_or_mount(instance)
-        token_fetcher = IasTokenFetcher(config=binding, cache=token_cache)
-        http = AsyncAdmsHttp(
-            config=binding,
-            token_fetcher=token_fetcher,
-            client=http_client,
-            user_jwt=user_jwt,
-        )
-        return AsyncAdmsClient(http)
-    except (ConfigError, ValueError):
-        raise
-    except Exception as exc:
-        raise ClientCreationError(
-            f"Failed to create async ADMS client for instance '{instance or 'default'}': {exc}"
-        ) from exc
+    if instance is not None and instance == "":
+        raise ValueError(
+            "instance must not be an empty string; omit it to use 'default'"
+        )
+    binding = config or load_from_env_or_mount(instance)
+    token_fetcher = IasTokenFetcher(config=binding, cache=token_cache)
+    http = AsyncAdmsHttp(
+        config=binding,
+        token_fetcher=token_fetcher,
+        client=http_client,
+        user_jwt=user_jwt,
+    )
+    return AsyncAdmsClient(http)

src/sap_cloud_sdk/adms/config.py

@@ -73,8 +73,16 @@ class _BindingData:
     resource: str = ""  # Optional IAS resource URI (app provider name)
 
     def validate(self) -> None:
-        required = ["clientid", "clientsecret", "url", "uri"]
-        missing = [f for f in required if not getattr(self, f)]
+        missing = [
+            name
+            for name, value in (
+                ("clientid", self.clientid),
+                ("clientsecret", self.clientsecret),
+                ("url", self.url),
+                ("uri", self.uri),
+            )
+            if not value
+        ]
         if missing:
             raise ConfigError(
                 f"ADMS binding is missing required fields: {', '.join(missing)}"

tests/adms/unit/test_client.py

@@ -143,12 +143,17 @@ def test_raises_config_error_on_missing_binding(self):
             with pytest.raises(ConfigError, match="missing fields"):
                 create_client(instance="nonexistent-instance")
 
-    def test_wraps_unexpected_exception_in_client_creation_error(self):
+    def test_unexpected_exception_propagates_as_is(self):
+        """Real bugs (e.g. ``RuntimeError`` from internal logic) must surface
+        as themselves rather than being silently wrapped — wrapping makes
+        debugging harder and previously masked SDK programming errors as
+        "client creation failed".
+        """
         with patch(
             "sap_cloud_sdk.adms.client.load_from_env_or_mount",
             side_effect=RuntimeError("unexpected"),
         ):
-            with pytest.raises(ClientCreationError, match="Failed to create ADMS client"):
+            with pytest.raises(RuntimeError, match="unexpected"):
                 create_client(instance="bad-instance")
 
     def test_returns_adms_client_on_success(self):