refactor(ogc): simplify argument normalization

Author: thodson-usgs

dataretrieval/ogc/requests.py

@@ -294,13 +294,18 @@ def _check_monitoring_location_id(
     return value
 
 
-def _get_args(
+def prepare_request_args(
     local_vars: dict[str, Any],
     exclude: set[str] | None = None,
     *,
     no_normalize: frozenset[str] | set[str] = _NO_NORMALIZE_PARAMS,
 ) -> dict[str, Any]:
-    """Build the API-request kwargs dict from a getter's ``locals()``."""
+    """Build OGC request kwargs from a getter's ``locals()``.
+
+    Internal bookkeeping keys, caller-supplied exclusions, and ``None`` values
+    are omitted. Identifiers and properties are validated; other iterables are
+    normalized unless listed in ``no_normalize``.
+    """
     to_exclude = {"service", "output_id"}
     if exclude:
         to_exclude.update(exclude)
@@ -322,35 +327,5 @@ def _get_args(
     return args
 
 
-def prepare_request_args(
-    local_vars: dict[str, Any],
-    exclude: set[str] | None = None,
-    *,
-    no_normalize: frozenset[str] | set[str] = _NO_NORMALIZE_PARAMS,
-) -> dict[str, Any]:
-    """Public facade entry point for argument normalization.
-
-    Wraps :func:`_get_args` with the same inputs and behavior — builds the
-    API-request kwargs dict from a getter's ``locals()``, excluding internal
-    bookkeeping keys and normalizing iterable parameters. Service adapters
-    (NGWMN, Water Data utils) use this rather than importing the private
-    ``_get_args`` directly.
-
-    Parameters
-    ----------
-    local_vars : dict
-        A getter's ``locals()`` snapshot.
-    exclude : set of str, optional
-        Extra keys to drop beyond the default set (``service``, ``output_id``).
-    no_normalize : frozenset or set of str, optional
-        Parameter names whose iterable values should NOT be pushed through
-        ``_normalize_str_iterable`` (e.g. date-range params, bounding box,
-        numeric lists). Defaults to the OGC base set (date ranges + bbox);
-        callers with additional numeric params pass a superset.
-
-    Returns
-    -------
-    dict
-        Cleaned kwargs suitable for passing to request builders.
-    """
-    return _get_args(local_vars, exclude, no_normalize=no_normalize)
+# Compatibility alias for existing private imports from ``ogc.engine``.
+_get_args = prepare_request_args

tests/headers_host_scoping_test.py

@@ -3,13 +3,12 @@
 from __future__ import annotations
 
 import asyncio
-import os
 from unittest import mock
 
 import httpx
+import pytest
 
 from dataretrieval.utils import (
-    _AUTHORIZED_API_KEY_HOST,
     HTTPX_ASYNC_DEFAULTS,
     _default_headers,
     _get,
@@ -21,79 +20,70 @@ class TestDefaultHeadersHostScoping:
 
     FAKE_TOKEN = "test-fake-token-abc123"
 
+    @pytest.fixture(autouse=True)
+    def _api_token(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """Install one harmless token for every host-scoping behavior test."""
+        monkeypatch.setenv("API_USGS_PAT", self.FAKE_TOKEN)
+
     def test_key_included_for_waterdata_host(self):
         """Key IS added when target URL matches api.waterdata.usgs.gov."""
         url = "https://api.waterdata.usgs.gov/ogcapi/v0/collections/daily/items"
-        with mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}):
-            headers = _default_headers(url)
+        headers = _default_headers(url)
         assert headers.get("X-Api-Key") == self.FAKE_TOKEN
 
     def test_key_excluded_for_external_host(self):
         """Key is NOT added for an external (non-USGS) host."""
         url = "https://nwis.waterservices.usgs.gov/nwis/iv/"
-        with mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}):
-            headers = _default_headers(url)
+        headers = _default_headers(url)
         assert "X-Api-Key" not in headers
 
     def test_key_excluded_for_wateruse_host(self):
         """Key is NOT added for the NWDC water-use host (api.water.usgs.gov)."""
         url = "https://api.water.usgs.gov/nwaa-data/data"
-        with mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}):
-            headers = _default_headers(url)
+        headers = _default_headers(url)
         assert "X-Api-Key" not in headers
 
     def test_key_excluded_for_rating_asset_host(self):
         """Key is NOT added for rating asset downloads (S3/external)."""
         url = "https://labs.waterdata.usgs.gov/sta/v1.1/Datastreams(123)/rating.rdb"
