This repository has been archived on 2026-09-23. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
zhiyi/tests/test_graph.py
T
xiaowei 58eaf9d59c feat: Phase 2.1 知识图谱 + Phase 2.2 Peer Representation
Phase 2.1 知识图谱 (src/graph/):
- GraphNode/GraphEdge 数据模型
- GraphBuilder: 从 Distilled 构建节点和边
- GraphQuery: BFS 多跳导航, degree_centrality, jaccard_similarity
- LazyIndexer: 懒加载索引管理

Phase 2.2 Peer Representation (src/peer/):
- PeerRepr 数据模型: explicit/deductive/induced preferences
- DecayCalculator: 线性衰减公式 score=max(0.1, 1.0-days*0.015)
- Tier 分层: CORE/ACTIVE/PASSIVE/DEPRECATED
- 三步推理引擎: Explicit/Deductive/Inductive Inference
- 置信度聚合: 0.35*deductive + 0.35*induced + 0.30*explicit

Tests: 37 passed (test_graph.py + test_peer.py)
2026-05-25 03:11:20 +08:00

250 lines
8.9 KiB
Python

"""
Tests for graph module.
"""
import pytest
import tempfile
from pathlib import Path
from datetime import datetime
import networkx as nx
from src.graph.models import GraphNode, GraphEdge, NodeType, EdgeType
from src.graph.builder import GraphBuilder
from src.graph.query import GraphQuery
from src.graph.indexer import LazyIndexer
from src.models.distilled import Distilled
class TestGraphNode:
def test_create_entity_node(self):
node = GraphNode.from_entity(
entity="牧尘",
distilled_id="test-123",
episode_id="ep-456",
confidence=0.8,
importance=2
)
assert node.type == NodeType.ENTITY
assert node.label == "牧尘"
assert node.distilled_id == "test-123"
def test_create_fact_node(self):
node = GraphNode.from_fact(
fact="牧尘喜欢简洁的回答",
distilled_id="test-123",
episode_id="ep-456",
confidence=0.9
)
assert node.type == NodeType.FACT
assert "简洁" in node.label
def test_to_dict_roundtrip(self):
node = GraphNode.from_entity("测试", "d1", "e1")
d = node.to_dict()
node2 = GraphNode.from_dict(d)
assert node.id == node2.id
assert node.label == node2.label
assert node.type == node2.type
def test_node_importance_assignment(self):
node = GraphNode.from_entity("重要人物", "d1", "e1", importance=3)
assert node.importance == 3
class TestGraphEdge:
def test_create_edge(self):
node_a = GraphNode.from_entity("A", "d1", "e1")
node_b = GraphNode.from_entity("B", "d2", "e2")
edge = GraphEdge.create_relation(
source_id=node_a.id,
target_id=node_b.id,
relation=EdgeType.RELATES_TO,
weight=0.9
)
assert edge.source == node_a.id
assert edge.target == node_b.id
assert edge.weight == 0.9
def test_to_dict_roundtrip(self):
node_a = GraphNode.from_entity("A", "d1", "e1")
node_b = GraphNode.from_entity("B", "d2", "e2")
edge = GraphEdge.create_relation(node_a.id, node_b.id, EdgeType.SIMILAR_TO, weight=0.8)
d = edge.to_dict()
edge2 = GraphEdge.from_dict(d)
assert edge.id == edge2.id
assert edge.relation == edge2.relation
class TestGraphBuilder:
def test_build_graph_from_distilled(self):
"""Test building a graph from a Distilled record."""
distilled = Distilled(
id="distilled-1",
episode_id="ep-1",
type="fact",
summary="测试总结",
facts=[
"牧尘喜欢简洁",
"牧尘偏好Python",
"牧尘用Arch Linux"
],
entities=["牧尘"],
confidence=0.8,
status="active",
importance=2
)
builder = GraphBuilder()
builder.add_distilled(distilled)
graph = builder.graph
# Should create entity nodes + fact nodes
assert len(graph.nodes) >= 4 # 至少:entity "牧尘" + 3 facts
def test_entity_extraction_from_facts(self):
"""Test that entities are properly extracted from facts."""
distilled = Distilled(
id="distilled-2",
episode_id="ep-2",
type="fact",
summary="",
facts=["牧尘使用ComfyUI"],
entities=["牧尘", "ComfyUI"],
confidence=0.7
)
builder = GraphBuilder()
builder.add_distilled(distilled)
graph = builder.graph
# Both entity and fact should create nodes
assert len(graph.nodes) >= 2
class TestGraphQuery:
def setup_method(self):
"""Set up a test graph using NetworkX directly."""
# Create a simple graph: A -> B -> C, A -> D
self.graph = nx.DiGraph()
self.node_a = GraphNode.from_entity("A", "d1", "e1")
self.node_b = GraphNode.from_entity("B", "d2", "e2")
self.node_c = GraphNode.from_entity("C", "d3", "e3")
self.node_d = GraphNode.from_entity("D", "d4", "e4")
# Add nodes to graph with data
self.graph.add_node(self.node_a.id, **self.node_a.to_dict())
self.graph.add_node(self.node_b.id, **self.node_b.to_dict())
self.graph.add_node(self.node_c.id, **self.node_c.to_dict())
self.graph.add_node(self.node_d.id, **self.node_d.to_dict())
# A -> B -> C (2 hops), A -> D (1 hop)
self.graph.add_edge(self.node_a.id, self.node_b.id, **GraphEdge.create_relation(
self.node_a.id, self.node_b.id, EdgeType.RELATES_TO, weight=0.9
).to_dict())
self.graph.add_edge(self.node_b.id, self.node_c.id, **GraphEdge.create_relation(
self.node_b.id, self.node_c.id, EdgeType.RELATES_TO, weight=0.9
).to_dict())
self.graph.add_edge(self.node_a.id, self.node_d.id, **GraphEdge.create_relation(
self.node_a.id, self.node_d.id, EdgeType.RELATES_TO, weight=0.8
).to_dict())
def test_bfs_1_hop(self):
"""Test BFS with 1 hop."""
query = GraphQuery(self.graph)
result = query.bfs_n_hops(self.node_a.id, max_hops=1)
# 1 hop should reach B and D (not C which is 2 hops away)
assert 1 in result
found_1hop = result.get(1, set())
assert self.node_b.id in found_1hop
assert self.node_d.id in found_1hop
assert self.node_c.id not in found_1hop
def test_bfs_2_hops(self):
"""Test BFS with 2 hops."""
query = GraphQuery(self.graph)
result = query.bfs_n_hops(self.node_a.id, max_hops=2)
# 2 hops should reach C (through B)
assert 2 in result
found_2hops = result.get(2, set())
assert self.node_c.id in found_2hops
def test_degree_centrality(self):
"""Test degree centrality calculation."""
query = GraphQuery(self.graph)
centrality = query.degree_centrality()
# Graph has 4 nodes, n-1 = 3
# A: out-degree=2, degree=2 → 2/3
# B: out-degree=1, degree=2 → 2/3 (in+out)
# C: out-degree=0, degree=1 → 1/3
# D: out-degree=0, degree=1 → 1/3
assert centrality[self.node_a.id] == 2.0 / 3.0
assert centrality[self.node_b.id] == 2.0 / 3.0
assert centrality[self.node_c.id] == 1.0 / 3.0
assert centrality[self.node_d.id] == 1.0 / 3.0
def test_jaccard_similarity(self):
"""Test Jaccard similarity between nodes."""
# Add shared neighbor for A and B
node_e = GraphNode.from_entity("E", "d5", "e5")
self.graph.add_node(node_e.id, **node_e.to_dict())
# A -> E, B -> E (both connect to E)
self.graph.add_edge(self.node_a.id, node_e.id, **GraphEdge.create_relation(
self.node_a.id, node_e.id, EdgeType.RELATES_TO, weight=0.9
).to_dict())
self.graph.add_edge(self.node_b.id, node_e.id, **GraphEdge.create_relation(
self.node_b.id, node_e.id, EdgeType.RELATES_TO, weight=0.9
).to_dict())
query = GraphQuery(self.graph)
sim = query.jaccard_similarity(self.node_a.id, self.node_b.id)
# A has neighbors {B, D, E}, B has neighbors {C, E}
# Jaccard = |{E}| / |{B, D, E, C}| = 1/4
assert 0 < sim <= 1
class TestLazyIndexer:
def test_indexer_creation(self):
"""Test lazy indexer initialization."""
with tempfile.TemporaryDirectory() as tmpdir:
indexer = LazyIndexer(storage_dir=Path(tmpdir))
assert indexer.storage_dir.exists()
def test_build_and_lookup(self):
"""Test building indexes and looking up."""
with tempfile.TemporaryDirectory() as tmpdir:
# Create a simple graph
graph = nx.DiGraph()
node = GraphNode.from_entity("测试节点", "d1", "e1")
graph.add_node(node.id, **node.to_dict())
indexer = LazyIndexer(storage_dir=Path(tmpdir))
indexer.build_indexes(graph)
# Should find the node by label
results = indexer.lookup_by_label("测试节点")
assert len(results) == 1
def test_save_and_load_index(self):
"""Test saving and loading indexes."""
with tempfile.TemporaryDirectory() as tmpdir:
# Create a graph
graph = nx.DiGraph()
node = GraphNode.from_entity("测试节点", "d1", "e1")
graph.add_node(node.id, **node.to_dict())
# Build and save
indexer1 = LazyIndexer(storage_dir=Path(tmpdir))
indexer1.build_indexes(graph)
indexer1.save_index()
# Load in new indexer
indexer2 = LazyIndexer(storage_dir=Path(tmpdir))
indexer2.load_index()
results = indexer2.lookup_by_label("测试节点")
assert len(results) == 1