test: reach 100% branch coverage for diagram package

Add tests for extract.py (deep history type, internal transitions with
and without actions, bidirectional compound detection, invalid input,
initial state fallback), dot.py (compound labels with actions, internal
action format, targetless transitions, non-bidirectional anchors), and
__main__.py (via runpy).

Mark unreachable branch in extract.py (history states never have
substates) with pragma: no cover, and add `if __name__` to coverage
exclusions in pyproject.toml.

Author: fgmacedo

pyproject.toml

@@ -116,6 +116,7 @@ exclude_lines = [
     "raise AssertionError",
     "raise NotImplementedError",
     "if TYPE_CHECKING",
+    'if __name__ == "__main__"',
 ]
 
 [tool.coverage.html]

statemachine/contrib/diagram/extract.py

@@ -131,7 +131,7 @@ def _extract_all_transitions(states, getter) -> List[DiagramTransition]:
             result.extend(_extract_all_transitions(state.states, getter))
         for history_state in getattr(state, "history", []):
             result.extend(_extract_transitions_from_state(history_state, getter))
-            if history_state.states:
+            if history_state.states:  # pragma: no cover
                 result.extend(_extract_all_transitions(history_state.states, getter))
     return result
 

tests/test_contrib_diagram.py

@@ -8,6 +8,7 @@
 from statemachine.contrib.diagram import DotGraphMachine
 from statemachine.contrib.diagram import main
 from statemachine.contrib.diagram import quickchart_write_svg
+from statemachine.contrib.diagram.model import ActionType
 from statemachine.contrib.diagram.model import StateType
 from statemachine.contrib.diagram.renderers.dot import DotRenderer
 
@@ -489,6 +490,165 @@ class SM(StateChart):
             )
 
 
+class TestExtract:
+    """Tests for extract.py edge cases."""
+
+    def test_deep_history_state_type(self):
+        """Deep history state is correctly typed in the extracted graph."""
+        from statemachine.contrib.diagram.extract import extract
+
+        from tests.machines.showcase_deep_history import DeepHistorySC
+
+        graph = extract(DeepHistorySC)
+        # Find the history state in the outer compound's children
+        outer = next(s for s in graph.states if s.id == "outer")
+        h_state = next(s for s in outer.children if s.type == StateType.HISTORY_DEEP)
+        assert h_state is not None
+
+    def test_internal_transition_actions_extracted(self):
+        """Internal transitions with actions are extracted into state actions."""
+        from statemachine.contrib.diagram.extract import extract
+
+        from tests.machines.showcase_internal import InternalSC
+
+        graph = extract(InternalSC)
+        monitoring = next(s for s in graph.states if s.id == "monitoring")
+        internal_actions = [a for a in monitoring.actions if a.type == ActionType.INTERNAL]
+        assert len(internal_actions) >= 1
+        assert any("check" in a.body for a in internal_actions)
+
+    def test_internal_transition_skipped_in_bidirectional(self):
+        """Internal transitions are skipped in _collect_bidirectional_compound_ids."""
+        from statemachine.contrib.diagram.extract import extract
+
+        class SM(StateChart):
+            class parent(State.Compound, name="Parent"):
+                child1 = State(initial=True)
+                child2 = State(final=True)
+
+                def log(self): ...
+
+                check = child1.to.itself(internal=True, on="log")
+                go = child1.to(child2)
+
+            start = State(initial=True)
+            end = State(final=True)
+
+            enter = start.to(parent)
+            finish = parent.to(end)
+
+        graph = extract(SM)
+        # parent has both incoming and outgoing, so it should be bidirectional
+        assert "parent" in graph.bidirectional_compound_ids
+
+    def test_internal_transition_without_action(self):
+        """Internal transition without on action has no internal action in diagram."""
+        from statemachine.contrib.diagram.extract import extract
+
+        class SM(StateChart):
+            s1 = State(initial=True)
+            s2 = State(final=True)
+
+            noop = s1.to.itself(internal=True)
+            go = s1.to(s2)
+
+        graph = extract(SM)
+        s1 = next(s for s in graph.states if s.id == "s1")
+        internal_actions = [a for a in s1.actions if a.type == ActionType.INTERNAL]
+        assert internal_actions == []
+
+    def test_extract_invalid_type_raises(self):
+        """extract() raises TypeError for invalid input."""
+        from statemachine.contrib.diagram.extract import extract
+
+        with pytest.raises(TypeError, match="Expected a StateChart"):
+            extract("not a machine")  # type: ignore[arg-type]
+
+    def test_resolve_initial_fallback(self):
+        """When no explicit initial, first candidate gets is_initial=True."""
+        from statemachine.contrib.diagram.extract import _resolve_initial_states
+        from statemachine.contrib.diagram.model import DiagramState
+
+        states = [
+            DiagramState(id="a", name="A", type=StateType.REGULAR),
+            DiagramState(id="b", name="B", type=StateType.REGULAR),
+        ]
+        _resolve_initial_states(states)
+        assert states[0].is_initial is True
+
+
+class TestDotRendererEdgeCases:
+    """Tests for dot.py edge cases."""
+
+    def test_compound_state_with_actions_label(self):
+        """Compound state with entry/exit actions renders action rows in label."""
+
+        class SM(StateChart):
+            class parent(State.Compound, name="Parent"):
+                child = State(initial=True)
+
+                def on_enter_parent(self): ...
+
+            start = State(initial=True)
+            enter = start.to(parent)
+
+        dot = DotGraphMachine(SM)().to_string()
+        # The compound label should contain the entry action
+        assert "entry" in dot.lower() or "on_enter_parent" in dot
+
+    def test_internal_action_format(self):
+        """Internal action uses body directly (no 'entry /' prefix)."""
+        renderer = DotRenderer()
+        from statemachine.contrib.diagram.model import DiagramAction
+
+        action = DiagramAction(type=ActionType.INTERNAL, body="check / log_status")
+        result = renderer._format_action(action)
+        assert result == "check / log_status"
+
+    def test_targetless_transition_self_loop(self):
+        """Transition with no target falls back to source as destination."""
+        from statemachine.contrib.diagram.model import DiagramTransition
+
+        transition = DiagramTransition(source="s1", targets=[], event="tick")
+        renderer = DotRenderer()
+        renderer._compound_ids = set()
+        edges = renderer._create_edges(transition)
+        assert len(edges) == 1
+        # With no targets, target_ids becomes [None], and dst becomes source
+        assert edges[0].obj_dict["points"][1] == "s1"
+
+    def test_compound_edge_anchor_non_bidirectional(self):
+        """Non-bidirectional compound state uses generic _anchor node."""
+        renderer = DotRenderer()
+        renderer._compound_bidir_ids = {"other"}
+        result = renderer._compound_edge_anchor("my_state", "out")
+        assert result == "my_state_anchor"
+
+
+class TestDiagramMainModule:
+    """Tests for __main__.py."""
+
+    def test_main_module_execution(self, tmp_path):
+        """python -m statemachine.contrib.diagram works."""
+        import runpy
+
+        out = tmp_path / "sm.svg"
+        with mock.patch(
+            "sys.argv",
+            [
+                "statemachine.contrib.diagram",
+                "tests.examples.traffic_light_machine.TrafficLightMachine",
+                str(out),
+            ],
+        ):
+            with pytest.raises(SystemExit) as exc_info:
+                runpy.run_module(
+                    "statemachine.contrib.diagram", run_name="__main__", alter_sys=True
+                )
+            assert exc_info.value.code is None
+        assert out.exists()
+
+
 class TestSphinxDirective:
     """Unit tests for the statemachine-diagram Sphinx directive."""