-        with mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}):
-            headers = _default_headers(url)
+        headers = _default_headers(url)
         assert "X-Api-Key" not in headers
 
     def test_key_excluded_for_lookalike_host(self):
         """Key is NOT sent to a typosquatting/lookalike domain."""
         url = "https://api.waterdata.usgs.gov.evil.com/ogcapi/v0/daily/items"
-        with mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}):
-            headers = _default_headers(url)
+        headers = _default_headers(url)
         assert "X-Api-Key" not in headers
 
     def test_key_excluded_when_no_url_provided(self):
         """Key is NOT added when target_url is None (legacy callers)."""
-        with mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}):
-            headers = _default_headers(None)
+        headers = _default_headers(None)
         assert "X-Api-Key" not in headers
 
-    def test_key_excluded_when_no_token_set(self):
+    def test_key_excluded_when_no_token_set(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         """No key header at all when API_USGS_PAT is not set."""
-        with mock.patch.dict(os.environ, {}, clear=True):
-            # Ensure the env var is absent
-            os.environ.pop("API_USGS_PAT", None)
-            headers = _default_headers("https://api.waterdata.usgs.gov/ogcapi/v0/daily")
+        monkeypatch.delenv("API_USGS_PAT")
+        headers = _default_headers("https://api.waterdata.usgs.gov/ogcapi/v0/daily")
         assert "X-Api-Key" not in headers
 
     def test_non_auth_headers_always_present(self):
         """User-Agent, Accept, Accept-Encoding, lang are always present."""
         url = "https://example.com/any"
-        with mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}):
-            headers = _default_headers(url)
+        headers = _default_headers(url)
         assert "User-Agent" in headers
         assert "Accept" in headers
         assert "Accept-Encoding" in headers
         assert "lang" in headers
         # Key should NOT be sent to example.com
         assert "X-Api-Key" not in headers
 
-    def test_authorized_host_constant(self):
-        """The authorized host constant is correct."""
-        assert _AUTHORIZED_API_KEY_HOST == "api.waterdata.usgs.gov"
-
     def test_generic_ogc_request_excludes_key_for_custom_host(self):
         """A caller-supplied OGC base URL never inherits Water Data auth."""
         from dataretrieval.ogc.requests import _construct_api_requests, _ogc_base_url
 
-        with (
-            mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}),
-            _ogc_base_url("https://features.example.org/ogcapi"),
-        ):
+        with _ogc_base_url("https://features.example.org/ogcapi"):
             request = _construct_api_requests("things")
         assert "X-Api-Key" not in request.headers
 
@@ -107,7 +97,6 @@ def test_rating_download_scopes_headers_to_asset_url(self):
         feature = {"id": "site.rdb", "assets": {"data": {"href": asset_url}}}
         response = mock.Mock(text="rating body")
         with (
-            mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}),
             mock.patch.object(ratings, "_get", return_value=response) as get,
             mock.patch.object(ratings, "_raise_for_non_200"),
             mock.patch.object(ratings, "read_rdb", return_value=pd.DataFrame()),
@@ -133,13 +122,12 @@ def handler(request: httpx.Request) -> httpx.Response:
             return httpx.Response(200, request=request)
 
         url = "https://api.waterdata.usgs.gov/start"
-        with mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}):
-            _get(
-                url,
-                headers=_default_headers(url),
-                follow_redirects=True,
-                transport=httpx.MockTransport(handler),
-            )
+        _get(
+            url,
+            headers=_default_headers(url),
+            follow_redirects=True,
+            transport=httpx.MockTransport(handler),
+        )
 
         assert seen[0].headers.get("X-Api-Key") == self.FAKE_TOKEN
         assert "X-Api-Key" not in seen[1].headers
@@ -166,8 +154,7 @@ async def run() -> None:
             ) as client:
                 await client.get(url, headers=_default_headers(url))
 
-        with mock.patch.dict(os.environ, {"API_USGS_PAT": self.FAKE_TOKEN}):
-            asyncio.run(run())
+        asyncio.run(run())
 
         assert seen[0].headers.get("X-Api-Key") == self.FAKE_TOKEN
         assert "X-Api-Key" not in seen[1].headers