-
- # CodeBoarding [Diagram-First Documentation]
-
- [](https://github.com/marketplace/actions/codeboarding-diagram-first-documentation)
+
+
+ # CodeBoarding Visual Architecture Review
+
+ Visual system-design review for pull requests. CodeBoarding analyzes the architecture before and after a change, then comments on the PR with an inline Mermaid diagram showing what changed.
+{graph}
+
+""")
+print(f" wrote {dst}")
+PY
+
+echo
+echo "diagram : $OUT/diagram.md"
+echo "preview : $OUT/preview.html"
+if [ "$OPEN" != "no" ]; then
+ if command -v open >/dev/null 2>&1; then open "$OUT/preview.html";
+ elif command -v xdg-open >/dev/null 2>&1; then xdg-open "$OUT/preview.html";
+ else echo "(open $OUT/preview.html in your browser)"; fi
+fi
diff --git a/tests/test_build_cta.py b/tests/test_build_cta.py
new file mode 100644
index 0000000..acb5580
--- /dev/null
+++ b/tests/test_build_cta.py
@@ -0,0 +1,70 @@
+"""Unit tests for scripts/build_cta.py โ editor detection + CTA footer."""
+
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+import build_cta as bc # noqa: E402
+
+
+def repo_with(*dirs):
+ d = Path(tempfile.mkdtemp())
+ for x in dirs:
+ (d / x).mkdir()
+ return d
+
+
+class TestDetectEditors(unittest.TestCase):
+ def test_neither_defaults_to_vscode(self):
+ self.assertEqual(bc.detect_editors(repo_with()), ["vscode"])
+
+ def test_vscode_only(self):
+ self.assertEqual(bc.detect_editors(repo_with(".vscode")), ["vscode"])
+
+ def test_cursor_only(self):
+ self.assertEqual(bc.detect_editors(repo_with(".cursor")), ["cursor"])
+
+ def test_both_vscode_first(self):
+ self.assertEqual(bc.detect_editors(repo_with(".vscode", ".cursor")), ["vscode", "cursor"])
+
+
+class TestBuildCta(unittest.TestCase):
+ def test_empty_base_yields_no_footer(self):
+ self.assertEqual(bc.build_cta("", "o", "r", "1", repo_with()), "")
+
+ def test_warning_shows_without_cta_base(self):
+ out = bc.build_cta("", "o", "r", "1", repo_with(), issues=3)
+ self.assertIn("3 architecture issues found", out)
+ self.assertNotIn("http", out) # no links without a proxy base
+
+ def test_links_banner_and_cursor_only(self):
+ out = bc.build_cta("https://x.dev/", "Org", "Repo", "9", repo_with(".cursor"), issues=2)
+ self.assertIn("2 architecture issues found", out)
+ self.assertNotIn("use-workspace", out) # webview/browser tier deferred โ extension-direct
+ self.assertIn("open-in-editor?owner=Org&repo=Repo&pr=9&editor=cursor", out)
+ self.assertIn("use-marketplace?owner=Org&repo=Repo&pr=9", out)
+ self.assertNotIn("Open in VS Code", out) # cursor-only repo
+
+ def test_no_banner_when_zero_issues_and_default_vscode(self):
+ out = bc.build_cta("https://x.dev", "o", "r", "1", repo_with(), issues=0)
+ self.assertNotIn("architecture issue", out)
+ self.assertIn("Open in VS Code", out)
+ self.assertNotIn("Open in Cursor", out)
+
+ def test_both_editors_singular_issue(self):
+ out = bc.build_cta("https://x.dev", "o", "r", "1", repo_with(".vscode", ".cursor"), issues=1)
+ self.assertIn("1 architecture issue found", out) # singular
+ self.assertIn("Open in VS Code", out)
+ self.assertIn("Open in Cursor", out)
+
+ def test_trailing_slash_in_base_is_normalized(self):
+ a = bc.build_cta("https://x.dev/", "o", "r", "1", repo_with())
+ b = bc.build_cta("https://x.dev", "o", "r", "1", repo_with())
+ self.assertNotIn("x.dev//", a)
+ self.assertEqual(a, b)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_cb_engine.py b/tests/test_cb_engine.py
new file mode 100644
index 0000000..523db5d
--- /dev/null
+++ b/tests/test_cb_engine.py
@@ -0,0 +1,209 @@
+"""Smoke tests for scripts/cb_engine.py โ verify it calls the engine API correctly,
+using stub modules so no real engine venv is needed."""
+
+import sys
+import tempfile
+import types
+import unittest
+from contextlib import redirect_stderr
+from io import StringIO
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+import cb_engine # noqa: E402
+
+_STUBBED = [
+ "codeboarding_workflows", "codeboarding_workflows.analysis",
+ "diagram_analysis", "diagram_analysis.exceptions",
+ "health", "health.models", "health.runner",
+ "static_analyzer", "static_analyzer.analysis_cache",
+]
+
+
+class _Rec:
+ def __init__(self, ret="OUT", raises=None):
+ self.calls = []
+ self._ret, self._raises = ret, raises
+
+ def __call__(self, *a, **k):
+ self.calls.append(k)
+ if self._raises:
+ raise self._raises("boom")
+ return self._ret
+
+
+def _mod(name, **attrs):
+ m = types.ModuleType(name)
+ for k, v in attrs.items():
+ setattr(m, k, v)
+ sys.modules[name] = m
+ return m
+
+
+class _Base(unittest.TestCase):
+ def tearDown(self):
+ for n in _STUBBED:
+ sys.modules.pop(n, None)
+
+
+class TestAnalysis(_Base):
+ def _install(self, run_full=None, run_incremental=None):
+ class BaselineUnavailableError(Exception):
+ pass
+
+ class IncrementalCacheMissingError(Exception):
+ pass
+
+ analysis = _mod(
+ "codeboarding_workflows.analysis",
+ run_full=run_full or _Rec(),
+ run_incremental=run_incremental or _Rec(),
+ BaselineUnavailableError=BaselineUnavailableError,
+ )
+ pkg = _mod("codeboarding_workflows")
+ pkg.analysis = analysis
+ exc = _mod("diagram_analysis.exceptions", IncrementalCacheMissingError=IncrementalCacheMissingError)
+ da = _mod("diagram_analysis")
+ da.exceptions = exc
+ return analysis, IncrementalCacheMissingError, BaselineUnavailableError
+
+ def test_base_calls_run_full(self):
+ rf = _Rec()
+ self._install(run_full=rf)
+ cb_engine.run_base("/repo", "/out", "myrepo", "rid-base", 2, "abc123")
+ self.assertEqual(len(rf.calls), 1)
+ k = rf.calls[0]
+ self.assertEqual(k["repo_name"], "myrepo")
+ self.assertEqual(str(k["repo_path"]), "/repo")
+ self.assertEqual(k["depth_level"], 2)
+ self.assertEqual(k["source_sha"], "abc123")
+
+ def test_main_parses_depth_as_int(self):
+ rf = _Rec()
+ self._install(run_full=rf)
+ cb_engine.main([
+ "base",
+ "--repo", "/repo",
+ "--out", "/out",
+ "--name", "myrepo",
+ "--run-id", "rid-base",
+ "--depth", "2",
+ "--source-sha", "abc123",
+ ])
+ self.assertEqual(rf.calls[0]["depth_level"], 2)
+
+ def test_main_rejects_invalid_depth(self):
+ for depth in ("0", "4", "x"):
+ with self.subTest(depth=depth):
+ with redirect_stderr(StringIO()):
+ with self.assertRaises(SystemExit):
+ cb_engine.main([
+ "base",
+ "--repo", "/repo",
+ "--out", "/out",
+ "--name", "myrepo",
+ "--run-id", "rid-base",
+ "--depth", depth,
+ "--source-sha", "abc123",
+ ])
+
+ def test_head_uses_incremental(self):
+ ri, rf = _Rec(), _Rec()
+ self._install(run_full=rf, run_incremental=ri)
+ cb_engine.run_head("/repo", "/out", "r", "rid", 1, "base", "head", "head")
+ self.assertEqual(len(ri.calls), 1)
+ self.assertEqual(len(rf.calls), 0) # no fallback
+ self.assertEqual(ri.calls[0]["base_ref"], "base")
+ self.assertEqual(ri.calls[0]["target_ref"], "head")
+
+ def test_head_falls_back_to_full_on_cache_miss(self):
+ analysis, IncMiss, _ = self._install() # install once so the exception class identity matches
+ rf = _Rec()
+ analysis.run_full = rf
+ analysis.run_incremental = _Rec(raises=IncMiss)
+ out = tempfile.mkdtemp()
+ (Path(out) / "stale.json").write_text("{}") # must be wiped before the full run
+ (Path(out) / "health").mkdir()
+ (Path(out) / "health" / "stale.json").write_text("{}")
+ cb_engine.run_head("/repo", out, "r", "rid", 3, "base", "head", "head")
+ self.assertEqual(len(rf.calls), 1) # fell back to full
+ self.assertEqual(rf.calls[0]["depth_level"], 3)
+ self.assertFalse((Path(out) / "stale.json").exists()) # head dir wiped before full
+ self.assertFalse((Path(out) / "health").exists()) # nested stale artifacts wiped too
+
+ def test_head_falls_back_to_full_on_baseline_unavailable(self):
+ analysis, _, BaseUnavail = self._install() # the other warm-start failure must also fall back
+ rf = _Rec()
+ analysis.run_full = rf
+ analysis.run_incremental = _Rec(raises=BaseUnavail)
+ cb_engine.run_head("/repo", tempfile.mkdtemp(), "r", "rid", 1, "base", "head", "head")
+ self.assertEqual(len(rf.calls), 1) # BaselineUnavailableError also triggers the full re-run
+
+
+class TestHealth(_Base):
+ def _install_health(self, report):
+ class Severity:
+ WARNING, CRITICAL = "warning", "critical"
+
+ class _Cache:
+ def __init__(self, artifact_dir, repo_root):
+ pass
+
+ def get(self):
+ return object() # non-None static analysis
+
+ _mod("health.models", Severity=Severity)
+ _mod("health.runner", run_health_checks=lambda sa, repo_name, repo_path: report)
+ _mod("health", )
+ _mod("static_analyzer.analysis_cache", StaticAnalysisCache=_Cache)
+ _mod("static_analyzer", )
+ return Severity
+
+ def test_counts_warning_and_critical(self):
+ Sev = self._install_health(report=None)
+
+ class FG:
+ def __init__(self, sev, n):
+ self.severity, self.entities = sev, list(range(n))
+
+ class CS:
+ finding_groups = [FG(Sev.WARNING, 2), FG(Sev.CRITICAL, 1), FG("info", 5)]
+
+ report = types.SimpleNamespace(check_summaries=[CS()])
+ self._install_health(report=report)
+ self.assertEqual(cb_engine.run_health("/art", "/repo", "r"), 3) # 2 warnings + 1 critical, info ignored
+
+ def test_prefers_written_health_report(self):
+ artifact_dir = Path(tempfile.mkdtemp())
+ report_dir = artifact_dir / "health"
+ report_dir.mkdir()
+ (report_dir / "health_report.json").write_text(
+ """
+ {
+ "check_summaries": [
+ {"finding_groups": [
+ {"severity": "warning", "entities": [{}, {}]},
+ {"severity": "critical", "entities": [{}]},
+ {"severity": "info", "entities": [{}, {}, {}, {}, {}]}
+ ]}
+ ]
+ }
+ """,
+ encoding="utf-8",
+ )
+ self.assertEqual(cb_engine.run_health(str(artifact_dir), "/repo", "r"), 3)
+
+ def test_malformed_health_report_falls_back(self):
+ artifact_dir = Path(tempfile.mkdtemp())
+ report_dir = artifact_dir / "health"
+ report_dir.mkdir()
+ (report_dir / "health_report.json").write_text("[]", encoding="utf-8")
+ self.assertEqual(cb_engine.run_health(str(artifact_dir), "/repo", "r"), 0)
+
+ def test_missing_module_yields_zero(self):
+ # No health.* modules installed -> import fails -> 0, never raises.
+ self.assertEqual(cb_engine.run_health("/art", "/repo", "r"), 0)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_diff_to_mermaid.py b/tests/test_diff_to_mermaid.py
new file mode 100644
index 0000000..1b14daf
--- /dev/null
+++ b/tests/test_diff_to_mermaid.py
@@ -0,0 +1,233 @@
+"""Unit tests for scripts/diff_to_mermaid.py โ diff logic + Mermaid rendering."""
+
+import re
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+import diff_to_mermaid as dm # noqa: E402
+
+
+def comp(name, files=None, cid=None, subs=None, subrels=None):
+ c = {
+ "name": name,
+ "component_id": cid or name,
+ "file_methods": [{"file_path": f, "methods": m} for f, m in (files or {}).items()],
+ }
+ if subs is not None:
+ c["components"] = subs
+ if subrels is not None:
+ c["components_relations"] = subrels
+ return c
+
+
+def rel(src, dst, label="calls"):
+ return {"src_name": src, "dst_name": dst, "src_id": src, "dst_id": dst, "relation": label}
+
+
+def linkstyle_indices_in_range(text):
+ n_edges = text.count("-->")
+ idxs = [int(x) for m in re.finditer(r"linkStyle ([\d,]+)", text) for x in m.group(1).split(",")]
+ return all(i < n_edges for i in idxs)
+
+
+class TestDiff(unittest.TestCase):
+ def test_added_modified_deleted_unchanged(self):
+ base = {"components": [comp("A", {"a.py": ["f"]}), comp("B"), comp("D")], "components_relations": []}
+ head = {"components": [comp("A", {"a.py": ["f", "g"]}), comp("B"), comp("C")], "components_relations": []}
+ status = {c["name"]: c["diff_status"] for c in dm.build_diff(base, head)["components"]}
+ self.assertEqual(status["A"], "modified") # method added inside the component
+ self.assertEqual(status["B"], "unchanged")
+ self.assertEqual(status["C"], "added")
+ self.assertEqual(status["D"], "deleted")
+
+ def test_structural_change_is_modified(self):
+ base = {"components": [comp("A", {"a.py": ["f"]})], "components_relations": []}
+ head = {"components": [comp("A", {"a.py": ["f"], "b.py": ["h"]})], "components_relations": []}
+ self.assertEqual(dm.build_diff(base, head)["components"][0]["diff_status"], "modified")
+
+ def test_rename_is_add_plus_delete(self):
+ base = {"components": [comp("Old")], "components_relations": []}
+ head = {"components": [comp("New")], "components_relations": []}
+ status = {c["name"]: c["diff_status"] for c in dm.build_diff(base, head)["components"]}
+ self.assertEqual(status, {"New": "added", "Old": "deleted"})
+
+ def test_relation_modified_on_label_change(self):
+ base = {"components": [comp("A"), comp("B")], "components_relations": [rel("A", "B", "uses")]}
+ head = {"components": [comp("A"), comp("B")], "components_relations": [rel("A", "B", "calls")]}
+ self.assertEqual(dm.build_diff(base, head)["components_relations"][0]["diff_status"], "modified")
+
+ def test_relation_added_and_deleted(self):
+ base = {"components": [comp("A"), comp("B")], "components_relations": [rel("A", "B")]}
+ head = {"components": [comp("A"), comp("B")], "components_relations": [rel("B", "A")]}
+ statuses = sorted(r["diff_status"] for r in dm.build_diff(base, head)["components_relations"])
+ self.assertEqual(statuses, ["added", "deleted"])
+
+ def test_parallel_relation_deletion_is_not_label_modification(self):
+ base = {
+ "components": [comp("A"), comp("B")],
+ "components_relations": [rel("A", "B", "uses"), rel("A", "B", "publishes")],
+ }
+ head = {"components": [comp("A"), comp("B")], "components_relations": [rel("A", "B", "uses")]}
+ statuses = sorted(r["diff_status"] for r in dm.build_diff(base, head)["components_relations"])
+ self.assertEqual(statuses, ["deleted", "unchanged"])
+
+
+class TestRender(unittest.TestCase):
+ def _diff(self):
+ base = {"components": [comp("A"), comp("B"), comp("Gone")], "components_relations": [rel("A", "B"), rel("A", "Gone")]}
+ head = {"components": [comp("A", {"x.py": ["f"]}), comp("B"), comp("New")], "components_relations": [rel("A", "B"), rel("A", "New")]}
+ return dm.build_diff(base, head)
+
+ def test_flat_default_has_no_subgraphs(self):
+ text, _ = dm.render_mermaid(self._diff(), render_depth=1)
+ self.assertNotIn("subgraph", text)
+ for cls in ("added", "modified", "deleted"):
+ self.assertIn(f"classDef {cls}", text)
+ self.assertTrue(linkstyle_indices_in_range(text))
+
+ def test_nested_subgraphs_balanced_and_valid(self):
+ base = {"components": [comp("P", subs=[comp("c1"), comp("c2")], subrels=[rel("c1", "c2")])], "components_relations": []}
+ head = {"components": [comp("P", subs=[comp("c1"), comp("c3")], subrels=[rel("c1", "c3")])], "components_relations": []}
+ text, _ = dm.render_mermaid(dm.build_diff(base, head), render_depth=2)
+ sg = sum(1 for line in text.splitlines() if line.strip().startswith("subgraph "))
+ en = sum(1 for line in text.splitlines() if line.strip() == "end")
+ self.assertGreater(sg, 0)
+ self.assertEqual(sg, en)
+ self.assertTrue(linkstyle_indices_in_range(text))
+
+ def test_render_depth_caps_at_data_depth(self):
+ base = {"components": [comp("P", subs=[comp("c1")], subrels=[])], "components_relations": []}
+ head = {"components": [comp("P", subs=[comp("c1"), comp("c2")], subrels=[])], "components_relations": []}
+ diff = dm.build_diff(base, head)
+ deep = dm.render_mermaid(diff, render_depth=5)[0]
+ two = dm.render_mermaid(diff, render_depth=2)[0]
+ self.assertEqual(deep, two) # no level-3 data, so depth 5 == depth 2
+
+ def test_label_escaping(self):
+ head = {"components": [comp('A "q" #h'), comp("B")], "components_relations": []}
+ base = {"components": [comp("B")], "components_relations": []}
+ text, _ = dm.render_mermaid(dm.build_diff(base, head), render_depth=1)
+ self.assertIn("#quot;", text)
+ self.assertIn("#35;", text)
+
+ def test_label_escaping_brackets_break_chars(self):
+ # `]` / `(` / `&` would break GitHub's renderer if left raw.
+ self.assertEqual(dm._esc("Has]Bracket"), "Has#93;Bracket")
+ self.assertEqual(dm._esc("f(x)"), "f#40;x#41;")
+ self.assertEqual(dm._esc("A & B"), "A #amp; B")
+ head = {"components": [comp("Weird]Name(x)"), comp("B")], "components_relations": []}
+ base = {"components": [comp("B")], "components_relations": []}
+ text, _ = dm.render_mermaid(dm.build_diff(base, head))
+ self.assertNotIn("]Name", text) # no raw ] inside a label
+ self.assertIn("#93;", text)
+
+ def test_esc_strips_newlines(self):
+ # A raw newline/CR in a label breaks the whole Mermaid block.
+ self.assertNotIn("\n", dm._esc("line1\nline2"))
+ self.assertNotIn("\r", dm._esc("a\r\nb"))
+
+ def test_truncate_caps_long_edge_label_with_ellipsis(self):
+ out = dm._truncate("x" * 60)
+ self.assertLessEqual(len(out), dm._EDGE_LABEL_MAX)
+ self.assertTrue(out.endswith("โฆ"))
+ self.assertEqual(dm._truncate("short"), "short") # under the cap: unchanged
+
+ def test_changed_flag_relation_only(self):
+ # A label-only relation change leaves n_changed=0 but must report changed=True.
+ base = {"components": [comp("A"), comp("B")], "components_relations": [rel("A", "B", "uses")]}
+ head = {"components": [comp("A"), comp("B")], "components_relations": [rel("A", "B", "calls")]}
+ text, meta = dm.render_mermaid(dm.build_diff(base, head))
+ self.assertEqual(meta["n_changed"], 0)
+ self.assertTrue(meta["changed"])
+ self.assertIsNotNone(text)
+
+ def test_changed_flag_false_when_identical(self):
+ d = {"components": [comp("A"), comp("B")], "components_relations": [rel("A", "B")]}
+ _, meta = dm.render_mermaid(dm.build_diff(d, d))
+ self.assertEqual(meta["n_changed"], 0)
+ self.assertFalse(meta["changed"])
+
+ def test_changed_flag_counts_nested(self):
+ base = {"components": [comp("P", subs=[comp("c1")], subrels=[])], "components_relations": []}
+ head = {"components": [comp("P", subs=[comp("c1", {"x.py": ["f"]})], subrels=[])], "components_relations": []}
+ _, meta = dm.render_mermaid(dm.build_diff(base, head), render_depth=2)
+ self.assertEqual(meta["n_changed"], 1) # the nested child counts
+ self.assertTrue(meta["changed"])
+
+ def test_nested_method_change_highlights_collapsed_parent(self):
+ base = {"components": [comp("P", subs=[comp("c1")], subrels=[])], "components_relations": []}
+ head = {"components": [comp("P", subs=[comp("c1", {"x.py": ["f"]})], subrels=[])], "components_relations": []}
+ text, meta = dm.render_mermaid(dm.build_diff(base, head), render_depth=1)
+ self.assertEqual(meta["n_changed"], 1)
+ self.assertIn("class n_P modified;", text)
+
+ def test_nested_relation_change_highlights_collapsed_parent(self):
+ base = {"components": [comp("P", subs=[comp("c1"), comp("c2")], subrels=[rel("c1", "c2", "uses")])], "components_relations": []}
+ head = {"components": [comp("P", subs=[comp("c1"), comp("c2")], subrels=[rel("c1", "c2", "calls")])], "components_relations": []}
+ text, meta = dm.render_mermaid(dm.build_diff(base, head), render_depth=1)
+ self.assertEqual(meta["n_changed"], 0)
+ self.assertTrue(meta["changed"])
+ self.assertIn("class n_P modified;", text)
+
+ def test_changed_only_keeps_nested_change(self):
+ base = {"components": [comp("P", subs=[comp("c1"), comp("c2")], subrels=[])], "components_relations": []}
+ head = {"components": [comp("P", subs=[comp("c1", {"x.py": ["f"]}), comp("c2")], subrels=[])], "components_relations": []}
+ text, meta = dm.render_mermaid(dm.build_diff(base, head), render_depth=2, changed_only=True)
+ self.assertIsNotNone(text)
+ self.assertTrue(meta["changed"])
+ self.assertFalse(meta["truncated"])
+ self.assertIn("subgraph n_P", text)
+ self.assertIn("class n_c1 modified;", text)
+ self.assertNotIn('n_c2["c2"]', text)
+
+ def test_changed_only_prunes_unchanged_children_of_modified_parent(self):
+ base = {"components": [comp("P", {"p.py": ["old"]}, subs=[comp("c1"), comp("c2")], subrels=[])], "components_relations": []}
+ head = {"components": [comp("P", {"p.py": ["old", "new"]}, subs=[comp("c1"), comp("c2")], subrels=[])], "components_relations": []}
+ text, meta = dm.render_mermaid(dm.build_diff(base, head), render_depth=2, changed_only=True)
+ self.assertIsNotNone(text)
+ self.assertTrue(meta["changed"])
+ self.assertIn('n_P["P"]', text)
+ self.assertNotIn('n_c1["c1"]', text)
+ self.assertNotIn('n_c2["c2"]', text)
+
+ def test_changed_only_is_not_auto_truncated(self):
+ text, meta = dm.render_mermaid(self._diff(), render_depth=1, changed_only=True)
+ self.assertIsNotNone(text)
+ self.assertFalse(meta["truncated"])
+ self.assertTrue(meta["changed_only"])
+ self.assertTrue(meta["requested_changed_only"])
+
+ def test_auto_truncation_reports_rendered_changed_only(self):
+ base = {
+ "components": [comp("A"), comp("B"), comp("C")],
+ "components_relations": [rel("B", "C", "uses"), rel("C", "B", "uses")],
+ }
+ head = {
+ "components": [comp("A", {"a.py": ["f"]}), comp("B"), comp("C")],
+ "components_relations": [rel("B", "C", "uses"), rel("C", "B", "uses")],
+ }
+ old = dm.MAX_EDGES
+ try:
+ dm.MAX_EDGES = 1
+ text, meta = dm.render_mermaid(dm.build_diff(base, head), render_depth=1)
+ finally:
+ dm.MAX_EDGES = old
+ self.assertIsNotNone(text)
+ self.assertTrue(meta["truncated"])
+ self.assertTrue(meta["changed_only"])
+ self.assertFalse(meta["requested_changed_only"])
+
+ def test_empty_returns_none(self):
+ text, meta = dm.render_mermaid({"components": [], "components_relations": []})
+ self.assertIsNone(text)
+ self.assertEqual(meta["n_nodes"], 0)
+
+ def test_no_edge_labels(self):
+ text, _ = dm.render_mermaid(self._diff(), render_depth=1, edge_labels=False)
+ self.assertNotIn(' -- "', text)
+
+
+if __name__ == "__main__":
+ unittest.main()