this repo has no description
1use gigabrain::Graph;
2use gigabrain::visualization::{GraphVisualizer, VisualizationOptions, VisualizationFormat, LayoutAlgorithm};
3use std::sync::Arc;
4
5#[tokio::test]
6async fn test_ascii_visualization() {
7 let graph = Arc::new(Graph::new());
8
9 // Create some test data
10 let alice = graph.create_node();
11 let bob = graph.create_node();
12
13 // Add labels and properties
14 {
15 let mut schema = graph.schema().write();
16 let person_label = schema.get_or_create_label("Person");
17 let name_prop = schema.get_or_create_property_key("name");
18 let knows_rel = schema.get_or_create_relationship_type("KNOWS");
19 drop(schema);
20
21 // Add properties and labels to nodes
22 graph.update_node(alice, |node| {
23 node.add_label(person_label);
24 node.properties.insert(name_prop, gigabrain::core::PropertyValue::String("Alice".to_string()));
25 }).unwrap();
26
27 graph.update_node(bob, |node| {
28 node.add_label(person_label);
29 node.properties.insert(name_prop, gigabrain::core::PropertyValue::String("Bob".to_string()));
30 }).unwrap();
31
32 // Create relationship
33 let _rel = graph.create_relationship(alice, bob, knows_rel).unwrap();
34 }
35
36 // Test ASCII visualization
37 let options = VisualizationOptions {
38 format: VisualizationFormat::Ascii,
39 max_nodes: Some(10),
40 max_relationships: Some(10),
41 include_properties: true,
42 include_labels: true,
43 layout: LayoutAlgorithm::Hierarchical,
44 color_scheme: gigabrain::visualization::ColorScheme::Default,
45 node_size: gigabrain::visualization::NodeSize::Medium,
46 font_size: gigabrain::visualization::FontSize::Medium,
47 };
48
49 let visualizer = GraphVisualizer::with_options(graph.clone(), options);
50 let result = visualizer.visualize().await;
51
52 assert!(result.is_ok());
53 let output = result.unwrap();
54 assert!(output.contains("Graph Visualization"));
55 assert!(output.contains("Alice"));
56 assert!(output.contains("Bob"));
57 assert!(output.contains("KNOWS"));
58}
59
60#[tokio::test]
61async fn test_json_visualization() {
62 let graph = Arc::new(Graph::new());
63
64 // Create test data
65 let node1 = graph.create_node();
66 let node2 = graph.create_node();
67
68 {
69 let mut schema = graph.schema().write();
70 let test_rel = schema.get_or_create_relationship_type("TEST");
71 drop(schema);
72
73 let _rel = graph.create_relationship(node1, node2, test_rel).unwrap();
74 }
75
76 // Test JSON visualization
77 let options = VisualizationOptions {
78 format: VisualizationFormat::Json,
79 max_nodes: Some(5),
80 max_relationships: Some(5),
81 include_properties: false,
82 include_labels: false,
83 layout: LayoutAlgorithm::Spring,
84 color_scheme: gigabrain::visualization::ColorScheme::Default,
85 node_size: gigabrain::visualization::NodeSize::Medium,
86 font_size: gigabrain::visualization::FontSize::Medium,
87 };
88
89 let visualizer = GraphVisualizer::with_options(graph.clone(), options);
90 let result = visualizer.visualize().await;
91
92 assert!(result.is_ok());
93 let output = result.unwrap();
94
95 // Parse as JSON to verify it's valid
96 let json: serde_json::Value = serde_json::from_str(&output).unwrap();
97 assert!(json["nodes"].is_array());
98 assert!(json["edges"].is_array());
99 assert!(json["metadata"].is_object());
100
101 let nodes = json["nodes"].as_array().unwrap();
102 let edges = json["edges"].as_array().unwrap();
103
104 assert_eq!(nodes.len(), 2);
105 assert_eq!(edges.len(), 1);
106}
107
108#[tokio::test]
109async fn test_dot_visualization() {
110 let graph = Arc::new(Graph::new());
111
112 // Create simple test data
113 let node1 = graph.create_node();
114 let node2 = graph.create_node();
115
116 {
117 let mut schema = graph.schema().write();
118 let connects_rel = schema.get_or_create_relationship_type("CONNECTS");
119 drop(schema);
120
121 let _rel = graph.create_relationship(node1, node2, connects_rel).unwrap();
122 }
123
124 // Test DOT visualization
125 let options = VisualizationOptions {
126 format: VisualizationFormat::Dot,
127 max_nodes: Some(5),
128 max_relationships: Some(5),
129 include_properties: true,
130 include_labels: true,
131 layout: LayoutAlgorithm::Spring,
132 color_scheme: gigabrain::visualization::ColorScheme::Light,
133 node_size: gigabrain::visualization::NodeSize::Large,
134 font_size: gigabrain::visualization::FontSize::Large,
135 };
136
137 let visualizer = GraphVisualizer::with_options(graph.clone(), options);
138 let result = visualizer.visualize().await;
139
140 assert!(result.is_ok());
141 let output = result.unwrap();
142
143 // Check DOT format basics
144 assert!(output.starts_with("digraph G"));
145 assert!(output.contains("layout=fdp"));
146 assert!(output.contains("CONNECTS"));
147 assert!(output.ends_with("}\n"));
148}
149
150#[tokio::test]
151async fn test_svg_visualization() {
152 let graph = Arc::new(Graph::new());
153
154 // Create test data
155 let _node1 = graph.create_node();
156
157 // Test SVG visualization
158 let options = VisualizationOptions {
159 format: VisualizationFormat::Svg,
160 max_nodes: Some(1),
161 max_relationships: Some(0),
162 include_properties: false,
163 include_labels: false,
164 layout: LayoutAlgorithm::Circular,
165 color_scheme: gigabrain::visualization::ColorScheme::Colorful,
166 node_size: gigabrain::visualization::NodeSize::Small,
167 font_size: gigabrain::visualization::FontSize::Small,
168 };
169
170 let visualizer = GraphVisualizer::with_options(graph.clone(), options);
171 let result = visualizer.visualize().await;
172
173 assert!(result.is_ok());
174 let output = result.unwrap();
175
176 // Check SVG format basics
177 assert!(output.starts_with("<svg"));
178 assert!(output.contains("xmlns=\"http://www.w3.org/2000/svg\""));
179 assert!(output.contains("Graph Visualization"));
180 assert!(output.ends_with("</svg>\n"));
181}
182
183#[tokio::test]
184async fn test_empty_graph_visualization() {
185 let graph = Arc::new(Graph::new());
186
187 let options = VisualizationOptions::default();
188 let visualizer = GraphVisualizer::with_options(graph.clone(), options);
189 let result = visualizer.visualize().await;
190
191 assert!(result.is_ok());
192 let output = result.unwrap();
193 assert!(output.contains("Empty graph"));
194}
195
196#[test]
197fn test_visualization_stats() {
198 let graph = Arc::new(Graph::new());
199
200 // Create test data
201 let node1 = graph.create_node();
202 let node2 = graph.create_node();
203
204 {
205 let mut schema = graph.schema().write();
206 let test_rel = schema.get_or_create_relationship_type("TEST");
207 drop(schema);
208
209 let _rel = graph.create_relationship(node1, node2, test_rel).unwrap();
210 }
211
212 let visualizer = GraphVisualizer::new(graph);
213 let stats = visualizer.get_stats();
214
215 assert_eq!(stats.node_count, 2);
216 assert_eq!(stats.edge_count, 1);
217 assert!(stats.avg_degree > 0.0);
218 assert!(stats.max_degree > 0);
219}