flow_rs_core/groups/
tests.rs

1//! Tests for group system
2
3// use crate::graph::{Graph, Node}; // Unused imports
4// use crate::types::{GroupId, NodeId, Position}; // Unused imports
5// use std::collections::HashSet; // Unused imports
6
7// use super::manager::GroupManager; // Unused imports
8
9#[cfg(test)]
10mod tests {
11    use super::*;
12    use crate::types::{GroupId, NodeId, Position};
13    use crate::graph::{Graph, Node};
14    use crate::groups::manager::GroupManager;
15    use std::collections::HashSet;
16
17    fn create_test_nodes() -> Vec<NodeId> {
18        vec![
19            NodeId::new("node1"),
20            NodeId::new("node2"),
21            NodeId::new("node3"),
22        ]
23    }
24
25    #[test]
26    fn test_create_group_from_nodes() {
27        let mut manager = GroupManager::new();
28        let nodes = create_test_nodes();
29        let members: HashSet<NodeId> = nodes.into_iter().take(2).collect();
30        let group_id = GroupId::new("test_group");
31
32        let result = manager.create_group(group_id.clone(), members.clone());
33
34        assert!(result.is_ok());
35
36        let group = manager.get_group(&group_id).unwrap();
37        assert_eq!(group.members.len(), 2);
38        assert!(group.contains_node(&NodeId::new("node1")));
39        assert!(group.contains_node(&NodeId::new("node2")));
40    }
41
42    #[test]
43    fn test_empty_group_creation_fails() {
44        let mut manager = GroupManager::new();
45        let empty_members = HashSet::new();
46        let group_id = GroupId::new("empty_group");
47
48        let result = manager.create_group(group_id, empty_members);
49
50        assert!(result.is_err());
51        assert!(matches!(result, Err(crate::error::FlowError::InvalidOperation { .. })));
52    }
53
54    #[test]
55    fn test_node_already_in_group_fails() {
56        let mut manager = GroupManager::new();
57        let nodes = create_test_nodes();
58        let members1: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
59        let members2: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
60
61        let group_id1 = GroupId::new("group1");
62        let group_id2 = GroupId::new("group2");
63
64        manager.create_group(group_id1, members1).unwrap();
65
66        let result = manager.create_group(group_id2, members2);
67        assert!(result.is_err());
68    }
69
70    #[test]
71    fn test_duplicate_group_creation_fails() {
72        let mut manager = GroupManager::new();
73        let nodes = create_test_nodes();
74        let members: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
75        let group_id = GroupId::new("duplicate_group");
76
77        manager.create_group(group_id.clone(), members.clone()).unwrap();
78
79        let result = manager.create_group(group_id, members);
80        assert!(result.is_err());
81    }
82
83    #[test]
84    fn test_get_group() {
85        let mut manager = GroupManager::new();
86        let nodes = create_test_nodes();
87        let members: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
88        let group_id = GroupId::new("test_group");
89
90        manager.create_group(group_id.clone(), members).unwrap();
91
92        let group = manager.get_group(&group_id);
93        assert!(group.is_some());
94        assert_eq!(group.unwrap().id, group_id);
95    }
96
97    #[test]
98    fn test_get_nonexistent_group() {
99        let manager = GroupManager::new();
100        let group_id = GroupId::new("nonexistent");
101
102        let group = manager.get_group(&group_id);
103        assert!(group.is_none());
104    }
105
106    #[test]
107    fn test_get_node_group() {
108        let mut manager = GroupManager::new();
109        let nodes = create_test_nodes();
110        let members: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
111        let group_id = GroupId::new("test_group");
112
113        manager.create_group(group_id.clone(), members).unwrap();
114
115        let node_group = manager.get_node_group(&nodes[0]);
116        assert!(node_group.is_some());
117        assert_eq!(node_group.unwrap(), &group_id);
118    }
119
120    #[test]
121    fn test_get_ungrouped_node() {
122        let manager = GroupManager::new();
123        let node_id = NodeId::new("ungrouped");
124
125        let node_group = manager.get_node_group(&node_id);
126        assert!(node_group.is_none());
127    }
128
129    #[test]
130    fn test_dissolve_group() {
131        let mut manager = GroupManager::new();
132        let nodes = create_test_nodes();
133        let members: HashSet<NodeId> = nodes.iter().take(2).cloned().collect();
134        let group_id = GroupId::new("test_group");
135
136        manager.create_group(group_id.clone(), members.clone()).unwrap();
137        assert_eq!(manager.group_count(), 1);
138
139        let dissolved_members = manager.dissolve_group(&group_id).unwrap();
140        assert_eq!(dissolved_members, members);
141        assert_eq!(manager.group_count(), 0);
142
143        // Verify nodes are no longer mapped
144        for node_id in &members {
145            assert!(manager.get_node_group(node_id).is_none());
146        }
147    }
148
149    #[test]
150    fn test_dissolve_nonexistent_group() {
151        let mut manager = GroupManager::new();
152        let group_id = GroupId::new("nonexistent");
153
154        let result = manager.dissolve_group(&group_id);
155        assert!(result.is_err());
156    }
157
158    #[test]
159    fn test_add_node_to_group() {
160        let mut manager = GroupManager::new();
161        let nodes = create_test_nodes();
162        let initial_members: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
163        let group_id = GroupId::new("test_group");
164
165        manager.create_group(group_id.clone(), initial_members).unwrap();
166
167        let result = manager.add_node_to_group(&group_id, nodes[1].clone());
168        assert!(result.is_ok());
169
170        let group = manager.get_group(&group_id).unwrap();
171        assert_eq!(group.member_count(), 2);
172        assert!(group.contains_node(&nodes[1]));
173        assert!(manager.get_node_group(&nodes[1]).is_some());
174    }
175
176    #[test]
177    fn test_add_node_to_nonexistent_group() {
178        let mut manager = GroupManager::new();
179        let node_id = NodeId::new("test_node");
180        let group_id = GroupId::new("nonexistent");
181
182        let result = manager.add_node_to_group(&group_id, node_id);
183        assert!(result.is_err());
184    }
185
186    #[test]
187    fn test_add_node_already_in_group() {
188        let mut manager = GroupManager::new();
189        let nodes = create_test_nodes();
190        let members: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
191        let group_id = GroupId::new("test_group");
192
193        manager.create_group(group_id.clone(), members).unwrap();
194
195        let result = manager.add_node_to_group(&group_id, nodes[0].clone());
196        assert!(result.is_err());
197    }
198
199    #[test]
200    fn test_remove_node_from_group() {
201        let mut manager = GroupManager::new();
202        let nodes = create_test_nodes();
203        let members: HashSet<NodeId> = nodes.iter().take(2).cloned().collect();
204        let group_id = GroupId::new("test_group");
205
206        manager.create_group(group_id.clone(), members.clone()).unwrap();
207
208        let result = manager.remove_node_from_group(&group_id, &nodes[0]);
209        assert!(result.is_ok());
210
211        let group = manager.get_group(&group_id).unwrap();
212        assert_eq!(group.member_count(), 1);
213        assert!(!group.contains_node(&nodes[0]));
214        assert!(manager.get_node_group(&nodes[0]).is_none());
215    }
216
217    #[test]
218    fn test_remove_node_from_nonexistent_group() {
219        let mut manager = GroupManager::new();
220        let node_id = NodeId::new("test_node");
221        let group_id = GroupId::new("nonexistent");
222
223        let result = manager.remove_node_from_group(&group_id, &node_id);
224        assert!(result.is_err());
225    }
226
227    #[test]
228    fn test_remove_node_not_in_group() {
229        let mut manager = GroupManager::new();
230        let nodes = create_test_nodes();
231        let members: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
232        let group_id = GroupId::new("test_group");
233
234        manager.create_group(group_id.clone(), members).unwrap();
235
236        let result = manager.remove_node_from_group(&group_id, &nodes[1]);
237        assert!(result.is_err());
238    }
239
240    #[test]
241    fn test_remove_last_node_dissolves_group() {
242        let mut manager = GroupManager::new();
243        let node_id = NodeId::new("test_node");
244        let members: HashSet<NodeId> = [node_id.clone()].into_iter().collect();
245        let group_id = GroupId::new("test_group");
246
247        manager.create_group(group_id.clone(), members).unwrap();
248        assert_eq!(manager.group_count(), 1);
249
250        let result = manager.remove_node_from_group(&group_id, &node_id);
251        assert!(result.is_ok());
252        assert_eq!(manager.group_count(), 0);
253        assert!(manager.get_group(&group_id).is_none());
254    }
255
256    #[test]
257    fn test_set_group_name() {
258        let mut manager = GroupManager::new();
259        let nodes = create_test_nodes();
260        let members: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
261        let group_id = GroupId::new("test_group");
262
263        manager.create_group(group_id.clone(), members).unwrap();
264
265        let result = manager.set_group_name(&group_id, Some("New Name".to_string()));
266        assert!(result.is_ok());
267
268        let group = manager.get_group(&group_id).unwrap();
269        assert_eq!(group.name, Some("New Name".to_string()));
270    }
271
272    #[test]
273    fn test_set_group_name_nonexistent() {
274        let mut manager = GroupManager::new();
275        let group_id = GroupId::new("nonexistent");
276
277        let result = manager.set_group_name(&group_id, Some("Name".to_string()));
278        assert!(result.is_err());
279    }
280
281    #[test]
282    fn test_calculate_group_bounds() {
283        let mut manager = GroupManager::new();
284        let mut graph = Graph::<(), ()>::new();
285
286        // Create nodes at specific positions
287        let mut node1 = Node::simple("node1", Position::new(100.0, 100.0));
288        let mut node2 = Node::simple("node2", Position::new(200.0, 150.0));
289        node1.set_size(crate::types::Size::new(50.0, 30.0));
290        node2.set_size(crate::types::Size::new(50.0, 30.0));
291        graph.add_node(node1).unwrap();
292        graph.add_node(node2).unwrap();
293
294        let members: HashSet<NodeId> = ["node1", "node2"].iter().map(|&s| NodeId::new(s)).collect();
295        let group_id = GroupId::new("test_group");
296        manager.create_group(group_id.clone(), members).unwrap();
297
298        let result = manager.calculate_group_bounds(&group_id, &graph);
299        assert!(result.is_ok());
300
301        let group = manager.get_group(&group_id).unwrap();
302        assert_eq!(group.position, Position::new(100.0, 100.0));
303        assert_eq!(group.size.width, 150.0); // 250 - 100 (200 + 50 - 100)
304        assert_eq!(group.size.height, 80.0); // 180 - 100 (150 + 30 - 100)
305    }
306
307    #[test]
308    fn test_calculate_group_bounds_nonexistent() {
309        let mut manager = GroupManager::new();
310        let graph = Graph::<(), ()>::new();
311        let group_id = GroupId::new("nonexistent");
312
313        let result = manager.calculate_group_bounds(&group_id, &graph);
314        assert!(result.is_err());
315    }
316
317    #[test]
318    fn test_group_bounds_empty_group() {
319        let mut manager = GroupManager::new();
320        let graph = Graph::<(), ()>::new();
321        let group_id = GroupId::new("empty_group");
322
323        // Create empty group (this should fail, but let's test bounds calculation)
324        let empty_members = HashSet::new();
325        let result = manager.create_group(group_id.clone(), empty_members);
326        assert!(result.is_err()); // Empty groups should not be created
327    }
328
329    #[test]
330    fn test_group_ids() {
331        let mut manager = GroupManager::new();
332        let nodes = create_test_nodes();
333
334        let group_id1 = GroupId::new("group1");
335        let group_id2 = GroupId::new("group2");
336        let members1: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
337        let members2: HashSet<NodeId> = [nodes[1].clone()].into_iter().collect();
338
339        manager.create_group(group_id1.clone(), members1).unwrap();
340        manager.create_group(group_id2.clone(), members2).unwrap();
341
342        let group_ids = manager.group_ids();
343        assert_eq!(group_ids.len(), 2);
344        assert!(group_ids.contains(&group_id1));
345        assert!(group_ids.contains(&group_id2));
346    }
347
348    #[test]
349    fn test_has_group() {
350        let mut manager = GroupManager::new();
351        let nodes = create_test_nodes();
352        let members: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
353        let group_id = GroupId::new("test_group");
354
355        assert!(!manager.has_group(&group_id));
356
357        manager.create_group(group_id.clone(), members).unwrap();
358
359        assert!(manager.has_group(&group_id));
360    }
361
362    #[test]
363    fn test_group_count() {
364        let mut manager = GroupManager::new();
365        let nodes = create_test_nodes();
366
367        assert_eq!(manager.group_count(), 0);
368
369        let group_id1 = GroupId::new("group1");
370        let group_id2 = GroupId::new("group2");
371        let members1: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
372        let members2: HashSet<NodeId> = [nodes[1].clone()].into_iter().collect();
373
374        manager.create_group(group_id1, members1).unwrap();
375        assert_eq!(manager.group_count(), 1);
376
377        manager.create_group(group_id2, members2).unwrap();
378        assert_eq!(manager.group_count(), 2);
379    }
380
381    #[test]
382    fn test_is_node_grouped() {
383        let mut manager = GroupManager::new();
384        let nodes = create_test_nodes();
385        let members: HashSet<NodeId> = [nodes[0].clone()].into_iter().collect();
386        let group_id = GroupId::new("test_group");
387
388        assert!(!manager.is_node_grouped(&nodes[0]));
389
390        manager.create_group(group_id, members).unwrap();
391
392        assert!(manager.is_node_grouped(&nodes[0]));
393        assert!(!manager.is_node_grouped(&nodes[1]));
394    }
395
396    // Group Drag Tests
397
398    #[test]
399    fn test_start_group_drag() {
400        let mut manager = GroupManager::new();
401        let mut graph = Graph::<(), ()>::new();
402
403        let node1 = Node::simple("node1", Position::new(100.0, 100.0));
404        graph.add_node(node1).unwrap();
405
406        let members: HashSet<NodeId> = [NodeId::new("node1")].into_iter().collect();
407        let group_id = GroupId::new("test_group");
408        manager.create_group(group_id.clone(), members).unwrap();
409
410        let result = manager.start_group_drag(&group_id, Position::zero(), &graph);
411        assert!(result.is_ok());
412        assert!(manager.is_group_dragging());
413        assert_eq!(manager.get_dragging_group(), Some(&group_id));
414    }
415
416    #[test]
417    fn test_start_group_drag_nonexistent() {
418        let mut manager = GroupManager::new();
419        let graph = Graph::<(), ()>::new();
420        let group_id = GroupId::new("nonexistent");
421
422        let result = manager.start_group_drag(&group_id, Position::zero(), &graph);
423        assert!(result.is_err());
424    }
425
426    #[test]
427    fn test_start_group_drag_already_dragging() {
428        let mut manager = GroupManager::new();
429        let mut graph = Graph::<(), ()>::new();
430
431        let node1 = Node::simple("node1", Position::new(100.0, 100.0));
432        graph.add_node(node1).unwrap();
433
434        let members: HashSet<NodeId> = [NodeId::new("node1")].into_iter().collect();
435        let group_id = GroupId::new("test_group");
436        manager.create_group(group_id.clone(), members).unwrap();
437
438        manager.start_group_drag(&group_id, Position::zero(), &graph).unwrap();
439
440        let result = manager.start_group_drag(&group_id, Position::zero(), &graph);
441        assert!(result.is_err());
442    }
443
444    #[test]
445    fn test_update_group_drag() {
446        let mut manager = GroupManager::new();
447        let mut graph = Graph::<(), ()>::new();
448
449        let node1 = Node::simple("node1", Position::new(100.0, 100.0));
450        let node2 = Node::simple("node2", Position::new(200.0, 150.0));
451        graph.add_node(node1).unwrap();
452        graph.add_node(node2).unwrap();
453
454        let members: HashSet<NodeId> = ["node1", "node2"].iter().map(|&s| NodeId::new(s)).collect();
455        let group_id = GroupId::new("test_group");
456        manager.create_group(group_id.clone(), members).unwrap();
457
458        manager
459            .start_group_drag(&group_id, Position::new(125.0, 110.0), &graph)
460            .unwrap();
461
462        let new_pos = Position::new(175.0, 135.0);
463        let result = manager.update_group_drag(new_pos, &mut graph);
464
465        assert!(result.is_ok());
466        let delta = result.unwrap();
467        assert_eq!(delta, Position::new(50.0, 25.0));
468        assert_eq!(
469            manager.get_drag_delta(),
470            Some(Position::new(50.0, 25.0))
471        );
472
473        // Check nodes moved
474        let node1_after = graph.get_node(&NodeId::new("node1")).unwrap();
475        let node2_after = graph.get_node(&NodeId::new("node2")).unwrap();
476        assert_eq!(node1_after.position, Position::new(150.0, 125.0));
477        assert_eq!(node2_after.position, Position::new(250.0, 175.0));
478    }
479
480    #[test]
481    fn test_complete_group_drag() {
482        let mut manager = GroupManager::new();
483        let mut graph = Graph::<(), ()>::new();
484
485        let node1 = Node::simple("node1", Position::new(100.0, 100.0));
486        graph.add_node(node1).unwrap();
487
488        let members: HashSet<NodeId> = [NodeId::new("node1")].into_iter().collect();
489        let group_id = GroupId::new("test_group");
490        manager.create_group(group_id.clone(), members).unwrap();
491        manager
492            .start_group_drag(&group_id, Position::zero(), &graph)
493            .unwrap();
494
495        let result = manager.complete_group_drag();
496
497        assert!(result.is_ok());
498        assert_eq!(result.unwrap(), group_id);
499        assert!(!manager.is_group_dragging());
500        assert_eq!(manager.get_dragging_group(), None);
501    }
502
503    #[test]
504    fn test_cancel_group_drag() {
505        let mut manager = GroupManager::new();
506        let mut graph = Graph::<(), ()>::new();
507
508        let node1 = Node::simple("node1", Position::new(100.0, 100.0));
509        let node2 = Node::simple("node2", Position::new(200.0, 150.0));
510        graph.add_node(node1).unwrap();
511        graph.add_node(node2).unwrap();
512
513        let members: HashSet<NodeId> = ["node1", "node2"].iter().map(|&s| NodeId::new(s)).collect();
514        let group_id = GroupId::new("test_group");
515        manager.create_group(group_id.clone(), members).unwrap();
516
517        manager
518            .start_group_drag(&group_id, Position::zero(), &graph)
519            .unwrap();
520        manager
521            .update_group_drag(Position::new(50.0, 25.0), &mut graph)
522            .unwrap();
523
524        // Verify nodes moved
525        assert_eq!(
526            graph.get_node(&NodeId::new("node1")).unwrap().position,
527            Position::new(150.0, 125.0)
528        );
529
530        // Cancel drag
531        let result = manager.cancel_group_drag(&mut graph);
532
533        assert!(result.is_ok());
534        assert_eq!(result.unwrap(), group_id);
535        assert!(!manager.is_group_dragging());
536
537        // Verify nodes restored to original positions
538        assert_eq!(
539            graph.get_node(&NodeId::new("node1")).unwrap().position,
540            Position::new(100.0, 100.0)
541        );
542        assert_eq!(
543            graph.get_node(&NodeId::new("node2")).unwrap().position,
544            Position::new(200.0, 150.0)
545        );
546    }
547
548    #[test]
549    fn test_drag_operations_without_active_drag() {
550        let mut graph = Graph::<(), ()>::new();
551        let mut manager = GroupManager::new();
552
553        // Try to update drag without starting
554        let result = manager.update_group_drag(Position::zero(), &mut graph);
555        assert!(result.is_err());
556        assert!(matches!(result, Err(crate::error::FlowError::InvalidOperation { .. })));
557
558        // Try to complete drag without starting
559        let result = manager.complete_group_drag();
560        assert!(result.is_err());
561
562        // Try to cancel drag without starting
563        let result = manager.cancel_group_drag(&mut graph);
564        assert!(result.is_err());
565    }
566}
flow_rs_core/groups/tests.rs

flow_rs_core/groups/
tests.rs
