tests(libs/code-actions): added some tests for utils, types and references

Author: 0xSwapFeeder

libs/code-actions/src/code_actions_provider.rs

@@ -62,3 +62,24 @@ impl CodeActionsProvider {
         provider.get_suggestions(uri, position, &files)
     }
 }
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+   fn test_set_base_path() {
+        let provider = CodeActionsProvider::new();
+        provider.set_base_path("test".to_string());
+        assert_eq!(*provider.base_path.read().unwrap(), "test");
+    }
+
+    #[test]
+    fn test_update_file_content() {
+        let provider = CodeActionsProvider::new();
+        provider.set_base_path("tests".to_string());
+        let result = provider.update_file_content();
+        assert!(!result.is_ok());
+    }
+}

libs/code-actions/src/lib.rs

@@ -4,6 +4,7 @@ mod error;
 mod references;
 mod types;
 mod utils;
+mod test_utils;
 
 pub use code_actions_provider::CodeActionsProvider;
 pub use types::{Location, Position};

libs/code-actions/src/references/position_node_visitor.rs

@@ -58,7 +58,7 @@ impl<'ast> Visit<'ast> for PositionNodeVisitor {
     }
 
     fn visit_enum_definition(&mut self, enum_def: &'ast EnumDefinition) {
-        if is_node_in_range(&enum_def.src, &self.position, &self.source) {
+        if log_is_node_in_range(&enum_def.src, &self.position, &self.source) {
             self.above_node = self.node.clone();
             self.node = Some(InteractableNode::EnumDefinition(enum_def.clone()));
         }
@@ -184,3 +184,147 @@ impl PositionNodeVisitor {
         self.node.clone()
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::test_utils::create_test_ast_file;
+
+    #[test]
+    fn test_find_function_declaration() {
+        let file = create_test_ast_file();
+        let position = Position {
+            line: 8,
+            column: 22,
+        };
+        let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::FunctionDefinition(function)) = node {
+            assert_eq!(function.name, "notUsed");
+        } else {
+            panic!("Expected FunctionDefinition, got {:?}", node);
+        }
+    }
+    
+    #[test]
+    fn test_find_contract_definition() {
+        let file = create_test_ast_file();
+        let position = Position {
+            line: 3,
+            column: 14,
+        };
+        let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::ContractDefinition(contract)) = node {
+            assert_eq!(contract.name, "Test");
+        } else {
+            panic!("Expected ContractDefinition, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_variable_declaration() {
+        let file = create_test_ast_file();
+        let position = Position {
+            line: 4,
+            column: 22,
+        };
+        let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::VariableDeclaration(variable)) = node {
+            assert_eq!(variable.name, "number");
+        } else {
+            panic!("Expected VariableDeclaration, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_modifier_definition() {
+        let file = create_test_ast_file();
+        let position = Position {
+            line: 1,
+            column: 1,
+        };
+        let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::ModifierDefinition(modifier)) = node {
+            assert_eq!(modifier.name, "modifier");
+        } else {
+            panic!("Expected ModifierDefinition, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_enum_definition() {
+        let file = create_test_ast_file();
+        let position = Position {
+            line: 1,
+            column: 1,
+        };
+        let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::EnumDefinition(enum_def)) = node {
+            assert_eq!(enum_def.name, "TestEnum");
+        } else {
+            panic!("Expected EnumDefinition, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_enum_value() {
+        let file = create_test_ast_file();
+        let position = Position {
+            line: 1,
+            column: 1,
+        };
+        let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::EnumValue(enum_value)) = node {
+            assert_eq!(enum_value.name, "TestEnumValue");
+        } else {
+            panic!("Expected EnumValue, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_event_definition() {
+        let file = create_test_ast_file();
+        let position = Position {
+            line: 1,
+            column: 1,
+        };
+        let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::EventDefinition(event)) = node {
+            assert_eq!(event.name, "TestEvent");
+        } else {
+            panic!("Expected EventDefinition, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_error_definition() {
+        let file = create_test_ast_file();
+        let position = Position {
+            line: 1,
+            column: 1,
+        };
+        let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::ErrorDefinition(error)) = node {
+            assert_eq!(error.name, "TestError");
+        } else {
+            panic!("Expected ErrorDefinition, got {:?}", node);
+        }
+    }
+
+    
+}

libs/code-actions/src/references/usage_visitor.rs

@@ -103,3 +103,25 @@ impl UsageVisitor {
         self.to_find.clone()
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::types::InteractableNode;
+    use crate::test_utils::create_test_ast_file;
+
+    #[test]
+    fn test_find_usages() {
+        let file = create_test_ast_file();
+        let id = 3;
+        let mut visitor = UsageVisitor::new(id);
+        let usages = visitor.find(&file.ast);
+        assert_eq!(usages.len(), 1);
+        if let InteractableNode::Identifier(identifier) = &usages[0] {
+            assert_eq!(identifier.referenced_declaration, Some(id));
+            assert_eq!(identifier.name, "number");
+        } else {
+            panic!("Expected IdentifierPath, got: {:?}", usages[0]);
+        }
+    }
+}