Graph-Native Infrastructure for Context and Accountable AI Systems
Python agent-memoryaiai-governanceai-infrastructureartificial-intelligencecontext-engineeringcontext-graphsdata-engineeringdecision-intelligencedeveloper-toolsexplainable-aigenerative-aigraph-ragknowledge-graphllmontologyprovenancepythonreasoningsemantic-search
Kg Context Explainability Output Fixes (#419)
Mohd Kaife30ef6cb76de
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 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-10diff --git a/semantica/kg/centrality_calculator.py b/semantica/kg/centrality_calculator.pyindex 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 adjacencyfor rel in relationships:diff --git a/tests/context/test_context_explainability_regression.py b/tests/context/test_context_explainability_regression.pynew file mode 100644index 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