tests

Author: phi-friday

src/tests/test_async_namespace.py

@@ -26,22 +26,52 @@ def test_emit_method(self) -> None:
         assert hasattr(mod.AsyncNamespace, "emit")
         sig = inspect.signature(mod.AsyncNamespace.emit)
         params = list(sig.parameters.keys())
-        assert "event" in params
-        assert "data" in params
-        assert "to" in params
-        assert "room" in params
-        assert "skip_sid" in params
-        assert "namespace" in params
-        assert "callback" in params
-        assert "ignore_queue" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "event",
+            "data",
+            "to",
+            "room",
+            "skip_sid",
+            "namespace",
+            "callback",
+            "ignore_queue",
+        ]
 
     def test_send_method(self) -> None:
         assert hasattr(mod.AsyncNamespace, "send")
-        assert callable(mod.AsyncNamespace.send)
+        sig = inspect.signature(mod.AsyncNamespace.send)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "data",
+            "to",
+            "room",
+            "skip_sid",
+            "namespace",
+            "callback",
+            "ignore_queue",
+        ]
 
     def test_call_method(self) -> None:
         assert hasattr(mod.AsyncNamespace, "call")
-        assert callable(mod.AsyncNamespace.call)
+        sig = inspect.signature(mod.AsyncNamespace.call)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "event",
+            "data",
+            "to",
+            "sid",
+            "namespace",
+            "timeout",
+            "ignore_queue",
+        ]
+        # Verify timeout default is None (not int)
+        assert sig.parameters["timeout"].default is None
 
     def test_enter_room_method(self) -> None:
         assert hasattr(mod.AsyncNamespace, "enter_room")
@@ -90,18 +120,24 @@ def test_emit_method(self) -> None:
         assert hasattr(mod.AsyncClientNamespace, "emit")
         sig = inspect.signature(mod.AsyncClientNamespace.emit)
         params = list(sig.parameters.keys())
-        assert "event" in params
-        assert "data" in params
-        assert "namespace" in params
-        assert "callback" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "event", "data", "namespace", "callback"]
 
     def test_send_method(self) -> None:
         assert hasattr(mod.AsyncClientNamespace, "send")
-        assert callable(mod.AsyncClientNamespace.send)
+        sig = inspect.signature(mod.AsyncClientNamespace.send)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "data", "namespace", "callback"]
 
     def test_call_method(self) -> None:
         assert hasattr(mod.AsyncClientNamespace, "call")
-        assert callable(mod.AsyncClientNamespace.call)
+        sig = inspect.signature(mod.AsyncClientNamespace.call)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "event", "data", "namespace", "timeout"]
+        # Verify timeout default is None (not int)
+        assert sig.parameters["timeout"].default is None
 
     def test_disconnect_method(self) -> None:
         assert hasattr(mod.AsyncClientNamespace, "disconnect")

src/tests/test_async_pubsub_manager.py

@@ -21,10 +21,8 @@ def test_inherits_async_manager(self) -> None:
     def test_init_signature(self) -> None:
         sig = inspect.signature(mod.AsyncPubSubManager.__init__)
         params = list(sig.parameters.keys())
-        assert "self" in params
-        assert "channel" in params
-        assert "write_only" in params
-        assert "logger" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "channel", "write_only", "logger"]
 
     def test_name_attribute(self) -> None:
         assert hasattr(mod.AsyncPubSubManager, "name")
@@ -47,21 +45,35 @@ def test_emit_method(self) -> None:
         assert hasattr(mod.AsyncPubSubManager, "emit")
         sig = inspect.signature(mod.AsyncPubSubManager.emit)
         params = list(sig.parameters.keys())
-        assert "event" in params
-        assert "data" in params
-        assert "namespace" in params
-        assert "room" in params
-        assert "skip_sid" in params
-        assert "callback" in params
-        assert "to" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "event",
+            "data",
+            "namespace",
+            "room",
+            "skip_sid",
+            "callback",
+            "to",
+            "kwargs",
+        ]
 
     def test_can_disconnect_method(self) -> None:
         assert hasattr(mod.AsyncPubSubManager, "can_disconnect")
