test(conformance): converge on the shared compression-disabled fixture

The compression-disabled conformance coverage added here locally has now
landed centrally (vgi-rpc-python be1a7a6), so this repo converges onto it
rather than keeping a parallel copy.

- Fixture renamed ts_http_no_compression_port ->
  conformance_http_no_compression_port, the name the shared suite looks up.
  The name is load-bearing: the shared case resolves it by string literal
  and *skips* rather than fails on a mismatch, so a rename would silently
  stop testing this port. Noted in the docstring.
- The local TestResponseCompressionDisabled class is deleted outright. The
  shared case subsumes both of its tests exactly -- same OPTIONS /health
  probe, same present-and-empty assertions, same both-headers zstd request,
  same "no codec claimed" check. A local test that duplicates the
  conformance suite keeps passing while this port drifts from the others,
  which is the failure mode the shared suite exists to prevent.

The worker needed no change: the --response-compression off flag added
earlier is exactly what the shared fixture drives.

Verified against the suite at be1a7a6: 6 passed, 0 skipped for the
-k Compression selection, and non-vacuous -- dropping the flag from the
fixture fails with `expected an empty advertisement, got ['zstd', 'gzip']`.

Note on CI reachability: ci.yml installs vgi-rpc from PyPI, and no released
version carries this class yet (it is four commits past v0.25.0, verified
against an installed 0.25.0). Until a release ships, CI does not skip these
cases -- it does not collect them at all, so their absence is silent rather
than reported. The fixture sits unused and harmless until then.

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

Author: rustyconover

test_ts_conformance.py

@@ -109,7 +109,7 @@ def conformance_http_port(ts_http_port: int) -> int:
 
 
 @pytest.fixture(scope="session")
-def ts_http_no_compression_port() -> Iterator[int]:
+def conformance_http_no_compression_port() -> Iterator[int]:
     """Bun conformance HTTP server with response compression explicitly OFF.
 
     Response compression is on by default (zstd level 1), so every other HTTP
@@ -118,6 +118,12 @@ def ts_http_no_compression_port() -> Iterator[int]:
     compression", as distinct from an absent header meaning "legacy server,
     assume zstd" — is only reachable through an explicit
     ``compressionLevel: null``, which ``--response-compression off`` passes.
+
+    The name is load-bearing: the shared suite's
+    ``TestHttpCompressionNegotiationConformance::test_empty_advertisement_means_never_compressed``
+    looks this fixture up by literal name via ``request.getfixturevalue`` and
+    *skips* if it is absent, so a rename here silently stops testing the TS
+    worker rather than failing.
     """
     proc, port = _start_http_server([*BUN_HTTP_WORKER, "--response-compression", "off"])
     yield port
@@ -508,64 +514,10 @@ def test_error_on_init(self, conformance_conn: ConnFactory) -> None:
 # Hook lives in conftest.py (next to this file) — pytest does not pick up
 # `pytest_collection_modifyitems` defined inside a test module.
 
-
-class TestResponseCompressionDisabled:
-    """The explicitly-disabled compression path, kept alive after the default flip.
-
-    Response compression now defaults to ON (zstd level 1), so the upstream
-    ``TestHttpCompressionNegotiationConformance`` suite — which runs against
-    ``conformance_http_port`` — takes its compressing branches and *skips*
-    ``test_empty_advertisement_means_never_compressed``.  These two cases pin
-    the other branch against a worker started with ``--response-compression
-    off``, so turning compression off stays a supported, tested configuration
-    rather than an accident of the old default.
-
-    Deliberately self-contained (no import from the upstream suite) so it runs
-    against any released ``vgi-rpc``.
-    """
-
-    # Large and highly compressible: nothing about the payload should stop a
-    # compressing server, so an uncompressed answer is the server's own choice.
-    PAYLOAD = "conformance-compression-probe " * 4096
-
-    def test_advertisement_is_present_but_empty(self, ts_http_no_compression_port: int) -> None:
-        import httpx
-
-        resp = httpx.options(f"http://127.0.0.1:{ts_http_no_compression_port}/health", timeout=5.0)
-        raw = resp.headers.get("VGI-Supported-Encodings")
-        # Absent would mean "legacy server, assume zstd" — the opposite claim.
-        assert raw is not None, "header must be present, not omitted"
-        assert [t for t in raw.split(",") if t.strip()] == []
-
-    def test_never_compresses_however_asked(self, ts_http_no_compression_port: int) -> None:
-        from io import BytesIO
-
-        import httpx
-        from vgi_rpc.conformance import ConformanceService
-        from vgi_rpc.http._common import _ARROW_CONTENT_TYPE
-        from vgi_rpc.rpc import rpc_methods
-        from vgi_rpc.rpc._wire import _write_request
-
-        info = rpc_methods(ConformanceService)["echo_string"]
-        version = vars(ConformanceService).get("protocol_version")
-        buf = BytesIO()
-        _write_request(
-            buf,
-            "echo_string",
-            info.params_schema,
-            {"value": self.PAYLOAD},
-            protocol_version=version if isinstance(version, str) else None,
-        )
-        resp = httpx.post(
-            f"http://127.0.0.1:{ts_http_no_compression_port}/echo_string",
-            content=buf.getvalue(),
-            headers={
-                "Content-Type": _ARROW_CONTENT_TYPE,
-                "Accept-Encoding": "zstd, gzip",
-                "X-VGI-Accept-Encoding": "zstd, gzip",
-            },
-            timeout=30.0,
-        )
-        assert resp.status_code == 200, f"{resp.status_code}: {resp.content[:200]!r}"
-        assert resp.headers.get("Content-Encoding") is None
-        assert resp.headers.get("X-VGI-Content-Encoding") is None
+# The repo-local ``TestResponseCompressionDisabled`` that used to live here was
+# removed once the same ground landed centrally as
+# ``TestHttpCompressionNegotiationConformance::test_empty_advertisement_means_never_compressed``
+# (vgi-rpc-python be1a7a6), which now drives the ``--response-compression off``
+# worker through the ``conformance_http_no_compression_port`` fixture above.
+# A local copy would keep passing while this port drifted from the other four
+# SDKs — precisely the failure the shared suite exists to catch.