test: make the suite runnable under dev.bat's Enterprise unlock

Three local-only failures, none of which CI could see. Two share a root cause
worth stating plainly: the native LicenseManager latches the first tier the
process resolves and offers no way back. `set_license_key("")` raises
ValueError, and `get_license_info()` keeps reporting the latched tier even after
QECTOR_LICENSE_KEY is removed from the environment. Any test asserting
Community-tier *rejection* is therefore unassertable once something has
resolved a higher tier.

test_enforcement_matrix `_native_cap_cell` popped QECTOR_LICENSE_KEY and assumed
that produced Community. It does, until the latch is set - which is why the file
passed alone and failed after test_rest_api_auth, whose authorised
/api/license/info request is the first call to get_license_info(). Bisected one
test at a time rather than guessed; three earlier theories (env caching,
QECTOR_API_KEY, QECTOR_ENFORCE) were each disproved by probe first.

test_auto_decoder_native monkeypatched the Python `qd.get_license_info`, but
NativeAutoDecoder asks the Rust gate, so the fake never applied.

Both now skip when the process has latched a non-Community tier, with the reason
stated. CI runs unlicensed, so the tier is Community there and every one of
these cells still executes - verified: 25 passed / 8 skipped unlicensed, exactly
as before, and 20 passed / 13 skipped under dev.bat with nothing failing.

test_auto_debug_fallbacks is unrelated and a real bug: it patched an instance
attribute on AutoDecoder, which defines __slots__, so unpatching raised
"attribute is read-only" in teardown. It never surfaced because CI has no GPU -
`_get_cuda()` returns None there and the entire patched block is skipped, so the
test passed while exercising none of the fallback path it exists to cover. Patch
the class instead.

Author: qectorlab

python/tests/test_auto_debug_fallbacks.py

@@ -31,14 +31,21 @@ class _RaisingCuda:
             def batch_decode(self, _syn):
                 raise RuntimeError("Simulated CUDA OOM Error")
 
-        real_get_decoder = ad._get_decoder
+        # Patch the CLASS, not the instance. AutoDecoder defines __slots__, and
+        # unpatching an instance attribute on a slotted object fails on exit with
+        # "'AutoDecoder' object attribute '_get_decoder' is read-only" - so the
+        # test blew up in teardown rather than testing anything. It went unnoticed
+        # because CI has no GPU: `_get_cuda()` returns None there, this whole block
+        # is skipped, and the test passes without exercising the fallback at all.
+        # It only ran, and only failed, on a machine with CUDA.
+        real_get_decoder = AutoDecoder._get_decoder
 
-        def _patched_get_decoder(backend):
+        def _patched_get_decoder(self, backend):
             if backend == Backend.CUDA:
                 return _RaisingCuda()
-            return real_get_decoder(backend)
+            return real_get_decoder(self, backend)
 
-        with patch.object(ad, "_get_decoder", new=_patched_get_decoder):
+        with patch.object(AutoDecoder, "_get_decoder", _patched_get_decoder):
             syns = (np.random.default_rng(42).random((32, code.n_checks)) < 0.08).astype(np.uint8)
 
             # The auto-debug engine should catch the CUDA exception and gracefully fall back to CPU_RAYON / CPU_SINGLE

python/tests/test_auto_decoder_native.py

@@ -35,6 +35,18 @@ def test_native_auto_decoder_routing_d5():
 
 @pytest.mark.skipif(not hasattr(qd, "NativeAutoDecoder"), reason="NativeAutoDecoder not available")
 def test_native_auto_decoder_rejects_qldpc_if_license(monkeypatch):
+    # Read the real tier BEFORE the monkeypatch below shadows it. Faking
+    # `qd.get_license_info` only moves the Python shim; NativeAutoDecoder asks
+    # the Rust LicenseManager, which latches the first licence the process
+    # resolves and offers no way back to Community. Under dev.bat's Enterprise
+    # token the constructor is therefore allowed and this raises nothing.
+    # CI runs unlicensed, so the tier is Community and the assertion holds.
+    latched = str((qd.get_license_info() or {}).get("tier", "Community"))
+    if latched != "Community":
+        pytest.skip(
+            f"process has latched tier {latched!r}; the native licence gate cannot be "
+            "forced back to Community from Python. Run without QECTOR_LICENSE_KEY."
+        )
     monkeypatch.setenv("QECTOR_ENFORCE", "1")
     monkeypatch.setattr(qd, "get_license_info", lambda: {"tier": "Community", "max_distance": 7})
     code = codes.rotated_surface_code(5)

python/tests/test_enforcement_matrix.py

@@ -165,6 +165,26 @@ def _native_cap_cell(tier: str, side: str) -> None:
             "asserted in Rust (grpc_server.rs / mcp_server.rs)."
         )
     os.environ.pop("QECTOR_LICENSE_KEY", None)
+    # Popping the variable is not sufficient once the process has resolved a
+    # licence. The native LicenseManager latches the first tier it sees and
+    # exposes no way back - `set_license_key("")` raises ValueError, and
+    # `get_license_info()` keeps reporting the latched tier - so on a machine
+    # running under dev.bat (Enterprise token) the cap below simply does not
+    # fire and `pytest.raises(PermissionError)` fails.
+    #
+    # It only reproduced in a specific order: the latch is set by whichever test
+    # first calls get_license_info(), which is test_rest_api_auth's authorised
+    # /api/license/info request. Alone, this file passed; after that file, it
+    # failed. Skip rather than assert something the process can no longer be put
+    # into. CI runs unlicensed, so the tier is Community there and these cells
+    # execute exactly as before - the coverage that matters is not lost.
+    latched = str((q.get_license_info() or {}).get("tier", "Community"))
+    if latched != "Community":
+        pytest.skip(
+            f"process has already latched tier {latched!r}; the native LicenseManager "
+            "caches the first licence it resolves and cannot be returned to Community "
+            "in-process. Run without QECTOR_LICENSE_KEY (as CI does) to exercise this."
+        )
     d = STRADDLE[tier][side]
     if _expect(tier, side):
         with pytest.raises(PermissionError):