fix(waterdata): align cql-json filter tests with the unchunkable raise

ChunkPlan now raises RequestTooLarge for an over-budget request with no
chunkable axis. That broke test_cql_json_filter_is_not_chunked, whose
300-clause (~30 KB) cql-json filter is no longer passed through. Use a
within-budget filter so it still asserts cql-json ships un-chunked, and add
test_cql_json_filter_over_budget_raises for the new behavior.

Cleanups: reuse the existing _filter_chunking_clauses() helper instead of
re-hand-rolling the clause/join, pin both raises with match=, drop a
provably-dead transport-mock block (the raise fires during ChunkPlan
construction, before any send), and trim a redundant comment.

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

Author: thodson-usgs

dataretrieval/waterdata/chunking.py

@@ -872,13 +872,10 @@ def __init__(
 
         axes = _extract_axes(args)
         if not axes:
-            # No chunkable axis: nothing to split. If the single request fits,
-            # run it verbatim (the common passthrough). If it's over budget we
-            # can't chunk it (e.g. a single large CQL ``IN`` clause with no
-            # top-level ``OR``, or one oversized value), so raise an actionable
-            # error instead of shipping it for the server to reject with an
-            # opaque HTTP 414. ``_safe_request_bytes`` treats an un-constructable
-            # URL (httpx.InvalidURL, > 64 KB) as over budget.
+            # No chunkable axis: if the single request fits, run it verbatim
+            # (the common passthrough); otherwise it can't be split, so raise an
+            # actionable error rather than ship a doomed request for the server
+            # to reject with an opaque HTTP 414.
             if _safe_request_bytes(build_request, args, url_limit) <= url_limit:
                 return
             raise RequestTooLarge(

tests/waterdata_chunking_test.py

@@ -175,7 +175,7 @@ def test_chunk_plan_raises_when_unchunkable_request_exceeds_limit():
     RequestTooLarge instead of being shipped for the server to reject with an
     opaque HTTP 414."""
     args = {"monitoring_location_id": "scalar-only"}
-    with pytest.raises(RequestTooLarge):
+    with pytest.raises(RequestTooLarge, match="no chunkable"):
         ChunkPlan(args, _fake_build, url_limit=10)
 
 

tests/waterdata_filters_test.py

@@ -7,6 +7,7 @@
 import pytest
 
 from dataretrieval.waterdata import get_continuous
+from dataretrieval.waterdata.chunking import RequestTooLarge
 from dataretrieval.waterdata.filters import (
     _check_numeric_filter_pitfall,
     _split_top_level_or,
@@ -270,9 +271,14 @@ async def fake_walk_pages(*_args, **_kwargs):
 
 
 def test_cql_json_filter_is_not_chunked():
-    """Chunking applies only to cql-text; cql-json is passed through unchanged."""
-    clause = "(time >= '2023-01-01T00:00:00Z' AND time <= '2023-01-01T00:30:00Z')"
-    expr = " OR ".join([clause] * 300)
+    """A within-budget cql-json filter is passed through unchanged.
+
+    Chunking only applies to cql-text (split on top-level ``OR``); cql-json is
+    opaque to the chunker. The over-budget case is covered by
+    ``test_cql_json_filter_over_budget_raises``.
+    """
+    # 50 clauses (~5 KB) stay under the 8 KB chunking budget → passthrough.
+    expr = _filter_chunking_clauses(50)
     sent_filters = []
 
     def fake_construct_api_requests(**kwargs):
@@ -304,6 +310,26 @@ def fake_construct_api_requests(**kwargs):
     assert sent_filters == [expr]
 
 
+def test_cql_json_filter_over_budget_raises():
+    """A cql-json filter the chunker can't split (no top-level ``OR`` axis is
+    extracted) that still exceeds the URL byte budget raises ``RequestTooLarge``
+    rather than shipping a doomed request for the server to reject with an
+    opaque HTTP 414.
+
+    The raise happens during ``ChunkPlan`` construction, before any request is
+    sent, so no transport mocking is needed.
+    """
+    # 300 clauses (~30 KB) blow past the 8 KB chunking budget.
+    expr = _filter_chunking_clauses(300)
+    with pytest.raises(RequestTooLarge, match="no chunkable"):
+        get_continuous(
+            monitoring_location_id="USGS-07374525",
+            parameter_code="72255",
+            filter=expr,
+            filter_lang="cql-json",
+        )
+
+
 @pytest.mark.parametrize(
     "expr",
     [