wip(tests): added position to node tests and test utils

Author: 0xSwapFeeder

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

@@ -265,6 +265,7 @@ mod test {
             line: 1,
             column: 1,
         };
+        //eprintln!("{:?}", file.ast);
         let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
         let node = visitor.find(&file.ast);
         assert!(node.is_some());
@@ -326,5 +327,187 @@ mod test {
         }
     }
 
-    
+    #[test]
+    fn test_find_struct_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::StructDefinition(struct_def)) = node {
+            assert_eq!(struct_def.name, "TestStruct");
+        } else {
+            panic!("Expected StructDefinition, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_user_defined_type_name() {
+        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::UserDefinedTypeName(udt)) = node {
+            assert_eq!(udt.name, Some("TestStruct".to_string()));
+        } else {
+            panic!("Expected UserDefinedTypeName, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_using_for_directive() {
+        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::UsingForDirective(_)) = node {
+            assert_eq!(true, true);
+        } else {
+            panic!("Expected UsingForDirective, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_import_directive() {
+        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::ImportDirective(id)) = node {
+            assert_eq!(true, true);
+        } else {
+            panic!("Expected ImportDirective, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_function_call() {
+        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::FunctionCall(_)) = node {
+            assert_eq!(true, true);
+        } else {
+            panic!("Expected FunctionCall, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_modifier_invocation() {
+        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::ModifierInvocation(_)) = node {
+            assert_eq!(true, true);
+        } else {
+            panic!("Expected ModifierInvocation, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_inheritance_specifier() {
+        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::InheritanceSpecifier(_)) = node {
+            assert_eq!(true, true);
+        } else {
+            panic!("Expected InheritanceSpecifier, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_identifier() {
+        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::Identifier(_)) = node {
+            assert_eq!(true, true);
+        } else {
+            panic!("Expected Identifier, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_member_access() {
+        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::MemberAccess(_)) = node {
+            assert_eq!(true, true);
+        } else {
+            panic!("Expected MemberAccess, got {:?}", node);
+        }
+    }
+
+    #[test]
+    fn test_find_new_expression() {
+        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::NewExpression(_, _)) = node {
+            assert_eq!(true, true);
+        } else {
+            panic!("Expected NewExpression, got {:?}", node);
+        }
+    }
+
+
+    #[test]
+    fn test_find_nothing() {
+        let file = create_test_ast_file();
+        let position = Position {
+            line: 100,
+            column: 100,
+        };
+        let mut visitor = PositionNodeVisitor::new(position, &file.file.content);
+        let node = visitor.find(&file.ast);
+        assert!(node.is_none());
+    }
+
 }

libs/code-actions/src/test_utils.rs

@@ -468,11 +468,87 @@ pub fn create_test_ast_file() -> SolidityAstFile {
             uint256 x = 1;
             number;
         }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        
     }";
     let path = "test.sol";
 
     let mut function = create_test_function_definition();
     function.modifiers.push(create_test_modifier_invocation().into());
+    function.body = Some(Block {
+        documentation: None,
+        id: 30,
+        node_type: BlockNodeType::Block,
+        src: SourceLocation::from_str("1:1:1").unwrap(),
+        statements: Some([
+            Statement::ExpressionStatement(ExpressionStatement {
+                expression: create_test_function_call().into(),
+                id: 100,
+                node_type: ExpressionStatementNodeType::ExpressionStatement,
+                src: SourceLocation::from_str("1:1:1").unwrap(),
+                documentation: None,
+            }),
+            Statement::ExpressionStatement(ExpressionStatement {
+                expression: create_test_member_access().into(),
+                id: 102,
+                node_type: ExpressionStatementNodeType::ExpressionStatement,
+                src: SourceLocation::from_str("1:1:1").unwrap(),
+                documentation: None,
+            }),
+            Statement::ExpressionStatement(ExpressionStatement {
+                expression: create_test_new_expression().into(),
+                id: 103,
+                node_type: ExpressionStatementNodeType::ExpressionStatement,
+                src: SourceLocation::from_str("1:1:1").unwrap(),
+                documentation: None,
+            }),
+        ].iter().cloned().collect()),
+    });
     let mut contract = create_test_contract_definition();
     contract.nodes.push(function.into());
     contract.nodes.push(create_test_variable_declaration().into());
@@ -481,6 +557,7 @@ pub fn create_test_ast_file() -> SolidityAstFile {
     contract.nodes.push(create_test_event_definition().into());
     contract.nodes.push(create_test_using_for_directive().into());
     contract.nodes.push(create_test_error_definition().into());
+    
     contract.base_contracts.push(create_test_inheritance_specifier().into());
     SolidityAstFile {
         file: osmium_libs_solidity_ast_extractor::types::SolidityFile {