test: eliminate remaining coverage gaps in invoke

- Remove dead code: _needs_wrapping hasattr(item, "run") branch was
  unreachable because IInvoke protocol check catches it first
- Add test for _InvokeCallableWrapper.__call__ (L74)
- Add test for non-IInvoke class passing through normalize_invoke_callbacks
- Add test for InvokeGroup.on_cancel() before run()
- invoke.py: 0 missing lines, 4 remaining branch partials are all
  structurally unreachable (Protocol body, async race conditions)

Author: fgmacedo

statemachine/invoke.py

@@ -128,9 +128,6 @@ def _needs_wrapping(item: Any) -> bool:
         # StateChart subclass → child machine invoker
         if issubclass(item, StateChart):
             return True
-        # Class whose instances implement IInvoke (has a ``run`` method)
-        if hasattr(item, "run"):
-            return True
     return False
 
 

tests/test_invoke.py

@@ -624,13 +624,16 @@ def run(self, ctx):
         assert result[0] is wrapper
 
     def test_iinvoke_class_with_run_method(self):
+        """IInvoke-compatible class gets wrapped."""
         from statemachine.invoke import _InvokeCallableWrapper
         from statemachine.invoke import normalize_invoke_callbacks
 
         class CustomHandler:
             def run(self, ctx):
                 return "result"
 
+        # CustomHandler satisfies IInvoke protocol (has run method)
+        assert isinstance(CustomHandler(), IInvoke)
         result = normalize_invoke_callbacks(CustomHandler)
         assert len(result) == 1
         assert isinstance(result[0], _InvokeCallableWrapper)
@@ -647,6 +650,19 @@ def my_func():
         assert result[0] is my_func
         assert not isinstance(result[0], _InvokeCallableWrapper)
 
+    def test_non_invoke_class_passes_through(self):
+        """A class without run() (not IInvoke, not StateChart) passes through unwrapped."""
+        from statemachine.invoke import _InvokeCallableWrapper
+        from statemachine.invoke import normalize_invoke_callbacks
+
+        class PlainClass:
+            pass
+
+        result = normalize_invoke_callbacks(PlainClass)
+        assert len(result) == 1
+        assert result[0] is PlainClass
+        assert not isinstance(result[0], _InvokeCallableWrapper)
+
 
 class TestResolveHandler:
     """InvokeManager._resolve_handler edge cases."""
@@ -719,6 +735,26 @@ def on_cancel(self):
         # _instance is None, _is_class is True → early return
         wrapper.on_cancel()  # should not raise
 
+    def test_callable_wrapper_call_returns_handler(self):
+        """__call__ returns the original handler (used by callback system for resolution)."""
+        from statemachine.invoke import _InvokeCallableWrapper
+
+        class MyHandler:
+            def run(self, ctx):
+                return "result"
+
+        wrapper = _InvokeCallableWrapper(MyHandler)
+        assert wrapper() is MyHandler
+
+
+class TestInvokeGroupOnCancelBeforeRun:
+    """InvokeGroup.on_cancel() before run() is a safe no-op."""
+
+    def test_on_cancel_before_run(self):
+        group = invoke_group(lambda: 1)
+        # on_cancel before run — executor is None, no futures
+        group.on_cancel()
+
 
 class TestDoneInvokeEventFactory:
     """done_invoke_ prefix works with both TransitionList and Event."""