-        assert callable(mod.AsyncPubSubManager.can_disconnect)
+        sig = inspect.signature(mod.AsyncPubSubManager.can_disconnect)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "sid", "namespace"]
 
     def test_disconnect_method(self) -> None:
         assert hasattr(mod.AsyncPubSubManager, "disconnect")
-        assert callable(mod.AsyncPubSubManager.disconnect)
+        sig = inspect.signature(mod.AsyncPubSubManager.disconnect)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        # namespace is required (no default), not optional
+        assert params == ["self", "sid", "namespace", "kwargs"]
+        # Verify namespace has no default (is required)
+        assert sig.parameters["namespace"].default is inspect.Parameter.empty
 
     def test_enter_room_method(self) -> None:
         assert hasattr(mod.AsyncPubSubManager, "enter_room")

src/tests/test_async_server.py

@@ -33,16 +33,16 @@ def test_inherits_base_server(self) -> None:
     def test_init_signature(self) -> None:
         sig = inspect.signature(mod.AsyncServer.__init__)
         params = list(sig.parameters.keys())
-        assert "self" in params
-        assert "client_manager" in params
-        assert "logger" in params
-        assert "json" in params
-        assert "async_handlers" in params
-        assert "namespaces" in params
-        # serializer, always_connect, async_mode and engineio options may be in kwargs
-        assert "kwargs" in params or any(
-            sig.parameters[p].kind == inspect.Parameter.VAR_KEYWORD for p in params
-        )
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "client_manager",
+            "logger",
+            "json",
+            "async_handlers",
+            "namespaces",
+            "kwargs",
+        ]
 
     def test_attach_method(self) -> None:
         assert hasattr(mod.AsyncServer, "attach")
@@ -52,14 +52,18 @@ def test_emit_method(self) -> None:
         assert hasattr(mod.AsyncServer, "emit")
         sig = inspect.signature(mod.AsyncServer.emit)
         params = list(sig.parameters.keys())
-        assert "event" in params
-        assert "data" in params
-        assert "to" in params
-        assert "room" in params
-        assert "skip_sid" in params
-        assert "namespace" in params
-        assert "callback" in params
-        assert "ignore_queue" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "event",
+            "data",
+            "to",
+            "room",
+            "skip_sid",
+            "namespace",
+            "callback",
+            "ignore_queue",
+        ]
 
     def test_send_method(self) -> None:
         assert hasattr(mod.AsyncServer, "send")

src/tests/test_async_simple_client.py

@@ -24,21 +24,32 @@ def test_client_class_class_var(self) -> None:
     def test_init_accepts_any_args(self) -> None:
         sig = inspect.signature(mod.AsyncSimpleClient.__init__)
         params = list(sig.parameters.keys())
-        assert "self" in params
-        assert "args" in params
-        assert "kwargs" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "args", "kwargs"]
+
+    def test_client_attribute_type(self) -> None:
+        """Verify client attribute is AsyncClient | None, not Client | None."""
+        client = mod.AsyncSimpleClient()
+        assert hasattr(client, "client")
+        # Should be None initially (before connect)
+        assert_type(client.client, async_client_mod.AsyncClient | None)
+        assert client.client is None
 
     def test_connect_method(self) -> None:
         assert hasattr(mod.AsyncSimpleClient, "connect")
         sig = inspect.signature(mod.AsyncSimpleClient.connect)
         params = list(sig.parameters.keys())
-        assert "url" in params
-        assert "headers" in params
-        assert "auth" in params
-        assert "transports" in params
-        assert "namespace" in params
-        assert "socketio_path" in params
-        assert "wait_timeout" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "url",
+            "headers",
+            "auth",
+            "transports",
+            "namespace",
+            "socketio_path",
+            "wait_timeout",
+        ]
 
     def test_sid_property(self) -> None:
         assert hasattr(mod.AsyncSimpleClient, "sid")
