test(integration): close v3.0.0 coverage gaps; fix demo-drift error tests

Post-v3.0.0 release surfaced 5 failing integration tests (release was
merged with bypassed status checks). All five are test maintenance,
not SDK bugs:

Coverage harness:
- Expected resource set now includes v3 sub-resources RFQsResource
  and QuotesResource (21 classes, was 19).
- Register PortfolioResource.{fills, fills_all, positions_all} —
  relocated from OrdersResource in #351/#376.
- Register MarketsResource.list_all_trades (canonical v3 name).
- Register FcmResource.positions_all (added in #344).
- Register RFQsResource + QuotesResource public methods.

Integration tests for v3 surfaces:
- tests/integration/test_communications.py: add TestRFQsV3Sync,
  TestQuotesV3Sync, TestQuotesV3RealApiOnly — exercise the namespaced
  client.communications.{rfqs,quotes}.* surface end-to-end on demo.
- tests/integration/test_portfolio.py: add fills/fills_all/positions_all
  smoke tests on both sync and async.
- tests/integration/test_markets.py: add test_list_all_trades.
- tests/integration/test_fcm.py: add positions_all sync + async.

Demo-drift fixes in test_errors.py:
- test_malformed_params_returns_validation_error +
  test_validation_error_details_attribute: demo now silently accepts
  malformed cursors. Switched to status='not-a-real-status' which
  reliably triggers 400 invalid_status_filter.
- test_bad_auth_returns_auth_error: KalshiConfig(base_url=...) now
  rejects split REST/WS environments (defense-in-depth from #261).
  Switched to KalshiConfig.demo().

Verification:
  Unit:        2954 passed, 3 skipped
  Integration: 233 passed, 38 skipped (was 218 passed / 5 failed)

Author: TexasCoding

tests/integration/test_communications.py

@@ -64,6 +64,14 @@
         "list_rfqs",
     ],
 )
+register(
+    "RFQsResource",
+    ["create", "delete", "get", "list", "list_all"],
+)
+register(
+    "QuotesResource",
+    ["accept", "confirm", "create", "delete", "get", "list", "list_all"],
+)
 
 
 @pytest.fixture
@@ -179,6 +187,139 @@ def test_get_unknown_quote_errors(self, sync_client: KalshiClient) -> None:
             sync_client.communications.get_quote("q-nonexistent-00000000")
 
 
