ff132e7e00
[SubgraphRetriever] - retrieve_neighborhood(entity_id, hops): N-hop 이웃 추출 - retrieve_context(entity_ids): 다중 엔티티 공통 경로 검색 - retrieve_induced_subgraph(entity_ids): 유도 부분 그래프 생성 - Cypher 최적화로 2-hop 쿼리 < 200ms [PatternMatcher] - find_paths(start, end, max_length): 경로 탐색 (깊이 우선) - find_cycles(min_length): 순환 의존성 감지 - find_strongly_connected_components(): SCC 분석 - find_motifs(type): 삼각형/체인/별 모티프 검출 - analyze_entity_connectivity(entity_id): 연결 메트릭 [테스트] - test_phase5_subgraph_retriever.py (6 테스트 통과) - test_phase5_pattern_matcher.py (10 테스트 통과) - test_phase5_integration_graphrag.py (6 통합 테스트 통과) Phase 5.2 (Graph Analytics) 준비 완료 Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>
357 lines
11 KiB
Python
357 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
"""Phase 5.1 Pattern Matcher tests."""
|
|
|
|
import asyncio
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, str(Path(__file__).parent / "ontology_platform"))
|
|
|
|
from ont_platform.core.graph.pattern_matcher import PatternMatcher, PathResult, CycleResult
|
|
|
|
|
|
class MockAdapter:
|
|
"""Mock Neo4j adapter for testing."""
|
|
|
|
async def execute_cypher(self, cypher: str, params=None):
|
|
"""Mock Cypher execution."""
|
|
params = params or {}
|
|
|
|
# find_paths
|
|
if "shortestPath" in cypher or "RELATES*" in cypher and "start_id" in params:
|
|
return [
|
|
{
|
|
"result": {
|
|
"path": [params.get("start_id"), 2, 3, params.get("end_id")],
|
|
"length": 3,
|
|
"confidence": 0.87,
|
|
}
|
|
},
|
|
{
|
|
"result": {
|
|
"path": [params.get("start_id"), 5, params.get("end_id")],
|
|
"length": 2,
|
|
"confidence": 0.90,
|
|
}
|
|
},
|
|
]
|
|
|
|
# find_cycles
|
|
if "start)-[" in cypher or ("RELATES*" in cypher and "end_id" not in params):
|
|
return [
|
|
{"result": {"cycle": [1, 2, 3, 1], "length": 3}},
|
|
{"result": {"cycle": [4, 5, 6, 4], "length": 3}},
|
|
]
|
|
|
|
# find_motifs - detect by type in params
|
|
motif_type = params.get("motif_type", "")
|
|
if motif_type == "triangle":
|
|
return [
|
|
{
|
|
"result": {
|
|
"motif_type": "triangle",
|
|
"nodes": [1, 2, 3],
|
|
"labels": ["Entity_1", "Entity_2", "Entity_3"],
|
|
}
|
|
},
|
|
{
|
|
"result": {
|
|
"motif_type": "triangle",
|
|
"nodes": [4, 5, 6],
|
|
"labels": ["Entity_4", "Entity_5", "Entity_6"],
|
|
}
|
|
},
|
|
]
|
|
|
|
if motif_type == "chain":
|
|
return [
|
|
{
|
|
"result": {
|
|
"motif_type": "chain",
|
|
"nodes": [1, 2, 3, 4],
|
|
"labels": ["A", "B", "C", "D"],
|
|
"length": 4,
|
|
}
|
|
},
|
|
]
|
|
|
|
if motif_type == "star":
|
|
return [
|
|
{
|
|
"result": {
|
|
"motif_type": "star",
|
|
"hub": 1,
|
|
"spokes": [2, 3, 4],
|
|
"hub_label": "Central",
|
|
"spoke_labels": ["Spoke1", "Spoke2", "Spoke3"],
|
|
}
|
|
},
|
|
]
|
|
|
|
# analyze_entity_connectivity
|
|
if "in_degree" in cypher:
|
|
return [
|
|
{
|
|
"metrics": {
|
|
"entity_id": params.get("entity_id"),
|
|
"entity_label": f"Entity_{params.get('entity_id')}",
|
|
"in_degree": 3,
|
|
"out_degree": 4,
|
|
"total_degree": 7,
|
|
"reachable_entities": 12,
|
|
"reachability_ratio": 0.857,
|
|
}
|
|
}
|
|
]
|
|
|
|
return []
|
|
|
|
|
|
async def test_find_paths():
|
|
"""Test path finding between entities."""
|
|
print("\n[TEST 1] Find Paths")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
paths = await matcher.find_paths(start_entity_id=1, end_entity_id=4, max_length=5)
|
|
|
|
assert len(paths) > 0, "Should find at least one path"
|
|
assert all("path" in p and "length" in p for p in paths), "All paths should have required fields"
|
|
|
|
shortest = min(paths, key=lambda p: p["length"])
|
|
assert shortest["length"] >= 2, "Path length should be >= 2"
|
|
|
|
print(f" [OK] Found {len(paths)} paths from 1 to 4")
|
|
print(f" [OK] Shortest path: {shortest['path']} (length {shortest['length']})")
|
|
print(f" [OK] Average confidence: {sum(p['confidence'] for p in paths) / len(paths):.3f}")
|
|
print(" [PASS]")
|
|
|
|
|
|
async def test_same_entity_path():
|
|
"""Test path from entity to itself."""
|
|
print("\n[TEST 2] Same Entity Path")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
paths = await matcher.find_paths(start_entity_id=1, end_entity_id=1, max_length=5)
|
|
|
|
assert len(paths) == 1, "Should return single path to itself"
|
|
assert paths[0]["path"] == [1], "Path should be entity itself"
|
|
assert paths[0]["length"] == 0, "Length to itself should be 0"
|
|
assert paths[0]["confidence"] == 1.0, "Confidence should be 1.0"
|
|
|
|
print(" [OK] Path to self: [1], length 0, confidence 1.0")
|
|
print(" [PASS]")
|
|
|
|
|
|
async def test_find_cycles():
|
|
"""Test cycle detection."""
|
|
print("\n[TEST 3] Find Cycles")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
cycles = await matcher.find_cycles(min_length=2, max_length=5)
|
|
|
|
assert len(cycles) > 0, "Should find cycles"
|
|
assert all(
|
|
"cycle" in c and "length" in c and c["length"] > 1 for c in cycles
|
|
), "All cycles should have required fields"
|
|
|
|
print(f" [OK] Found {len(cycles)} cycles")
|
|
for i, cycle in enumerate(cycles, 1):
|
|
print(f" Cycle {i}: {cycle['cycle']} (length {cycle['length']})")
|
|
print(" [PASS]")
|
|
|
|
|
|
async def test_find_motifs_triangle():
|
|
"""Test triangle motif detection."""
|
|
print("\n[TEST 4] Find Motifs (Triangle)")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
motifs = await matcher.find_motifs(motif_type="triangle", limit=100)
|
|
|
|
assert len(motifs) > 0, "Should find triangle motifs"
|
|
assert all(m.get("motif_type") == "triangle" for m in motifs), "All should be triangles"
|
|
|
|
print(f" [OK] Found {len(motifs)} triangle motifs")
|
|
for motif in motifs:
|
|
print(f" Triangle: {motif['nodes']}")
|
|
print(" [PASS]")
|
|
|
|
|
|
async def test_find_motifs_chain():
|
|
"""Test chain motif detection."""
|
|
print("\n[TEST 5] Find Motifs (Chain)")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
motifs = await matcher.find_motifs(motif_type="chain", limit=100)
|
|
|
|
assert len(motifs) >= 0, "Should return chain motifs (may be empty)"
|
|
if motifs:
|
|
assert all(m.get("motif_type") == "chain" for m in motifs), "All should be chains"
|
|
print(f" [OK] Found {len(motifs)} chain motifs")
|
|
|
|
print(" [PASS]")
|
|
|
|
|
|
async def test_find_motifs_star():
|
|
"""Test star motif detection."""
|
|
print("\n[TEST 6] Find Motifs (Star)")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
motifs = await matcher.find_motifs(motif_type="star", limit=100)
|
|
|
|
assert len(motifs) >= 0, "Should return star motifs (may be empty)"
|
|
if motifs:
|
|
assert all(m.get("motif_type") == "star" for m in motifs), "All should be stars"
|
|
assert all("hub" in m for m in motifs), "Stars should have hub"
|
|
assert all("spokes" in m for m in motifs), "Stars should have spokes"
|
|
print(f" [OK] Found {len(motifs)} star motifs")
|
|
for motif in motifs:
|
|
print(f" Hub: {motif['hub']}, Spokes: {motif['spokes']}")
|
|
|
|
print(" [PASS]")
|
|
|
|
|
|
async def test_find_motifs_invalid():
|
|
"""Test invalid motif type."""
|
|
print("\n[TEST 7] Invalid Motif Type")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
result = await matcher.find_motifs(motif_type="invalid", limit=100)
|
|
|
|
assert isinstance(result, dict) and "error" in result, "Should return error for invalid motif"
|
|
print(f" [OK] Correctly rejects invalid motif: {result['error']}")
|
|
print(" [PASS]")
|
|
|
|
|
|
async def test_analyze_entity_connectivity():
|
|
"""Test entity connectivity analysis."""
|
|
print("\n[TEST 8] Entity Connectivity Analysis")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
metrics = await matcher.analyze_entity_connectivity(entity_id=1)
|
|
|
|
assert "in_degree" in metrics, "Should have in_degree"
|
|
assert "out_degree" in metrics, "Should have out_degree"
|
|
assert "total_degree" in metrics, "Should have total_degree"
|
|
assert "reachable_entities" in metrics, "Should have reachable_entities"
|
|
|
|
assert metrics["total_degree"] == metrics["in_degree"] + metrics["out_degree"]
|
|
print(f" [OK] Entity 1 metrics:")
|
|
print(f" In-degree: {metrics['in_degree']}")
|
|
print(f" Out-degree: {metrics['out_degree']}")
|
|
print(f" Total degree: {metrics['total_degree']}")
|
|
print(f" Reachable entities: {metrics['reachable_entities']}")
|
|
print(f" Reachability ratio: {metrics['reachability_ratio']:.3f}")
|
|
print(" [PASS]")
|
|
|
|
|
|
async def test_path_validation():
|
|
"""Test path length validation."""
|
|
print("\n[TEST 9] Path Length Validation")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
try:
|
|
await matcher.find_paths(start_entity_id=1, end_entity_id=2, max_length=0)
|
|
assert False, "Should reject max_length < 2"
|
|
except ValueError as e:
|
|
assert "max_length must be between 2 and 6" in str(e)
|
|
print(" [OK] Correctly rejects max_length < 2")
|
|
|
|
try:
|
|
await matcher.find_paths(start_entity_id=1, end_entity_id=2, max_length=7)
|
|
assert False, "Should reject max_length > 6"
|
|
except ValueError as e:
|
|
assert "max_length must be between 2 and 6" in str(e)
|
|
print(" [OK] Correctly rejects max_length > 6")
|
|
|
|
print(" [PASS]")
|
|
|
|
|
|
async def test_cycle_validation():
|
|
"""Test cycle detection validation."""
|
|
print("\n[TEST 10] Cycle Detection Validation")
|
|
|
|
adapter = MockAdapter()
|
|
matcher = PatternMatcher(adapter)
|
|
|
|
try:
|
|
await matcher.find_cycles(min_length=1)
|
|
assert False, "Should reject min_length < 2"
|
|
except ValueError as e:
|
|
assert "min_length must be >= 2" in str(e)
|
|
print(" [OK] Correctly rejects min_length < 2")
|
|
|
|
try:
|
|
await matcher.find_cycles(min_length=5, max_length=3)
|
|
assert False, "Should reject max_length < min_length"
|
|
except ValueError as e:
|
|
assert "max_length must be between min_length and 6" in str(e)
|
|
print(" [OK] Correctly rejects max_length < min_length")
|
|
|
|
print(" [PASS]")
|
|
|
|
|
|
async def main():
|
|
"""Run all tests."""
|
|
print("=" * 70)
|
|
print("Phase 5.1 Pattern Matcher Tests")
|
|
print("=" * 70)
|
|
|
|
try:
|
|
await test_find_paths()
|
|
await test_same_entity_path()
|
|
await test_find_cycles()
|
|
await test_find_motifs_triangle()
|
|
await test_find_motifs_chain()
|
|
await test_find_motifs_star()
|
|
await test_find_motifs_invalid()
|
|
await test_analyze_entity_connectivity()
|
|
await test_path_validation()
|
|
await test_cycle_validation()
|
|
|
|
print("\n" + "=" * 70)
|
|
print("All tests passed!")
|
|
print("=" * 70)
|
|
print("\nPhase 5.1 Pattern Matcher capabilities:")
|
|
print(" [OK] Path finding between entities")
|
|
print(" [OK] Cycle detection")
|
|
print(" [OK] Motif detection (triangle, chain, star)")
|
|
print(" [OK] Entity connectivity analysis")
|
|
print(" [OK] Input validation")
|
|
|
|
return True
|
|
except AssertionError as e:
|
|
print(f"\nTest failed: {e}")
|
|
import traceback
|
|
|
|
traceback.print_exc()
|
|
return False
|
|
except Exception as e:
|
|
print(f"\nUnexpected error: {e}")
|
|
import traceback
|
|
|
|
traceback.print_exc()
|
|
return False
|
|
|
|
|
|
if __name__ == "__main__":
|
|
success = asyncio.run(main())
|
|
sys.exit(0 if success else 1)
|