@@ -50,22 +61,22 @@ def test_emit_method(self) -> None:
         assert hasattr(mod.AsyncSimpleClient, "emit")
         sig = inspect.signature(mod.AsyncSimpleClient.emit)
         params = list(sig.parameters.keys())
-        assert "event" in params
-        assert "data" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "event", "data"]
 
     def test_call_method(self) -> None:
         assert hasattr(mod.AsyncSimpleClient, "call")
         sig = inspect.signature(mod.AsyncSimpleClient.call)
         params = list(sig.parameters.keys())
-        assert "event" in params
-        assert "data" in params
-        assert "timeout" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "event", "data", "timeout"]
 
     def test_receive_method(self) -> None:
         assert hasattr(mod.AsyncSimpleClient, "receive")
         sig = inspect.signature(mod.AsyncSimpleClient.receive)
         params = list(sig.parameters.keys())
-        assert "timeout" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "timeout"]
 
     def test_disconnect_method(self) -> None:
         assert hasattr(mod.AsyncSimpleClient, "disconnect")

src/tests/test_namespace.py

@@ -26,22 +26,52 @@ def test_emit_method(self) -> None:
         assert hasattr(mod.Namespace, "emit")
         sig = inspect.signature(mod.Namespace.emit)
         params = list(sig.parameters.keys())
-        assert "event" in params
-        assert "data" in params
-        assert "to" in params
-        assert "room" in params
-        assert "skip_sid" in params
-        assert "namespace" in params
-        assert "callback" in params
-        assert "ignore_queue" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "event",
+            "data",
+            "to",
+            "room",
+            "skip_sid",
+            "namespace",
+            "callback",
+            "ignore_queue",
+        ]
 
     def test_send_method(self) -> None:
         assert hasattr(mod.Namespace, "send")
-        assert callable(mod.Namespace.send)
+        sig = inspect.signature(mod.Namespace.send)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "data",
+            "to",
+            "room",
+            "skip_sid",
+            "namespace",
+            "callback",
+            "ignore_queue",
+        ]
 
     def test_call_method(self) -> None:
         assert hasattr(mod.Namespace, "call")
-        assert callable(mod.Namespace.call)
+        sig = inspect.signature(mod.Namespace.call)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        assert params == [
+            "self",
+            "event",
+            "data",
+            "to",
+            "sid",
+            "namespace",
+            "timeout",
+            "ignore_queue",
+        ]
+        # Verify timeout default is None (not int)
+        assert sig.parameters["timeout"].default is None
 
     def test_enter_room_method(self) -> None:
         assert hasattr(mod.Namespace, "enter_room")
@@ -90,18 +120,24 @@ def test_emit_method(self) -> None:
         assert hasattr(mod.ClientNamespace, "emit")
         sig = inspect.signature(mod.ClientNamespace.emit)
         params = list(sig.parameters.keys())
-        assert "event" in params
-        assert "data" in params
-        assert "namespace" in params
-        assert "callback" in params
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "event", "data", "namespace", "callback"]
 
     def test_send_method(self) -> None:
         assert hasattr(mod.ClientNamespace, "send")
-        assert callable(mod.ClientNamespace.send)
+        sig = inspect.signature(mod.ClientNamespace.send)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "data", "room", "namespace", "callback"]
 
     def test_call_method(self) -> None:
         assert hasattr(mod.ClientNamespace, "call")
-        assert callable(mod.ClientNamespace.call)
+        sig = inspect.signature(mod.ClientNamespace.call)
+        params = list(sig.parameters.keys())
+        # Exact match to catch stub/runtime mismatches
+        assert params == ["self", "event", "data", "namespace", "timeout"]
+        # Verify timeout default is None (not int)
+        assert sig.parameters["timeout"].default is None
 
     def test_disconnect_method(self) -> None:
         assert hasattr(mod.ClientNamespace, "disconnect")