+@pytest.mark.integration
+class TestRFQsV3Sync:
+    """v3 namespaced surface: ``client.communications.rfqs.*``.
+
+    These calls forward to the same endpoints as the deprecated
+    top-level methods; this class proves the new public path works
+    end-to-end on demo.
+    """
+
+    def test_list(self, sync_client: KalshiClient) -> None:
+        page = sync_client.communications.rfqs.list(limit=10)
+        assert isinstance(page, Page)
+        for rfq in page.items:
+            assert isinstance(rfq, RFQ)
+
+    def test_list_all(self, sync_client: KalshiClient) -> None:
+        for i, rfq in enumerate(
+            sync_client.communications.rfqs.list_all(limit=10),
+        ):
+            assert isinstance(rfq, RFQ)
+            if i >= 4:
+                break
+
+    def test_create_get_delete(
+        self, sync_client: KalshiClient, demo_market_ticker: str,
+    ) -> None:
+        try:
+            created = sync_client.communications.rfqs.create(
+                market_ticker=demo_market_ticker,
+                rest_remainder=False,
+                contracts=1,
+            )
+        except (KalshiValidationError, KalshiAuthError) as e:
+            pytest.skip(f"demo refused rfqs.create: {e}")
+        assert isinstance(created, CreateRFQResponse)
+        try:
+            time.sleep(0.5)  # eventual consistency on demo
+            got = sync_client.communications.rfqs.get(created.id)
+            assert isinstance(got, GetRFQResponse)
+            assert got.rfq.id == created.id
+        finally:
+            sync_client.communications.rfqs.delete(created.id)
+
+
+@pytest.mark.integration
+class TestQuotesV3Sync:
+    """v3 namespaced surface: ``client.communications.quotes.*``.
+
+    ``list`` and ``list_all`` need a creator filter on demo; ``accept`` and
+    ``confirm`` require two parties — both live behind the real-API gate to
+    mirror ``TestCommunicationsRealApiOnly``. The lifecycle test exercises
+    ``create`` / ``get`` / ``delete`` which the demo supports for self-quoting.
+    """
+
+    def test_quote_lifecycle(
+        self, sync_client: KalshiClient, ephemeral_rfq: str,
+    ) -> None:
+        try:
+            created = sync_client.communications.quotes.create(
+                rfq_id=ephemeral_rfq,
+                yes_bid="0.50",
+                no_bid="0.50",
+                rest_remainder=False,
+            )
+        except (KalshiValidationError, KalshiAuthError) as e:
+            pytest.skip(f"demo refused quotes.create: {e}")
+        quote_id = created.id
+        try:
+            time.sleep(0.5)
+            got = sync_client.communications.quotes.get(quote_id)
+            assert got.quote.id == quote_id
+            assert got.quote.rfq_id == ephemeral_rfq
+        finally:
+            try:
+                sync_client.communications.quotes.delete(quote_id)
+            except Exception:
+                logger.warning("cleanup: failed to delete quote %s", quote_id)
+
+
+@pytest.mark.integration
+@pytest.mark.integration_real_api_only
+class TestQuotesV3RealApiOnly:
+    """v3 namespaced surface for endpoints the demo can't service.
+
+    See ``TestCommunicationsRealApiOnly`` for the underlying demo
+    constraints — these tests mirror that gating against the new
+    ``client.communications.quotes`` namespace.
+    """
+
+    def test_list(self, sync_client: KalshiClient) -> None:
+        comms_id = sync_client.communications.get_id().communications_id
+        page = sync_client.communications.quotes.list(
+            limit=10, quote_creator_user_id=comms_id,
+        )
+        assert isinstance(page, Page)
+
+    def test_list_all(self, sync_client: KalshiClient) -> None:
+        comms_id = sync_client.communications.get_id().communications_id
+        for i, quote in enumerate(
+            sync_client.communications.quotes.list_all(
+                limit=10, quote_creator_user_id=comms_id,
+            ),
+        ):
+            assert isinstance(quote, Quote)
+            if i >= 4:
+                break
+
+    def test_accept_and_confirm(
+        self, sync_client: KalshiClient, demo_market_ticker: str,
+    ) -> None:
+        rfq = sync_client.communications.rfqs.create(
+            market_ticker=demo_market_ticker,
+            rest_remainder=False,
+            contracts=1,
+        )
+        try:
+            quote = sync_client.communications.quotes.create(
+                rfq_id=rfq.id,
+                yes_bid="0.50",
+                no_bid="0.50",
+                rest_remainder=False,
+            )
+            sync_client.communications.quotes.accept(
+                quote.id, accepted_side="yes",
+            )
+            sync_client.communications.quotes.confirm(quote.id)
+        finally:
+            try:
+                sync_client.communications.rfqs.delete(rfq.id)
+            except Exception:
+                logger.warning("cleanup: failed to delete rfq %s", rfq.id)
+
+
 @pytest.mark.integration
 @pytest.mark.integration_real_api_only
 class TestCommunicationsRealApiOnly:

tests/integration/test_coverage.py

@@ -69,7 +69,7 @@ def test_no_stale_registrations(self) -> None:
             )
 
     def test_discovery_finds_all_resources(self) -> None:
