Skip to content

Graph-Native Infrastructure for Context and Accountable AI Systems

Kg Context Explainability Output Fixes (#419)

Mohd Kaife30ef6cb76de
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 57b1b247..b5a7ea5e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -295,14 +295,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
- Added full-URI validation in `create_alignment` — raises `ProcessingError` if predicate is a CURIE instead of a full URI, preventing silent storage of unqueryable triples
- Fixed E2E test `test_end_to_end_cross_ontology_uri_flow` — previously mocked the method under test; now uses a real mock backend with `execute_sparql` to exercise the actual expansion and VALUES clause injection flow
- 19 tests added covering: `create_alignment`, `get_alignments`, `suggest_alignments`, merge with alignment computation, `expand_entity_uri` (enabled/disabled), `build_values_clause`, and full E2E cross-ontology query flow
-- **Context Explainability Output Fixes** (PR pending on `context` by @KaifAhmad1):
+- **Context Explainability Output Fixes** (by @KaifAhmad1):
- Fixed decision-node storage in `ContextGraph` so full human-readable `scenario`, `reasoning`, and decision metadata are preserved on graph nodes instead of degrading into opaque IDs or truncated display text
- Fixed causal and precedent reconstruction paths in the context module so returned `Decision` objects prefer readable stored fields over raw node identifiers
- Fixed context aggregate outputs to return enriched readable payloads for influence, causality, similarity, policy-impact, and entity-similarity workflows instead of bare UUID lists or tuple-only results
- Fixed `PolicyEngine.get_affected_decisions()` so both Cypher and fallback branches return consistent decision metadata including `scenario`, `category`, `outcome`, and `confidence`
- Fixed `EntityLinker` similarity flows so enriched similarity results are consumed correctly across internal linking paths and public search aliases
+ - Fixed `CentralityCalculator._build_adjacency()` to handle `ContextGraph` edges (dataclass `ContextEdge` objects with `source_id`/`target_id`) so `calculate_degree_centrality()` and related centrality algorithms work correctly when a `ContextGraph` is passed as the graph store
- Fixed downstream KG integrations in `node_embeddings`, `link_predictor`, `centrality_calculator`, `path_finder`, and context retrieval fallbacks to normalize enriched neighbor/node outputs without breaking graph algorithms
- - Added and updated regression tests covering readable decision text preservation, enriched causal/path outputs, policy-impact results, entity similarity payloads, and compatibility with KG consumers
+ - Added 23 regression tests in `tests/context/test_context_explainability_regression.py` covering readable decision text preservation, enriched causal/path outputs, policy-impact results, entity similarity payloads, and compatibility with KG consumers
## [0.3.0] - 2026-03-10
diff --git a/semantica/kg/centrality_calculator.py b/semantica/kg/centrality_calculator.py
index 6bd4166f..9fe9a956 100644
--- a/semantica/kg/centrality_calculator.py
+++ b/semantica/kg/centrality_calculator.py
@@ -528,6 +528,22 @@ class CentralityCalculator:
relationships = graph.get_relationships()
elif isinstance(graph, dict):
relationships = graph.get("relationships", graph.get("edges", []))
+ elif hasattr(graph, "edges") and not callable(graph.edges):
+ # ContextGraph-style: edges is a list of dataclass objects with source_id/target_id
+ for edge in (graph.edges or []):
+ if isinstance(edge, dict):
+ src = edge.get("source") or edge.get("source_id")
+ tgt = edge.get("target") or edge.get("target_id")
+ else:
+ src = getattr(edge, "source_id", None) or getattr(edge, "source", None)
+ tgt = getattr(edge, "target_id", None) or getattr(edge, "target", None)
+ if src and tgt:
+ src, tgt = str(src), str(tgt)
+ if tgt not in adjacency[src]:
+ adjacency[src].append(tgt)
+ if src not in adjacency[tgt]:
+ adjacency[tgt].append(src)
+ return dict(adjacency)
# Build adjacency
for rel in relationships:
diff --git a/tests/context/test_context_explainability_regression.py b/tests/context/test_context_explainability_regression.py
new file mode 100644
index 00000000..777ecec5
--- /dev/null
+++ b/tests/context/test_context_explainability_regression.py
@@ -0,0 +1,564 @@
+"""
+Regression tests for Context Explainability Output Fixes.
+
+Covers:
+- Readable decision text preservation in ContextGraph nodes and reconstruction paths
+- Enriched causal/path outputs (from_scenario, to_scenario, scenario/outcome/category dicts)
+- PolicyEngine.get_affected_decisions() consistent metadata across Cypher and fallback branches
+- EntityLinker similarity flows return full enriched payloads
+- KG consumer compatibility (node_embeddings, link_predictor, centrality_calculator, path_finder)
+ when ContextGraph is used as the graph store and get_neighbors returns enriched dicts
+"""
+
+import pytest
+from datetime import datetime, timedelta
+from unittest.mock import MagicMock, patch, PropertyMock
+from typing import Any, Dict, List
+
+from semantica.context.context_graph import ContextGraph
+from semantica.context.decision_models import Decision
+from semantica.context.entity_linker import EntityLinker
+from semantica.context.policy_engine import PolicyEngine
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_decision(decision_id: str, scenario: str, reasoning: str,
+ category: str = "test", outcome: str = "approved",
+ confidence: float = 0.9, decision_maker: str = "agent_1") -> Decision:
+ return Decision(
+ decision_id=decision_id,
+ category=category,
+ scenario=scenario,
+ reasoning=reasoning,
+ outcome=outcome,
+ confidence=confidence,
+ timestamp=datetime.now(),
+ decision_maker=decision_maker,
+ )
+
+
+# ===========================================================================
+# Group 1 – Readable Decision Text Preservation
+# ===========================================================================
+
+class TestReadableDecisionTextPreservation:
+ """Decision-node storage preserves full human-readable text, not IDs."""
+
+ def test_add_decision_scenario_stored_as_content(self):
+ """scenario is stored as node.content, not as an opaque ID."""
+ g = ContextGraph()
+ d = _make_decision(
+ "d1",
+ scenario="Loan application for first-time buyer: $300k, FICO 720",
+ reasoning="Strong credit profile with stable income"
+ )
+ g.add_decision(d)
+
+ node = g.nodes["d1"]
+ assert node.content == d.scenario, (
+ "node.content must equal the full human-readable scenario string"
+ )
+ assert node.content != "d1", "node.content must NOT be the node ID"
+
+ def test_add_decision_reasoning_preserved_in_properties(self):
+ """Full reasoning text is stored in node.properties, not truncated."""
+ g = ContextGraph()
+ long_reasoning = (
+ "Customer has 8-year payment history, zero delinquencies, debt-to-income "
+ "ratio of 28%, salary verified at $95k/year via W-2. Risk score: LOW."
+ )
+ d = _make_decision("d2", "Credit card limit review", long_reasoning)
+ g.add_decision(d)
+
+ node = g.nodes["d2"]
+ assert node.properties["reasoning"] == long_reasoning
+ assert len(node.properties["reasoning"]) > 50
+
+ def test_find_precedents_returns_decision_with_readable_scenario(self):
+ """find_precedents() returns Decision objects whose .scenario is readable text."""
+ g = ContextGraph()
+ cause = _make_decision(
+ "cause_1",
+ scenario="Overdraft protection request – account in good standing 5 yrs",
+ reasoning="Long account history, low overdraft frequency"
+ )
+ effect = _make_decision(
+ "effect_1",
+ scenario="Fee waiver granted due to precedent overdraft approval",
+ reasoning="Follows precedent cause_1"
+ )
+ g.add_decision(cause)
+ g.add_decision(effect)
+ g.add_causal_relationship("cause_1", "effect_1", "PRECEDENT_FOR")
+
+ precedents = g.find_precedents("effect_1")
+ assert len(precedents) >= 1, "Should return at least one precedent"
+
+ p = precedents[0]
+ assert isinstance(p, Decision)
+ assert p.scenario, "Returned Decision.scenario must not be empty"
+ assert "overdraft" in p.scenario.lower() or "Overdraft" in p.scenario, (
+ f"scenario should contain human-readable text, got: {p.scenario!r}"
+ )
+ assert p.scenario != "cause_1", "scenario must NOT be the raw node ID"
+
+ def test_get_causal_chain_returns_readable_text(self):
+ """get_causal_chain() returns Decision objects with scenario text from node.content."""
+ g = ContextGraph()
+ for did, scenario in [
+ ("root", "Initial fraud alert triggered on account #7734"),
+ ("mid", "Temporary hold placed pending fraud investigation"),
+ ("leaf", "Card blocked; customer notified via SMS"),
+ ]:
+ g.add_decision(_make_decision(did, scenario, f"reasoning for {did}"))
+
+ g.add_causal_relationship("root", "mid", "CAUSED")
+ g.add_causal_relationship("mid", "leaf", "CAUSED")
+
+ chain = g.get_causal_chain("leaf", direction="upstream")
+ assert len(chain) >= 1
+
+ for dec in chain:
+ assert isinstance(dec, Decision)
+ assert dec.scenario, "Each chained Decision must have non-empty scenario"
+ assert dec.scenario != dec.decision_id, (
+ f"scenario '{dec.scenario}' must not equal the decision_id"
+ )
+
+
+# ===========================================================================
+# Group 2 – Enriched Causal / Path Outputs
+# ===========================================================================
+
+class TestEnrichedCausalOutputs:
+ """trace_decision_causality and analyze_decision_influence return readable dicts."""
+
+ def _graph_with_decisions(self):
+ g = ContextGraph()
+ alpha_id = g.record_decision(
+ category="mortgage",
+ scenario="Approve mortgage for tech employee earning $180k",
+ reasoning="Strong credit profile and stable income verified",
+ outcome="approved",
+ confidence=0.92,
+ entities=["tech_employee", "mortgage_dept"],
+ )
+ beta_id = g.record_decision(
+ category="auto_loan",
+ scenario="Approve auto-loan backed by employer letter",
+ reasoning="Employer verification provided, income above threshold",
+ outcome="approved",
+ confidence=0.85,
+ entities=["tech_employee", "auto_dept"],
+ )
+ return g, alpha_id, beta_id
+
+ def test_trace_decision_causality_hops_have_scenario_fields(self):
+ """Each causal hop includes from_scenario and to_scenario with readable text."""
+ g, alpha_id, beta_id = self._graph_with_decisions()
+ chains = g.trace_decision_causality(beta_id, max_depth=3)
+
+ # At least one hop should exist (shared entity creates causal link)
+ if chains:
+ for hop_list in chains:
+ for hop in hop_list:
+ assert "from" in hop, "hop must have 'from' key"
+ assert "to" in hop, "hop must have 'to' key"
+ assert "from_scenario" in hop, (
+ f"hop must have 'from_scenario' key, got keys: {list(hop.keys())}"
+ )
+ assert "to_scenario" in hop, (
+ f"hop must have 'to_scenario' key, got keys: {list(hop.keys())}"
+ )
+ # Scenarios must be strings, not empty IDs
+ assert isinstance(hop["from_scenario"], str)
+ assert isinstance(hop["to_scenario"], str)
+
+ def test_analyze_decision_influence_direct_influence_is_enriched_dicts(self):
+ """direct_influence list contains dicts with decision_id, scenario, outcome, category."""
+ g, alpha_id, beta_id = self._graph_with_decisions()
+ result = g.analyze_decision_influence(alpha_id)
+
+ assert "direct_influence" in result
+ assert isinstance(result["direct_influence"], list)
+
+ for item in result["direct_influence"]:
+ assert isinstance(item, dict), (
+ f"direct_influence items must be dicts, got {type(item)}"
+ )
+ for field in ("decision_id", "scenario", "outcome", "category"):
+ assert field in item, (
+ f"influence item missing field '{field}', keys: {list(item.keys())}"
+ )
+
+ def test_analyze_decision_influence_scores_contain_readable_fields(self):
+ """influence_scores entries include scenario/outcome/category alongside score."""
+ g, alpha_id, beta_id = self._graph_with_decisions()
+ result = g.analyze_decision_influence(alpha_id)
+
+ assert "influence_scores" in result
+ for item in result["influence_scores"]:
+ assert "score" in item
+ assert "decision_id" in item
+ assert "scenario" in item
+ assert "category" in item
+ assert "outcome" in item
+
+
+# ===========================================================================
+# Group 3 – PolicyEngine Consistent Decision Metadata
+# ===========================================================================
+
+class TestPolicyEngineAffectedDecisions:
+ """get_affected_decisions() returns enriched metadata from both branches."""
+
+ def _mock_store_with_query(self, records):
+ store = MagicMock()
+ store.execute_query.return_value = records
+ return store
+
+ def test_cypher_branch_returns_scenario_category_outcome_confidence(self):
+ """Cypher results include scenario/category/outcome/confidence with actual values."""
+ records = [
+ {
+ "decision_id": "dec_abc",
+ "scenario": "Increase credit limit for platinum member",
+ "category": "credit",
+ "outcome": "approved",
+ "confidence": 0.88,
+ }
+ ]
+ store = self._mock_store_with_query(records)
+ pe = PolicyEngine(graph_store=store)
+
+ affected = pe.get_affected_decisions("policy_1", "v1", "v2")
+
+ assert len(affected) == 1
+ d = affected[0]
+ assert d["scenario"] == "Increase credit limit for platinum member", (
+ f"scenario must be readable text, got: {d['scenario']!r}"
+ )
+ assert d["category"] == "credit"
+ assert d["outcome"] == "approved"
+ assert d["confidence"] == pytest.approx(0.88, abs=1e-6)
+
+ def test_fallback_branch_enriches_from_context_graph_nodes(self):
+ """Fallback branch reads scenario/category/outcome/confidence from ContextGraph nodes."""
+ g = ContextGraph()
+ d = _make_decision(
+ "dec_xyz",
+ scenario="Block account after 3 failed PIN attempts",
+ reasoning="Security policy v1 requires lockout",
+ category="security",
+ outcome="blocked",
+ confidence=0.99,
+ )
+ g.add_decision(d)
+ # Add a policy node and the APPLIED_POLICY edge
+ g.add_node("policy_2:v1", "Policy", {"policy_id": "policy_2", "version": "v1"})
+ g.add_edge("dec_xyz", "policy_2:v1", "APPLIED_POLICY")
+
+ pe = PolicyEngine(graph_store=g)
+
+ affected = pe.get_affected_decisions("policy_2", "v1", "v2")
+
+ assert len(affected) == 1
+ d_out = affected[0]
+ assert d_out["decision_id"] == "dec_xyz"
+ # scenario must come from node.content, not be empty or the raw ID
+ assert d_out["scenario"], "scenario must not be empty"
+ assert d_out["scenario"] != "dec_xyz", (
+ f"scenario should be readable text not the node ID, got: {d_out['scenario']!r}"
+ )
+ assert "PIN" in d_out["scenario"] or "Block" in d_out["scenario"], (
+ f"scenario should reflect stored decision text, got: {d_out['scenario']!r}"
+ )
+
+ def test_both_branches_return_same_key_shape(self):
+ """Both Cypher and fallback branches return dicts with identical required keys."""
+ required_keys = {"decision_id", "scenario", "category", "outcome", "confidence"}
+
+ # Cypher branch
+ store_cypher = self._mock_store_with_query([{
+ "decision_id": "d1",
+ "scenario": "some scenario",
+ "category": "cat",
+ "outcome": "out",
+ "confidence": 0.5,
+ }])
+ pe_c = PolicyEngine(graph_store=store_cypher)
+ cypher_result = pe_c.get_affected_decisions("p", "v1", "v2")
+ assert len(cypher_result) == 1
+ assert required_keys.issubset(cypher_result[0].keys()), (
+ f"Cypher branch missing keys: {required_keys - cypher_result[0].keys()}"
+ )
+
+ # Fallback branch
+ g = ContextGraph()
+ g.add_decision(_make_decision("d2", "fallback scenario", "fallback reason"))
+ g.add_node("p2:v1", "Policy", {})
+ g.add_edge("d2", "p2:v1", "APPLIED_POLICY")
+ pe_f = PolicyEngine(graph_store=g)
+ fallback_result = pe_f.get_affected_decisions("p2", "v1", "v2")
+ assert len(fallback_result) == 1
+ assert required_keys.issubset(fallback_result[0].keys()), (
+ f"Fallback branch missing keys: {required_keys - fallback_result[0].keys()}"
+ )
+
+
+# ===========================================================================
+# Group 4 – EntityLinker Similarity Payloads
+# ===========================================================================
+
+class TestEntityLinkerSimilarityPayloads:
+ """EntityLinker similarity flows return enriched dicts, not bare IDs."""
+
+ def _linker(self):
+ return EntityLinker(
+ knowledge_graph={
+ "entities": [
+ {
+ "id": "ent_python",
+ "text": "Python programming language",
+ "type": "Technology",
+ },
+ {
+ "id": "ent_java",
+ "text": "Java programming language",
+ "type": "Technology",
+ },
+ {
+ "id": "ent_sql",
+ "text": "SQL database query language",
+ "type": "Language",
+ },
+ ]
+ }
+ )
+
+ def test_find_similar_entities_returns_full_payload_keys(self):
+ """find_similar_entities() returns dicts with entity_id, text, type, uri, similarity."""
+ linker = self._linker()
+ results = linker.find_similar_entities("Python language", threshold=0.1)
+
+ assert isinstance(results, list)
+ assert len(results) >= 1, "Should find at least one similar entity"
+
+ for item in results:
+ assert isinstance(item, dict)
+ for field in ("entity_id", "text", "type", "similarity"):
+ assert field in item, (
+ f"find_similar_entities result missing field '{field}', got: {list(item.keys())}"
+ )
+ # entity_id must be the stored ID, not empty
+ assert item["entity_id"], "entity_id must not be empty"
+ # similarity must be a non-negative float
+ assert isinstance(item["similarity"], (int, float))
+ assert item["similarity"] >= 0.0
+
+ def test_find_similar_entities_text_field_is_human_readable(self):
+ """text field in similarity results is human-readable entity text, not an ID."""
+ linker = self._linker()
+ results = linker.find_similar_entities("Python language", threshold=0.1)
+
+ assert len(results) >= 1
+ for item in results:
+ assert item["text"] != item["entity_id"], (
+ f"text should be human-readable, not the entity ID: {item['text']!r}"
+ )
+ assert len(item["text"]) > 2
+
+ def test_find_similar_entities_sorted_by_similarity_descending(self):
+ """Results are sorted by similarity in descending order."""
+ linker = self._linker()
+ results = linker.find_similar_entities("Python language", threshold=0.0)
+
+ if len(results) >= 2:
+ for i in range(len(results) - 1):
+ assert results[i]["similarity"] >= results[i + 1]["similarity"], (
+ "Results must be sorted by similarity descending"
+ )
+
+ def test_find_similar_public_alias_returns_full_payload(self):
+ """find_similar() public alias delegates to find_similar_entities and returns full dicts."""
+ linker = self._linker()
+ results = linker.find_similar("Python language", threshold=0.1)
+
+ assert isinstance(results, list)
+ for item in results:
+ assert isinstance(item, dict)
+ assert "entity_id" in item
+ assert "text" in item
+ assert "similarity" in item
+
+ def test_find_similar_with_entity_dict_input(self):
+ """find_similar() accepts an EntityDict as input and returns full dicts."""
+ linker = self._linker()
+ entity_dict = {"text": "Java language", "type": "Technology"}
+ results = linker.find_similar(entity_dict, threshold=0.1)
+
+ assert isinstance(results, list)
+ for item in results:
+ assert "entity_id" in item
+ assert "similarity" in item
+
+ def test_find_linked_entities_creates_entity_links_with_ids(self):
+ """_find_linked_entities creates EntityLink objects with valid target entity IDs."""
+ linker = self._linker()
+ linker.assign_uri("ent_python", "Python programming language", "Technology")
+
+ links = linker._find_linked_entities(
+ entity_id="my_entity",
+ entity_text="Python language",
+ entity_type="Technology",
+ all_entities=[],
+ context=None,
+ )
+
+ assert isinstance(links, list)
+ for link in links:
+ # target_entity_id must be a stored entity ID, not empty or equal to text
+ assert link.target_entity_id, "target_entity_id must not be empty"
+ assert link.target_entity_id.startswith("ent_"), (
+ f"target_entity_id should be a stored entity ID, got: {link.target_entity_id!r}"
+ )
+ assert link.confidence >= 0.0
+
+
+# ===========================================================================
+# Group 5 – KG Consumer Compatibility
+# ===========================================================================
+
+class TestKGConsumerCompatibility:
+ """KG algorithms normalize enriched neighbor/node dicts from ContextGraph correctly."""
+
+ def _graph_with_nodes(self, pairs):
+ """Build a ContextGraph with given (id, label) pairs connected in a chain."""
+ g = ContextGraph()
+ for nid, label in pairs:
+ g.add_node(nid, label, {"name": nid})
+ # Connect in order
+ ids = [nid for nid, _ in pairs]
+ for i in range(len(ids) - 1):
+ g.add_edge(ids[i], ids[i + 1], "RELATED_TO")
+ return g
+
+ def test_node_embedder_build_adjacency_normalizes_enriched_dicts(self):
+ """NodeEmbedder._build_adjacency strips enriched dicts to node IDs (no crash, no None)."""
+ from semantica.kg.node_embeddings import NodeEmbedder
+
+ g = self._graph_with_nodes([("A", "Person"), ("B", "Person"), ("C", "Person")])
+ embedder = NodeEmbedder()
+
+ # Verify get_neighbors on ContextGraph returns dicts (enriched)
+ raw = g.get_neighbors("A")
+ assert isinstance(raw[0], dict), "ContextGraph.get_neighbors should return dicts"
+ assert "id" in raw[0]
+
+ adjacency = embedder._build_adjacency(g, ["Person", "Person"], ["RELATED_TO"])
+ # Each node maps to a list of plain string IDs
+ for node_id, neighbors in adjacency.items():
+ assert isinstance(node_id, str)
+ for nb in neighbors:
+ assert isinstance(nb, str), (
+ f"adjacency neighbor must be a string ID, got {type(nb)}: {nb!r}"
+ )
+ assert nb is not None
+
+ def test_link_predictor_get_node_neighbors_normalizes_enriched_dicts(self):
+ """LinkPredictor._get_node_neighbors strips enriched dicts to plain IDs."""
+ from semantica.kg.link_predictor import LinkPredictor
+
+ g = self._graph_with_nodes([("X", "Item"), ("Y", "Item"), ("Z", "Item")])
+ predictor = LinkPredictor()
+
+ neighbors = predictor._get_node_neighbors(g, "X")
+ assert isinstance(neighbors, list)
+ for nb in neighbors:
+ assert isinstance(nb, str), (
+ f"neighbor must be a plain string ID, got {type(nb)}: {nb!r}"
+ )
+ assert nb is not None
+
+ def test_link_predictor_score_link_works_with_context_graph(self):
+ """score_link() runs without error when given a ContextGraph store."""
+ from semantica.kg.link_predictor import LinkPredictor
+
+ g = self._graph_with_nodes([
+ ("n1", "Entity"), ("n2", "Entity"), ("n3", "Entity")
+ ])
+ predictor = LinkPredictor()
+
+ score = predictor.score_link(g, "n1", "n3", method="common_neighbors")
+ assert isinstance(score, (int, float))
+ assert score >= 0.0
+
+ def test_centrality_calculator_get_filtered_neighbors_normalizes_dicts(self):
+ """CentralityCalculator._get_filtered_neighbors strips enriched dicts to IDs."""
+ from semantica.kg.centrality_calculator import CentralityCalculator
+
+ g = self._graph_with_nodes([("c1", "Node"), ("c2", "Node"), ("c3", "Node")])
+ calc = CentralityCalculator()
+
+ neighbors = calc._get_filtered_neighbors(g, "c1", relationship_types=None)
+ assert isinstance(neighbors, list)
+ for nb in neighbors:
+ assert isinstance(nb, str), (
+ f"filtered neighbor must be a plain string ID, got {type(nb)}: {nb!r}"
+ )
+
+ def test_centrality_calculator_degree_centrality_works_with_context_graph(self):
+ """calculate_degree_centrality() works with ContextGraph as the graph store."""
+ from semantica.kg.centrality_calculator import CentralityCalculator
+
+ g = self._graph_with_nodes([
+ ("hub", "Node"), ("spoke1", "Node"), ("spoke2", "Node")
+ ])
+ g.add_edge("hub", "spoke2", "RELATED_TO") # hub has extra edge
+ calc = CentralityCalculator()
+
+ result = calc.calculate_degree_centrality(g)
+ assert isinstance(result, dict)
+ # result has keys: centrality, rankings, max_degree, total_nodes
+ assert "centrality" in result
+ centrality = result["centrality"]
+ assert isinstance(centrality, dict)
+ assert len(centrality) > 0
+ for node_id, score in centrality.items():
+ assert isinstance(node_id, str)
+ assert isinstance(score, (int, float))
+ assert score >= 0.0
+
+ def test_path_finder_get_neighbors_normalizes_enriched_dicts(self):
+ """PathFinder._get_neighbors strips enriched dicts to (id, edge_data) tuples."""
+ from semantica.kg.path_finder import PathFinder
+
+ g = self._graph_with_nodes([("p1", "Stop"), ("p2", "Stop"), ("p3", "Stop")])
+ finder = PathFinder()
+
+ neighbors = finder._get_neighbors(g, "p1")
+ assert isinstance(neighbors, list)
+ for item in neighbors:
+ node_id, edge_data = item
+ assert isinstance(node_id, str), (
+ f"neighbor node_id must be a plain string, got {type(node_id)}: {node_id!r}"
+ )
+ assert node_id is not None
+
+ def test_path_finder_dijkstra_works_with_context_graph(self):
+ """dijkstra_shortest_path() runs without error on ContextGraph."""
+ from semantica.kg.path_finder import PathFinder
+
+ g = self._graph_with_nodes([
+ ("start", "Node"), ("mid", "Node"), ("end", "Node")
+ ])
+ finder = PathFinder()
+
+ result = finder.dijkstra_shortest_path(g, "start", "end")
+ assert result is not None
+ assert isinstance(result, list)
+ assert "start" in result
+ assert "end" in result