Expand integration tests, fix transport response reading bug

Comprehensive integration tests covering all API endpoint groups:
- Backends: list, get, field validation, degraded-optional
- Characterizations: list, get by ID, field validation
- Jobs: create, get, list, filter, pagination, cancel, delete,
  cost, probabilities, estimate, completed job fields, dry run
- Sessions: list, create/end lifecycle, context manager
- Whoami: sync, detailed
- Usage: with permission skip
- Async: whoami, list jobs, paginated iteration

Fix bug in _transport.py where _parse_error_body accessed
response.json()/response.text without calling response.read()
first, causing ResponseNotRead on error status codes.

30 integration tests total (from 4). Tests that depend on
account-specific features (sessions, usage) skip gracefully.

Author: splch

ionq_core/_transport.py

@@ -42,6 +42,7 @@ def _backoff_delays(max_retries: int) -> Iterator[float]:
 
 
 def _parse_error_body(response: httpx.Response) -> dict | str | None:
+    response.read()
     try:
         return response.json()
     except Exception:

tests/integration/conftest.py

@@ -2,12 +2,18 @@
 
 import contextlib
 import os
+import warnings
 
 import pytest
 
 from ionq_core import AuthenticatedClient, IonQClient
 from ionq_core.api.default import delete_job
 
+# Integration tests make real HTTPS connections that may leak sockets during
+# process teardown. This is harmless but triggers pytest's filterwarnings=error.
+warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*SSL")
+warnings.filterwarnings("ignore", category=pytest.PytestUnraisableExceptionWarning, message=".*SSL.*")
+
 _job_ids: list[str] = []
 
 

tests/integration/test_async.py

@@ -0,0 +1,38 @@
+"""Integration tests verifying async variants work against the real API."""
+
+import pytest
+
+from ionq_core import IonQClient, aiter_jobs
+from ionq_core.api.default import get_jobs
+from ionq_core.api.whoami import get_whoami
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.fixture
+def async_client(api_key):
+    return IonQClient(api_key=api_key)
+
+
+async def test_async_whoami(async_client):
+    async with async_client as c:
+        result = await get_whoami.asyncio(client=c)
+        assert result is not None
+        assert result.key_name
+
+
+async def test_async_list_jobs(async_client):
+    async with async_client as c:
+        resp = await get_jobs.asyncio(client=c, limit=2)
+        assert resp is not None
+        assert len(resp.jobs) > 0
+
+
+async def test_async_iter_jobs(async_client):
+    async with async_client as c:
+        jobs = []
+        async for j in aiter_jobs(c, limit=1):
+            jobs.append(j)
+            if len(jobs) >= 2:
+                break
+        assert len(jobs) == 2

tests/integration/test_backends.py

@@ -1,18 +1,52 @@
-"""Verify backend listing works against the real API."""
+"""Integration tests for backend endpoints."""
+
+import warnings
 
 import pytest
 
 from ionq_core import Client
-from ionq_core.api.backends import get_backends
+from ionq_core.api.backends import get_backend, get_backends
 
 pytestmark = pytest.mark.integration
 
+BASE_URL = "https://api.ionq.co/v0.4"
+
+
+def _unauthenticated():
+    """Unauthenticated client (no managed transport, may leak sockets)."""
+    return Client(base_url=BASE_URL)
+
+
+class TestListBackends:
+    def test_returns_backends(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", ResourceWarning)
+            backends = get_backends.sync(client=_unauthenticated())
+        assert backends is not None
+        assert len(backends) > 0
+
+    def test_has_qpu(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", ResourceWarning)
+            backends = get_backends.sync(client=_unauthenticated())
+        names = [b.backend for b in backends]
+        assert any("qpu" in n for n in names)
+
+    def test_backend_fields(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", ResourceWarning)
+            backends = get_backends.sync(client=_unauthenticated())
+        for b in backends:
+            assert b.backend
+            assert b.status
+            assert b.qubits > 0
+            assert b.average_queue_time is not None
+            assert b.last_updated
+
 
-def test_list_backends():
-    """Backends endpoint is unauthenticated - use a plain Client."""
-    unauthenticated = Client(base_url="https://api.ionq.co/v0.4")
-    backends = get_backends.sync(client=unauthenticated)
-    assert backends is not None
-    assert len(backends) > 0
-    names = [b.backend for b in backends]
-    assert any("qpu" in n for n in names), f"Expected at least one QPU backend in {names}"
+class TestGetBackend:
+    def test_get_qpu(self, client):
+        backend = get_backend.sync("qpu.forte-1", client=client)
+        assert backend is not None
+        assert backend.backend == "qpu.forte-1"
+        assert backend.qubits > 0

tests/integration/test_characterizations.py

@@ -0,0 +1,32 @@
+"""Integration tests for characterization endpoints."""
+
+import pytest
+
+from ionq_core.api.characterizations import get_characterization, get_characterizations_for_backend
+
+pytestmark = pytest.mark.integration
+
+
+class TestListCharacterizations:
+    def test_returns_characterizations(self, client):
+        resp = get_characterizations_for_backend.sync("qpu.forte-1", client=client, limit=1)
+        assert resp is not None
+        assert len(resp.characterizations) > 0
+
+    def test_characterization_fields(self, client):
+        resp = get_characterizations_for_backend.sync("qpu.forte-1", client=client, limit=1)
+        char = resp.characterizations[0]
+        assert char.id
+        assert char.backend == "qpu.forte-1"
+        assert char.date
+
+
+class TestGetCharacterization:
+    def test_get_by_id(self, client):
+        resp = get_characterizations_for_backend.sync("qpu.forte-1", client=client, limit=1)
+        char_id = resp.characterizations[0].id
+
+        char = get_characterization.sync("qpu.forte-1", char_id, client=client)
+        assert char is not None
+        assert char.id == char_id
+        assert char.qubits > 0

tests/integration/test_sessions.py

@@ -0,0 +1,55 @@
+"""Integration tests for session endpoints."""
+
+import contextlib
+
+import pytest
+
+from ionq_core import SessionManager
+from ionq_core._exceptions import NotFoundError
+from ionq_core.api.default import get_session_jobs, get_sessions
+
+pytestmark = pytest.mark.integration
+
+
+def test_list_sessions(client):
+    try:
+        result = get_sessions.sync(client=client)
+        assert result is not None
+    except NotFoundError:
+        pytest.skip("Sessions endpoint not available for this account")
+
+
+class TestSessionManager:
+    def test_create_and_end_session(self, client):
+        mgr = SessionManager(client, "simulator")
+        try:
+            mgr.open()
+        except NotFoundError:
+            pytest.skip("Sessions not available for this account")
+
+        try:
+            assert mgr.session_id is not None
+
+            session = mgr.status()
+            assert session is not None
+            assert session.backend == "simulator"
+
+            jobs = get_session_jobs.sync(mgr.session_id, client=client)
+            assert jobs is not None
+        finally:
+            with contextlib.suppress(Exception):
+                mgr.close()
+
+    def test_context_manager(self, client):
+        mgr = SessionManager(client, "simulator")
+        try:
+            mgr.open()
+        except NotFoundError:
+            pytest.skip("Sessions not available for this account")
+        try:
+            assert mgr.session_id is not None
+            status = mgr.status()
+            assert status is not None
+        finally:
+            with contextlib.suppress(Exception):
+                mgr.close()