test: add generic tests for coverage

src/entity/graph.rs

@@ -412,3 +412,361 @@ impl Traverser {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::entity::direction::Direction;
+
+    fn create_test_graph() -> Graph {
+        let mut graph = Graph::new();
+        let node1 = graph.add_node(Node {
+            position: glam::Vec2::new(0.0, 0.0),
+        });
+        let node2 = graph.add_node(Node {
+            position: glam::Vec2::new(16.0, 0.0),
+        });
+        let node3 = graph.add_node(Node {
+            position: glam::Vec2::new(0.0, 16.0),
+        });
+
+        graph.connect(node1, node2, false, None, Direction::Right).unwrap();
+        graph.connect(node1, node3, false, None, Direction::Down).unwrap();
+
+        graph
+    }
+
+    #[test]
+    fn test_graph_new() {
+        let graph = Graph::new();
+        assert_eq!(graph.node_count(), 0);
+        assert!(graph.adjacency_list.is_empty());
+    }
+
+    #[test]
+    fn test_graph_add_node() {
+        let mut graph = Graph::new();
+        let node = Node {
+            position: glam::Vec2::new(10.0, 20.0),
+        };
+        let id = graph.add_node(node);
+
+        assert_eq!(id, 0);
+        assert_eq!(graph.node_count(), 1);
+        assert_eq!(graph.adjacency_list.len(), 1);
+
+        let retrieved_node = graph.get_node(id).unwrap();
+        assert_eq!(retrieved_node.position, glam::Vec2::new(10.0, 20.0));
+    }
+
+    #[test]
+    fn test_graph_node_count() {
+        let mut graph = Graph::new();
+        assert_eq!(graph.node_count(), 0);
+
+        graph.add_node(Node {
+            position: glam::Vec2::new(0.0, 0.0),
+        });
+        assert_eq!(graph.node_count(), 1);
+
+        graph.add_node(Node {
+            position: glam::Vec2::new(1.0, 1.0),
+        });
+        assert_eq!(graph.node_count(), 2);
+    }
+
+    #[test]
+    fn test_graph_get_node() {
+        let mut graph = Graph::new();
+        let node = Node {
+            position: glam::Vec2::new(5.0, 10.0),
+        };
+        let id = graph.add_node(node);
+
+        let retrieved = graph.get_node(id).unwrap();
+        assert_eq!(retrieved.position, glam::Vec2::new(5.0, 10.0));
+
+        assert!(graph.get_node(999).is_none());
+    }
+
+    #[test]
+    fn test_graph_connect() {
+        let mut graph = Graph::new();
+        let node1 = graph.add_node(Node {
+            position: glam::Vec2::new(0.0, 0.0),
+        });
+        let node2 = graph.add_node(Node {
+            position: glam::Vec2::new(16.0, 0.0),
+        });
+
+        let result = graph.connect(node1, node2, false, None, Direction::Right);
+        assert!(result.is_ok());
+
+        // Check that edges were added in both directions
+        let edge1 = graph.find_edge_in_direction(node1, Direction::Right);
+        let edge2 = graph.find_edge_in_direction(node2, Direction::Left);
+
+        assert!(edge1.is_some());
+        assert!(edge2.is_some());
+        assert_eq!(edge1.unwrap().target, node2);
+        assert_eq!(edge2.unwrap().target, node1);
+    }
+
+    #[test]
+    fn test_graph_connect_invalid_nodes() {
+        let mut graph = Graph::new();
+        let node1 = graph.add_node(Node {
+            position: glam::Vec2::new(0.0, 0.0),
+        });
+
+        // Try to connect to non-existent node
+        let result = graph.connect(node1, 999, false, None, Direction::Right);
+        assert!(result.is_err());
+
+        // Try to connect from non-existent node
+        let result = graph.connect(999, node1, false, None, Direction::Right);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_graph_find_edge() {
+        let mut graph = Graph::new();
+        let node1 = graph.add_node(Node {
+            position: glam::Vec2::new(0.0, 0.0),
+        });
+        let node2 = graph.add_node(Node {
+            position: glam::Vec2::new(16.0, 0.0),
+        });
+
+        graph.connect(node1, node2, false, None, Direction::Right).unwrap();
+
+        let edge = graph.find_edge(node1, node2);
+        assert!(edge.is_some());
+        assert_eq!(edge.unwrap().target, node2);
+
+        // Test non-existent edge
+        assert!(graph.find_edge(node1, 999).is_none());
+    }
+
+    #[test]
+    fn test_graph_find_edge_in_direction() {
+        let mut graph = Graph::new();
+        let node1 = graph.add_node(Node {
+            position: glam::Vec2::new(0.0, 0.0),
+        });
+        let node2 = graph.add_node(Node {
+            position: glam::Vec2::new(16.0, 0.0),
+        });
+
+        graph.connect(node1, node2, false, None, Direction::Right).unwrap();
+
+        let edge = graph.find_edge_in_direction(node1, Direction::Right);
+        assert!(edge.is_some());
+        assert_eq!(edge.unwrap().target, node2);
+
+        // Test non-existent direction
+        assert!(graph.find_edge_in_direction(node1, Direction::Up).is_none());
+    }
+
+    #[test]
+    fn test_intersection_edges() {
+        let mut intersection = Intersection::default();
+        intersection.set(
+            Direction::Up,
+            Edge {
+                target: 1,
+                distance: 10.0,
+                direction: Direction::Up,
+            },
+        );
+        intersection.set(
+            Direction::Right,
+            Edge {
+                target: 2,
+                distance: 15.0,
+                direction: Direction::Right,
+            },
+        );
+
+        let edges: Vec<_> = intersection.edges().collect();
+        assert_eq!(edges.len(), 2);
+
+        let up_edge = edges.iter().find(|e| e.direction == Direction::Up).unwrap();
+        let right_edge = edges.iter().find(|e| e.direction == Direction::Right).unwrap();
+
+        assert_eq!(up_edge.target, 1);
+        assert_eq!(up_edge.distance, 10.0);
+        assert_eq!(right_edge.target, 2);
+        assert_eq!(right_edge.distance, 15.0);
+    }
+
+    #[test]
+    fn test_intersection_get() {
+        let mut intersection = Intersection::default();
+        let edge = Edge {
+            target: 1,
+            distance: 10.0,
+            direction: Direction::Up,
+        };
+        intersection.set(Direction::Up, edge);
+
+        let retrieved = intersection.get(Direction::Up);
+        assert!(retrieved.is_some());
+        assert_eq!(retrieved.unwrap().target, 1);
+
+        assert!(intersection.get(Direction::Down).is_none());
+    }
+
+    #[test]
+    fn test_intersection_set() {
+        let mut intersection = Intersection::default();
+        let edge = Edge {
+            target: 1,
+            distance: 10.0,
+            direction: Direction::Left,
+        };
+
+        intersection.set(Direction::Left, edge);
+        let retrieved = intersection.get(Direction::Left);
+        assert!(retrieved.is_some());
+        assert_eq!(retrieved.unwrap().target, 1);
+    }
+
+    #[test]
+    fn test_position_is_at_node() {
+        let pos = Position::AtNode(5);
+        assert!(pos.is_at_node());
+
+        let pos = Position::BetweenNodes {
+            from: 1,
+            to: 2,
+            traversed: 5.0,
+        };
+        assert!(!pos.is_at_node());
+    }
+
+    #[test]
+    fn test_position_from_node_id() {
+        let pos = Position::AtNode(5);
+        assert_eq!(pos.from_node_id(), 5);
+
+        let pos = Position::BetweenNodes {
+            from: 1,
+            to: 2,
+            traversed: 5.0,
+        };
+        assert_eq!(pos.from_node_id(), 1);
+    }
+
+    #[test]
+    fn test_position_to_node_id() {
+        let pos = Position::AtNode(5);
+        assert_eq!(pos.to_node_id(), None);
+
+        let pos = Position::BetweenNodes {
+            from: 1,
+            to: 2,
+            traversed: 5.0,
+        };
+        assert_eq!(pos.to_node_id(), Some(2));
+    }
+
+    #[test]
+    fn test_position_is_stopped() {
+        let pos = Position::AtNode(5);
+        assert!(pos.is_stopped());
+
+        let pos = Position::BetweenNodes {
+            from: 1,
+            to: 2,
+            traversed: 5.0,
+        };
+        assert!(!pos.is_stopped());
+    }
+
+    #[test]
+    fn test_traverser_new() {
+        let graph = create_test_graph();
+        let traverser = Traverser::new(&graph, 0, Direction::Left);
+
+        assert_eq!(traverser.direction, Direction::Left);
+        // The next_direction might be consumed immediately when the traverser starts moving
+        // So we just check that the direction is set correctly
+        assert_eq!(traverser.direction, Direction::Left);
+    }
+
+    #[test]
+    fn test_traverser_set_next_direction() {
+        let graph = create_test_graph();
+        let mut traverser = Traverser::new(&graph, 0, Direction::Left);
+
+        traverser.set_next_direction(Direction::Up);
+        assert!(traverser.next_direction.is_some());
+        assert_eq!(traverser.next_direction.unwrap().0, Direction::Up);
+
+        // Setting same direction should not change anything
+        traverser.set_next_direction(Direction::Up);
+        assert_eq!(traverser.next_direction.unwrap().0, Direction::Up);
+    }
+
+    #[test]
+    fn test_traverser_advance_at_node() {
+        let graph = create_test_graph();
+        let mut traverser = Traverser::new(&graph, 0, Direction::Right);
+
+        // Should start moving in the initial direction
+        traverser.advance(&graph, 5.0);
+
+        match traverser.position {
+            Position::BetweenNodes { from, to, traversed } => {
+                assert_eq!(from, 0);
+                assert_eq!(to, 1);
+                assert_eq!(traversed, 5.0);
+            }
+            _ => panic!("Expected to be between nodes"),
+        }
+    }
+
+    #[test]
+    fn test_traverser_advance_between_nodes() {
+        let graph = create_test_graph();
+        let mut traverser = Traverser::new(&graph, 0, Direction::Right);
+
+        // Move to between nodes
+        traverser.advance(&graph, 5.0);
+
+        // Advance further
+        traverser.advance(&graph, 3.0);
+
+        match traverser.position {
+            Position::BetweenNodes { from, to, traversed } => {
+                assert_eq!(from, 0);
+                assert_eq!(to, 1);
+                assert_eq!(traversed, 8.0);
+            }
+            _ => panic!("Expected to be between nodes"),
+        }
+    }
+
+    #[test]
+    fn test_edge_structure() {
+        let edge = Edge {
+            target: 5,
+            distance: 10.5,
+            direction: Direction::Up,
+        };
+
+        assert_eq!(edge.target, 5);
+        assert_eq!(edge.distance, 10.5);
+        assert_eq!(edge.direction, Direction::Up);
+    }
+
+    #[test]
+    fn test_node_structure() {
+        let node = Node {
+            position: glam::Vec2::new(10.0, 20.0),
+        };
+
+        assert_eq!(node.position, glam::Vec2::new(10.0, 20.0));
+    }
+}