improved tests

tests/test_dag.py

@@ -348,3 +348,63 @@ class TestDAGComplexScenarios:
         assert len(sub) == 2
         assert set(sub["D"]) == {"E"}
         assert set(sub["E"]) == {"F"}
+
+        nested = sub.subgraph("E")
+        assert all_nodes(nested) == {"E", "F"}
+        assert set(nested.reverse["E"]) == set()
+        nested.remove_edge("E", "F")
+        assert "F" in sub["E"]
+        assert "F" in g["E"]
+
+    @pytest.mark.parametrize(
+        ("seeds", "reverse", "expected_nodes", "expected_edges"),
+        [
+            ({"C", "D"}, False, {"C", "D", "E", "F"}, {("D", "E"), ("E", "F")}),
+            ("D", True, {"A", "B", "D"}, {("D", "B"), ("B", "A")}),
+            ("F", False, {"F"}, set()),
+        ],
+        ids=["multiple-seeds", "reverse-extraction", "sink-only"],
+    )
+    def test_subgraph_boundaries(
+        self,
+        seeds: str | set[str],
+        reverse: bool,
+        expected_nodes: set[str],
+        expected_edges: set[tuple[str, str]],
+    ) -> None:
+        graph = DAG[str]()
+        graph["A"] = "B"
+        graph["B"] = {"C", "D"}
+        graph["D"] = "E"
+        graph["E"] = "F"
+
+        subgraph = (graph.reverse if reverse else graph).subgraph(seeds)
+
+        assert all_nodes(subgraph) == expected_nodes
+        assert set(subgraph.topo_sort()) == expected_nodes
+        assert len(subgraph) == len(expected_edges)
+        assert {(source, target) for source in subgraph for target in subgraph[source]} == expected_edges
+        assert {
+            (source, target) for target in subgraph.reverse for source in subgraph.reverse[target]
+        } == expected_edges
+
+    def test_subgraph_preserves_callbacks_without_firing_during_extraction(self) -> None:
+        added: list[tuple[str, str]] = []
+        removed: list[tuple[str, str]] = []
+        graph = DAG[str]()
+        graph.add_edge("A", "B")
+        graph.on_add = lambda source, target: added.append((source, target))
+        graph.on_remove = lambda source, target: removed.append((source, target))
+
+        subgraph = graph.subgraph("A")
+
+        assert subgraph.on_add is graph.on_add
+        assert subgraph.on_remove is graph.on_remove
+        assert added == []
+        assert removed == []
+        subgraph["A"].add("C")
+        subgraph["A"].discard("B")
+        assert added == [("A", "C")]
+        assert removed == [("A", "B")]
+        assert set(graph["A"]) == {"B"}
+        assert set(graph.reverse["B"]) == {"A"}