test: close PR3 coverage gaps to 100%

- Connection.check_capability per-field branches (parametrized)
- Context.log with logger and meta supplied
- Peer.notify forwards to wrapped Outbound

Author: maxisbey

tests/server/test_connection.py

@@ -173,6 +173,27 @@ def test_connection_check_capability_false_before_initialized():
     assert conn.check_capability(ClientCapabilities(sampling=SamplingCapability())) is False
 
 
+@pytest.mark.parametrize(
+    ("have", "want", "expected"),
+    [
+        (ClientCapabilities(roots=None), ClientCapabilities(roots=RootsCapability()), False),
+        (
+            ClientCapabilities(roots=RootsCapability(list_changed=False)),
+            ClientCapabilities(roots=RootsCapability(list_changed=True)),
+            False,
+        ),
+        (ClientCapabilities(sampling=None), ClientCapabilities(sampling=SamplingCapability()), False),
+        (ClientCapabilities(experimental=None), ClientCapabilities(experimental={"a": {}}), False),
+        (ClientCapabilities(experimental={"a": {}}), ClientCapabilities(experimental={"b": {}}), False),
+        (ClientCapabilities(experimental={"a": {}}), ClientCapabilities(experimental={"a": {}}), True),
+    ],
+)
+def test_check_capability_per_field_branches(have: ClientCapabilities, want: ClientCapabilities, expected: bool):
+    conn = Connection(StubOutbound(), has_standalone_channel=True)
+    conn.client_capabilities = have
+    assert conn.check_capability(want) is expected
+
+
 def test_connection_check_capability_true_when_client_declares_it():
     conn = Connection(StubOutbound(), has_standalone_channel=True)
     conn.client_capabilities = ClientCapabilities(

tests/server/test_server_context.py

@@ -129,3 +129,28 @@ async def server_on_request(dctx: DCtx, method: str, params: Mapping[str, Any] |
     method, params = crec.notifications[0]
     assert method == "notifications/message"
     assert params is not None and params["level"] == "debug" and params["data"] == "hello"
+
+
+@pytest.mark.anyio
+async def test_context_log_includes_logger_and_meta_when_supplied():
+    crec = Recorder()
+    _, c_notify = echo_handlers(crec)
+
+    async def server_on_request(dctx: DCtx, method: str, params: Mapping[str, Any] | None) -> dict[str, Any]:
+        ctx: Context[_Lifespan, TransportContext] = Context(
+            dctx, lifespan=_Lifespan("app"), connection=Connection(dctx, has_standalone_channel=True)
+        )
+        await ctx.log("info", "x", logger="my.log", meta={"traceId": "t"})
+        return {}
+
+    async with running_pair(direct_pair, server_on_request=server_on_request, client_on_notify=c_notify) as (
+        client,
+        *_,
+    ):
+        with anyio.fail_after(5):
+            await client.send_raw_request("t", None)
+            await crec.notified.wait()
+    _, params = crec.notifications[0]
+    assert params is not None
+    assert params["logger"] == "my.log"
+    assert params["_meta"] == {"traceId": "t"}

tests/shared/test_peer.py

@@ -135,6 +135,23 @@ def test_dump_params_merges_meta_over_model_meta():
     assert out == {"_meta": {"k": 1}}
 
 
+@pytest.mark.anyio
+async def test_peer_notify_forwards_to_wrapped_outbound():
+    sent: list[tuple[str, Mapping[str, Any] | None]] = []
+
+    class _Out:
+        async def send_raw_request(
+            self, method: str, params: Mapping[str, Any] | None, opts: Any = None
+        ) -> dict[str, Any]:
+            raise NotImplementedError
+
+        async def notify(self, method: str, params: Mapping[str, Any] | None) -> None:
+            sent.append((method, params))
+
+    await Peer(_Out()).notify("n", {"x": 1})
+    assert sent == [("n", {"x": 1})]
+
+
 @pytest.mark.anyio
 async def test_peer_ping_sends_ping_and_returns_none():
     rec = _Recorder({})