387 lines
11 KiB
Rust
387 lines
11 KiB
Rust
//! Integration tests for RuVector graph database
|
|
//!
|
|
//! End-to-end tests that verify all components work together correctly.
|
|
|
|
use ruvector_graph::{GraphDB, Node, Edge, Label, RelationType, Properties, PropertyValue};
|
|
|
|
// ============================================================================
|
|
// Full Workflow Integration Tests
|
|
// ============================================================================
|
|
|
|
#[test]
|
|
fn test_complete_graph_workflow() {
|
|
let db = GraphDB::new();
|
|
|
|
// 1. Create nodes
|
|
let mut alice_props = Properties::new();
|
|
alice_props.insert("name".to_string(), PropertyValue::String("Alice".to_string()));
|
|
alice_props.insert("age".to_string(), PropertyValue::Integer(30));
|
|
|
|
let mut bob_props = Properties::new();
|
|
bob_props.insert("name".to_string(), PropertyValue::String("Bob".to_string()));
|
|
bob_props.insert("age".to_string(), PropertyValue::Integer(35));
|
|
|
|
db.create_node(Node::new(
|
|
"alice".to_string(),
|
|
vec![Label { name: "Person".to_string() }],
|
|
alice_props,
|
|
)).unwrap();
|
|
|
|
db.create_node(Node::new(
|
|
"bob".to_string(),
|
|
vec![Label { name: "Person".to_string() }],
|
|
bob_props,
|
|
)).unwrap();
|
|
|
|
// 2. Create relationship
|
|
let mut edge_props = Properties::new();
|
|
edge_props.insert("since".to_string(), PropertyValue::Integer(2020));
|
|
|
|
db.create_edge(Edge::new(
|
|
"knows".to_string(),
|
|
"alice".to_string(),
|
|
"bob".to_string(),
|
|
RelationType { name: "KNOWS".to_string() },
|
|
edge_props,
|
|
)).unwrap();
|
|
|
|
// 3. Verify everything was created
|
|
let alice = db.get_node("alice").unwrap();
|
|
let bob = db.get_node("bob").unwrap();
|
|
let edge = db.get_edge("knows").unwrap();
|
|
|
|
assert_eq!(alice.labels[0].name, "Person");
|
|
assert_eq!(bob.labels[0].name, "Person");
|
|
assert_eq!(edge.rel_type.name, "KNOWS");
|
|
assert_eq!(edge.from_node, "alice");
|
|
assert_eq!(edge.to_node, "bob");
|
|
}
|
|
|
|
#[test]
|
|
fn test_social_network_scenario() {
|
|
let db = GraphDB::new();
|
|
|
|
// Create users
|
|
for i in 0..10 {
|
|
let mut props = Properties::new();
|
|
props.insert("username".to_string(), PropertyValue::String(format!("user{}", i)));
|
|
props.insert("followers".to_string(), PropertyValue::Integer(i * 100));
|
|
|
|
db.create_node(Node::new(
|
|
format!("user{}", i),
|
|
vec![Label { name: "User".to_string() }],
|
|
props,
|
|
)).unwrap();
|
|
}
|
|
|
|
// Create follow relationships
|
|
for i in 0..9 {
|
|
let edge = Edge::new(
|
|
format!("follow_{}", i),
|
|
format!("user{}", i),
|
|
format!("user{}", i + 1),
|
|
RelationType { name: "FOLLOWS".to_string() },
|
|
Properties::new(),
|
|
);
|
|
|
|
db.create_edge(edge).unwrap();
|
|
}
|
|
|
|
// Verify graph structure
|
|
for i in 0..10 {
|
|
assert!(db.get_node(&format!("user{}", i)).is_some());
|
|
}
|
|
|
|
for i in 0..9 {
|
|
assert!(db.get_edge(&format!("follow_{}", i)).is_some());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_movie_database_scenario() {
|
|
let db = GraphDB::new();
|
|
|
|
// Create movies
|
|
let mut inception_props = Properties::new();
|
|
inception_props.insert("title".to_string(), PropertyValue::String("Inception".to_string()));
|
|
inception_props.insert("year".to_string(), PropertyValue::Integer(2010));
|
|
inception_props.insert("rating".to_string(), PropertyValue::Float(8.8));
|
|
|
|
db.create_node(Node::new(
|
|
"inception".to_string(),
|
|
vec![Label { name: "Movie".to_string() }],
|
|
inception_props,
|
|
)).unwrap();
|
|
|
|
// Create actors
|
|
let mut dicaprio_props = Properties::new();
|
|
dicaprio_props.insert("name".to_string(), PropertyValue::String("Leonardo DiCaprio".to_string()));
|
|
|
|
db.create_node(Node::new(
|
|
"dicaprio".to_string(),
|
|
vec![Label { name: "Actor".to_string() }],
|
|
dicaprio_props,
|
|
)).unwrap();
|
|
|
|
// Create ACTED_IN relationship
|
|
let mut role_props = Properties::new();
|
|
role_props.insert("character".to_string(), PropertyValue::String("Cobb".to_string()));
|
|
|
|
db.create_edge(Edge::new(
|
|
"acted1".to_string(),
|
|
"dicaprio".to_string(),
|
|
"inception".to_string(),
|
|
RelationType { name: "ACTED_IN".to_string() },
|
|
role_props,
|
|
)).unwrap();
|
|
|
|
// Verify
|
|
let movie = db.get_node("inception").unwrap();
|
|
let actor = db.get_node("dicaprio").unwrap();
|
|
let role = db.get_edge("acted1").unwrap();
|
|
|
|
assert!(movie.properties.contains_key("title"));
|
|
assert!(actor.properties.contains_key("name"));
|
|
assert_eq!(role.rel_type.name, "ACTED_IN");
|
|
}
|
|
|
|
#[test]
|
|
fn test_knowledge_graph_scenario() {
|
|
let db = GraphDB::new();
|
|
|
|
// Create concepts
|
|
let concepts = vec![
|
|
("ml", "Machine Learning"),
|
|
("ai", "Artificial Intelligence"),
|
|
("dl", "Deep Learning"),
|
|
("nn", "Neural Networks"),
|
|
];
|
|
|
|
for (id, name) in concepts {
|
|
let mut props = Properties::new();
|
|
props.insert("name".to_string(), PropertyValue::String(name.to_string()));
|
|
|
|
db.create_node(Node::new(
|
|
id.to_string(),
|
|
vec![Label { name: "Concept".to_string() }],
|
|
props,
|
|
)).unwrap();
|
|
}
|
|
|
|
// Create relationships
|
|
db.create_edge(Edge::new(
|
|
"e1".to_string(),
|
|
"dl".to_string(),
|
|
"ml".to_string(),
|
|
RelationType { name: "IS_A".to_string() },
|
|
Properties::new(),
|
|
)).unwrap();
|
|
|
|
db.create_edge(Edge::new(
|
|
"e2".to_string(),
|
|
"ml".to_string(),
|
|
"ai".to_string(),
|
|
RelationType { name: "IS_A".to_string() },
|
|
Properties::new(),
|
|
)).unwrap();
|
|
|
|
db.create_edge(Edge::new(
|
|
"e3".to_string(),
|
|
"dl".to_string(),
|
|
"nn".to_string(),
|
|
RelationType { name: "USES".to_string() },
|
|
Properties::new(),
|
|
)).unwrap();
|
|
|
|
// Verify concept hierarchy
|
|
assert!(db.get_node("ai").is_some());
|
|
assert!(db.get_edge("e1").is_some());
|
|
}
|
|
|
|
// ============================================================================
|
|
// Complex Multi-Step Operations
|
|
// ============================================================================
|
|
|
|
#[test]
|
|
fn test_batch_import() {
|
|
let db = GraphDB::new();
|
|
|
|
// Simulate importing a batch of data
|
|
let nodes_to_import = 100;
|
|
|
|
for i in 0..nodes_to_import {
|
|
let mut props = Properties::new();
|
|
props.insert("id".to_string(), PropertyValue::Integer(i));
|
|
props.insert("type".to_string(), PropertyValue::String("imported".to_string()));
|
|
|
|
let node = Node::new(
|
|
format!("import_{}", i),
|
|
vec![Label { name: "Imported".to_string() }],
|
|
props,
|
|
);
|
|
|
|
db.create_node(node).unwrap();
|
|
}
|
|
|
|
// Verify all were imported
|
|
for i in 0..nodes_to_import {
|
|
assert!(db.get_node(&format!("import_{}", i)).is_some());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_graph_transformation() {
|
|
let db = GraphDB::new();
|
|
|
|
// Original graph: Linear chain
|
|
for i in 0..10 {
|
|
db.create_node(Node::new(
|
|
format!("n{}", i),
|
|
vec![],
|
|
Properties::new(),
|
|
)).unwrap();
|
|
}
|
|
|
|
for i in 0..9 {
|
|
db.create_edge(Edge::new(
|
|
format!("e{}", i),
|
|
format!("n{}", i),
|
|
format!("n{}", i + 1),
|
|
RelationType { name: "NEXT".to_string() },
|
|
Properties::new(),
|
|
)).unwrap();
|
|
}
|
|
|
|
// Transform: Add reverse edges
|
|
for i in 0..9 {
|
|
db.create_edge(Edge::new(
|
|
format!("rev_e{}", i),
|
|
format!("n{}", i + 1),
|
|
format!("n{}", i),
|
|
RelationType { name: "PREV".to_string() },
|
|
Properties::new(),
|
|
)).unwrap();
|
|
}
|
|
|
|
// Verify bidirectional graph
|
|
assert!(db.get_edge("e5").is_some());
|
|
assert!(db.get_edge("rev_e5").is_some());
|
|
}
|
|
|
|
// ============================================================================
|
|
// Error Recovery Tests
|
|
// ============================================================================
|
|
|
|
#[test]
|
|
fn test_handle_missing_nodes_gracefully() {
|
|
let db = GraphDB::new();
|
|
|
|
// Try to get non-existent node
|
|
let result = db.get_node("does_not_exist");
|
|
assert!(result.is_none());
|
|
|
|
// Try to get non-existent edge
|
|
let result = db.get_edge("missing_edge");
|
|
assert!(result.is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn test_duplicate_id_handling() {
|
|
let db = GraphDB::new();
|
|
|
|
let node1 = Node::new(
|
|
"duplicate".to_string(),
|
|
vec![],
|
|
Properties::new(),
|
|
);
|
|
|
|
db.create_node(node1).unwrap();
|
|
|
|
// Try to create node with same ID
|
|
let node2 = Node::new(
|
|
"duplicate".to_string(),
|
|
vec![],
|
|
Properties::new(),
|
|
);
|
|
|
|
// This should either update or error, depending on desired semantics
|
|
// For now, just verify it doesn't panic
|
|
let _result = db.create_node(node2);
|
|
}
|
|
|
|
// ============================================================================
|
|
// Data Integrity Tests
|
|
// ============================================================================
|
|
|
|
#[test]
|
|
fn test_edge_referential_integrity() {
|
|
let db = GraphDB::new();
|
|
|
|
// Create nodes
|
|
db.create_node(Node::new("a".to_string(), vec![], Properties::new())).unwrap();
|
|
db.create_node(Node::new("b".to_string(), vec![], Properties::new())).unwrap();
|
|
|
|
// Create valid edge
|
|
let edge = Edge::new(
|
|
"e1".to_string(),
|
|
"a".to_string(),
|
|
"b".to_string(),
|
|
RelationType { name: "LINKS".to_string() },
|
|
Properties::new(),
|
|
);
|
|
|
|
let result = db.create_edge(edge);
|
|
assert!(result.is_ok());
|
|
|
|
// Try to create edge with non-existent source
|
|
// Note: Current implementation doesn't check this, but it should
|
|
let bad_edge = Edge::new(
|
|
"e2".to_string(),
|
|
"nonexistent".to_string(),
|
|
"b".to_string(),
|
|
RelationType { name: "LINKS".to_string() },
|
|
Properties::new(),
|
|
);
|
|
|
|
let _result = db.create_edge(bad_edge);
|
|
// TODO: Should fail with error
|
|
}
|
|
|
|
// ============================================================================
|
|
// Performance Integration Tests
|
|
// ============================================================================
|
|
|
|
#[test]
|
|
fn test_large_graph_operations() {
|
|
let db = GraphDB::new();
|
|
|
|
let num_nodes = 1000;
|
|
let num_edges = 5000;
|
|
|
|
// Create nodes
|
|
for i in 0..num_nodes {
|
|
db.create_node(Node::new(
|
|
format!("large_{}", i),
|
|
vec![],
|
|
Properties::new(),
|
|
)).unwrap();
|
|
}
|
|
|
|
// Create edges
|
|
for i in 0..num_edges {
|
|
let from = i % num_nodes;
|
|
let to = (i + 1) % num_nodes;
|
|
|
|
db.create_edge(Edge::new(
|
|
format!("e_{}", i),
|
|
format!("large_{}", from),
|
|
format!("large_{}", to),
|
|
RelationType { name: "EDGE".to_string() },
|
|
Properties::new(),
|
|
)).unwrap();
|
|
}
|
|
|
|
// Verify graph size
|
|
// TODO: Add methods to get counts
|
|
}
|