18 - Unit Testing

libs/code-actions/src/code_actions_provider.rs

@@ -74,3 +74,23 @@ impl CodeActionsProvider {
         refactors
     }
 }
+
+#[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/completions/auto_complete_provider.rs

@@ -104,3 +104,26 @@ impl AutoCompleteProvider {
         vec![]
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::test_utils::{create_test_ast_file, create_test_ast_file_struct_definition};
+
+    use super::*;
+
+    #[test]
+    fn test_get_suggestions() {
+        let provider = AutoCompleteProvider::new();
+        let uri = "test.sol";
+        let position = Position {
+            line: 10,
+            column: 15,
+        };
+        let files = vec![
+            create_test_ast_file(),
+            create_test_ast_file_struct_definition(),
+        ];
+        let completes = provider.get_suggestions(uri, position, &files);
+        assert_eq!(completes.len(), 4);
+    }
+}

libs/code-actions/src/lib.rs

@@ -2,6 +2,7 @@ mod code_actions_provider;
 mod completions;
 mod error;
 mod references;
+mod test_utils;
 mod types;
 mod utils;
 

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

@@ -77,3 +77,199 @@ impl DefinitionVisitor {
         self.node.clone()
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::test_utils::{
+        create_test_ast_file_contract_definition, create_test_ast_file_enum_definition,
+        create_test_ast_file_enum_value, create_test_ast_file_event_definition,
+        create_test_ast_file_function_definition, create_test_ast_file_modifier_definition,
+        create_test_ast_file_struct_definition, create_test_ast_file_variable_declaration,
+    };
+
+    use super::*;
+
+    #[test]
+    fn test_find_contract_definition() {
+        let id = 1;
+        let file = create_test_ast_file_contract_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::ContractDefinition(contract)) = node {
+            assert_eq!(contract.id, id);
+        } else {
+            panic!("Expected ContractDefinition node");
+        }
+    }
+
+    #[test]
+    fn test_find_contract_definition_not_found() {
+        let id = 0;
+        let file = create_test_ast_file_contract_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_none());
+    }
+
+    #[test]
+    fn test_find_function_definition() {
+        let id = 2;
+        let file = create_test_ast_file_function_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::FunctionDefinition(function)) = node {
+            assert_eq!(function.id, id);
+        } else {
+            panic!("Expected FunctionDefinition node");
+        }
+    }
+
+    #[test]
+    fn test_find_function_definition_not_found() {
+        let id = 0;
+        let file = create_test_ast_file_function_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_none());
+    }
+
+    #[test]
+    fn test_find_modifier_definition() {
+        let id = 4;
+        let file = create_test_ast_file_modifier_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::ModifierDefinition(modifier)) = node {
+            assert_eq!(modifier.id, id);
+        } else {
+            panic!("Expected ModifierDefinition node");
+        }
+    }
+
+    #[test]
+    fn test_find_modifier_definition_not_found() {
+        let id = 0;
+        let file = create_test_ast_file_modifier_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_none());
+    }
+
+    #[test]
+    fn test_find_struct_definition() {
+        let id = 5;
+        let file = create_test_ast_file_struct_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::StructDefinition(struct_def)) = node {
+            assert_eq!(struct_def.id, id);
+        } else {
+            panic!("Expected StructDefinition node");
+        }
+    }
+
+    #[test]
+    fn test_find_struct_definition_not_found() {
+        let id = 0;
+        let file = create_test_ast_file_struct_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_none());
+    }
+
+    #[test]
+    fn test_find_enum_definition() {
+        let id = 6;
+        let file = create_test_ast_file_enum_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::EnumDefinition(enum_def)) = node {
+            assert_eq!(enum_def.id, id);
+        } else {
+            panic!("Expected EnumDefinition node");
+        }
+    }
+
+    #[test]
+    fn test_find_enum_definition_not_found() {
+        let id = 0;
+        let file = create_test_ast_file_enum_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_none());
+    }
+
+    #[test]
+    fn test_find_variable_declaration() {
+        let id = 3;
+        let file = create_test_ast_file_variable_declaration();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::VariableDeclaration(variable)) = node {
+            assert_eq!(variable.id, id);
+        } else {
+            panic!("Expected VariableDeclaration node");
+        }
+    }
+
+    #[test]
+    fn test_find_variable_declaration_not_found() {
+        let id = 0;
+        let file = create_test_ast_file_variable_declaration();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_none());
+    }
+
+    #[test]
+    fn test_find_enum_value() {
+        let id = 8;
+        let file = create_test_ast_file_enum_value();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::EnumValue(enum_def)) = node {
+            assert_eq!(enum_def.id, id);
+        } else {
+            panic!("Expected EnumDefinition node");
+        }
+    }
+
+    #[test]
+    fn test_find_enum_value_not_found() {
+        let id = 0;
+        let file = create_test_ast_file_enum_value();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_none());
+    }
+
+    #[test]
+    fn test_find_event_definition() {
+        let id = 7;
+        let file = create_test_ast_file_event_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_some());
+        if let Some(InteractableNode::EventDefinition(event)) = node {
+            assert_eq!(event.id, id);
+        } else {
+            panic!("Expected EventDefinition node");
+        }
+    }
+
+    #[test]
+    fn test_find_event_definition_not_found() {
+        let id = 0;
+        let file = create_test_ast_file_event_definition();
+        let mut visitor = DefinitionVisitor::new(id);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_none());
+    }
+}