-        """Sanity check: discover finds the expected 19 resource classes."""
+        """Sanity check: discover finds the expected 21 resource classes."""
         discovered = discover_public_methods()
         expected = {
             "AccountResource",
@@ -86,6 +86,8 @@ def test_discovery_finds_all_resources(self) -> None:
             "ExchangeResource",
             "HistoricalResource",
             "PortfolioResource",
+            "QuotesResource",
+            "RFQsResource",
             "SearchResource",
             "SeriesResource",
             "StructuredTargetsResource",

tests/integration/test_errors.py

@@ -42,12 +42,14 @@ def test_malformed_params_returns_validation_error(
     ) -> None:
         """Malformed request params should raise KalshiValidationError (400).
 
-        Uses a malformed cursor — the SDK passes it verbatim to the server,
-        which rejects it with a 400. (Numeric range checks like negative
-        limit are now enforced client-side via ValueError per #214.)
+        Uses an invalid ``status`` filter — the server rejects values outside
+        its accepted enum with 400 invalid_status_filter. (Numeric range
+        checks like negative ``limit`` are enforced client-side via
+        ``ValueError`` per #214, and malformed cursors are now silently
+        ignored by the demo server.)
         """
         with pytest.raises(KalshiValidationError) as exc_info:
-            sync_client.markets.list(cursor="!!!not-a-valid-cursor!!!")
+            sync_client.markets.list(status="not-a-real-status")  # type: ignore[arg-type]
 
         exc = exc_info.value
         assert exc.status_code == 400
@@ -70,9 +72,7 @@ def test_bad_auth_returns_auth_error(self) -> None:
         auth = KalshiAuth(
             key_id="invalid-key-id-for-test", private_key=dummy_key
         )
-        config = KalshiConfig(
-            base_url="https://demo-api.kalshi.co/trade-api/v2"
-        )
+        config = KalshiConfig.demo()
         client = KalshiClient(auth=auth, config=config)
 
         try:
@@ -102,7 +102,7 @@ def test_validation_error_details_attribute(
     ) -> None:
         """KalshiValidationError should have a details attribute (may be None or dict)."""
         with pytest.raises(KalshiValidationError) as exc_info:
-            sync_client.markets.list(cursor="!!!not-a-valid-cursor!!!")
+            sync_client.markets.list(status="not-a-real-status")  # type: ignore[arg-type]
 
         exc = exc_info.value
         assert hasattr(exc, "details")

tests/integration/test_fcm.py

@@ -13,11 +13,11 @@
 from kalshi.client import KalshiClient
 from kalshi.errors import KalshiAuthError, KalshiNotFoundError, KalshiServerError
 from kalshi.models.orders import Order
-from kalshi.models.portfolio import PositionsResponse
+from kalshi.models.portfolio import MarketPosition, PositionsResponse
 from tests.integration.assertions import assert_model_fields
 from tests.integration.coverage_harness import register
 
-register("FcmResource", ["orders", "orders_all", "positions"])
+register("FcmResource", ["orders", "orders_all", "positions", "positions_all"])
 
 # Tolerated errors on demo for non-FCM accounts:
 #   - 401/403 → KalshiAuthError (expected: demo account lacks FCM role)
@@ -65,6 +65,19 @@ def test_positions(self, sync_client: KalshiClient) -> None:
         assert isinstance(result, PositionsResponse)
         assert_model_fields(result)
 
+    def test_positions_all(self, sync_client: KalshiClient) -> None:
+        try:
+            gen = sync_client.fcm.positions_all(
+                subtrader_id="sdk-test-subtrader",
+                limit=2,
+            )
+            for count, pos in enumerate(gen):
+                assert isinstance(pos, MarketPosition)
+                if count >= 2:
+                    break
+        except _TOLERATED_FCM_ERRORS:
+            pytest.skip("Demo account is not FCM-enabled (expected)")
+
 
 @pytest.mark.integration
 class TestFcmAsync:
@@ -85,3 +98,18 @@ async def test_positions(self, async_client: AsyncKalshiClient) -> None:
         except _TOLERATED_FCM_ERRORS:
             pytest.skip("Demo account is not FCM-enabled (expected)")
         assert isinstance(result, PositionsResponse)
+
+    async def test_positions_all(self, async_client: AsyncKalshiClient) -> None:
+        try:
+            gen = async_client.fcm.positions_all(
+                subtrader_id="sdk-test-subtrader",
+                limit=2,
+            )
+            count = 0
+            async for pos in gen:
+                assert isinstance(pos, MarketPosition)
+                count += 1
+                if count >= 2:
+                    break
+        except _TOLERATED_FCM_ERRORS:
+            pytest.skip("Demo account is not FCM-enabled (expected)")

tests/integration/test_markets.py

@@ -30,6 +30,7 @@
         "get",
         "list",
         "list_all",
+        "list_all_trades",
         "list_trades",
         "list_trades_all",
         "orderbook",
@@ -180,6 +181,15 @@ def test_list_trades_all(self, sync_client: KalshiClient) -> None:
             if count >= 2:
                 break
 
+    def test_list_all_trades(self, sync_client: KalshiClient) -> None:
+        # v3 canonical name; ``list_trades_all`` is a deprecated forwarder.
+        for count, t in enumerate(
+            sync_client.markets.list_all_trades(limit=5),
+        ):
+            assert isinstance(t, Trade)
+            if count >= 2:
+                break
+
     def test_bulk_candlesticks(
         self,
         sync_client: KalshiClient,

tests/integration/test_portfolio.py

@@ -7,9 +7,11 @@
 from kalshi.async_client import AsyncKalshiClient
 from kalshi.client import KalshiClient
 from kalshi.models.common import Page
+from kalshi.models.orders import Fill
 from kalshi.models.portfolio import (
     Balance,
     Deposit,
+    MarketPosition,
     PositionsResponse,
     Settlement,
     TotalRestingOrderValue,
@@ -24,7 +26,10 @@
         "balance",
         "deposits",
         "deposits_all",
+        "fills",
+        "fills_all",
         "positions",
+        "positions_all",
         "settlements",
         "settlements_all",
         "total_resting_order_value",
@@ -51,6 +56,27 @@ def test_positions(self, sync_client: KalshiClient) -> None:
         assert isinstance(result.market_positions, list)
         assert isinstance(result.event_positions, list)
 
+    def test_positions_all(self, sync_client: KalshiClient) -> None:
+        for count, pos in enumerate(sync_client.portfolio.positions_all(limit=2)):
+            assert isinstance(pos, MarketPosition)
+            assert_model_fields(pos)
+            if count >= 2:
+                break
+
+    def test_fills(self, sync_client: KalshiClient) -> None:
+        page = sync_client.portfolio.fills(limit=5)
+        assert isinstance(page, Page)
+        for item in page.items:
+            assert isinstance(item, Fill)
+            assert_model_fields(item)
+
+    def test_fills_all(self, sync_client: KalshiClient) -> None:
+        for count, fill in enumerate(sync_client.portfolio.fills_all(limit=2)):
+            assert isinstance(fill, Fill)
+            assert_model_fields(fill)
+            if count >= 2:
+                break
+
     def test_settlements(self, sync_client: KalshiClient) -> None:
         page = sync_client.portfolio.settlements(limit=5)
         assert isinstance(page, Page)
@@ -115,6 +141,31 @@ async def test_positions(self, async_client: AsyncKalshiClient) -> None:
         assert isinstance(result, PositionsResponse)
         assert_model_fields(result)
 
+    async def test_positions_all(self, async_client: AsyncKalshiClient) -> None:
+        count = 0
+        async for pos in async_client.portfolio.positions_all(limit=2):
+            assert isinstance(pos, MarketPosition)
+            assert_model_fields(pos)
+            count += 1
+            if count >= 3:
+                break
+
+    async def test_fills(self, async_client: AsyncKalshiClient) -> None:
+        page = await async_client.portfolio.fills(limit=5)
+        assert isinstance(page, Page)
+        for item in page.items:
+            assert isinstance(item, Fill)
+            assert_model_fields(item)
+
+    async def test_fills_all(self, async_client: AsyncKalshiClient) -> None:
+        count = 0
+        async for fill in async_client.portfolio.fills_all(limit=2):
+            assert isinstance(fill, Fill)
+            assert_model_fields(fill)
+            count += 1
+            if count >= 3:
+                break
+
     async def test_settlements(self, async_client: AsyncKalshiClient) -> None:
         page = await async_client.portfolio.settlements(limit=5)
         assert isinstance(page, Page)