test: correct errors in tests

Author: AlbertoCentonze

natrix/ast_node.py

@@ -186,20 +186,19 @@ def memory_accesses(self) -> List[MemoryAccess]:
         if self.ast_type != "FunctionDef":
             raise ValueError("Not a function")
 
-        # Get all nodes that might have variable_reads or variable_writes
-        all_nodes = self.get_descendants()
-        if not all_nodes:
+        attrs = self.get_descendants("Attribute")
+        if not attrs:
             return []
 
         accesses: List[MemoryAccess] = []
 
-        for node in all_nodes:
+        for attr in attrs:
             for access_type in ("variable_reads", "variable_writes"):
-                if access_type in node.node_dict:
-                    for item in node.get(access_type):
+                if access_type in attr.node_dict:
+                    for item in attr.get(access_type):
                         accesses.append(
                             MemoryAccess(
-                                node=node,
+                                node=attr,
                                 type="read"
                                 if access_type == "variable_reads"
                                 else "write",

natrix/rules/unused_arg.py

@@ -28,7 +28,7 @@ def visit_FunctionDef(self, node: FunctionDefNode):
         # Skip interface function definitions
         if node.is_from_interface:
             return
-            
+
         # Collect declared arguments in a dictionary, {arg_name: arg_node}
         declared_args = {}
         for arg_info in node.get("args.args"):

tests/conftest.py

@@ -66,3 +66,8 @@ def twocrypto_contract():
 @pytest.fixture()
 def for_loop_underscore_contract():
     return output_loader("for_loop_underscore")
+
+
+@pytest.fixture()
+def test_unused_arg_contract():
+    return output_loader("test_unused_arg")

tests/contracts/test_unused_arg.vy

@@ -0,0 +1,13 @@
+# pragma version 0.4.0
+
+def function_with_unused_arg(_used_arg: uint256, _unused_arg: address) -> uint256:
+    return _used_arg * 2
+
+def function_with_all_used_args(_arg1: uint256, _arg2: address) -> uint256:
+    if _arg2 == empty(address):
+        return _arg1
+    return _arg1 + 1
+
+# Interface function - arguments should not be flagged
+interface ITest:
+    def some_interface_function(_interface_arg: uint256) -> bool: view

tests/rules/test_print_left.py

@@ -6,8 +6,8 @@ def test_print_left(uncached_contract):
 
     issues = rule.run(uncached_contract)
     assert len(issues) == 2
-    assert issues[0].position == "12:8"
-    assert issues[1].position == "15:8"
+    assert issues[0].position == "17:8"
+    assert issues[1].position == "20:8"
     assert (
         issues[0].message
         == "Found a 'print' statement; consider removing it in production code."

tests/rules/test_storage_caching.py

@@ -6,7 +6,7 @@ def test_storage_caching(uncached_contract):
 
     issues = rule.run(uncached_contract)
     assert len(issues) == 1
-    assert issues[0].position == "28:7"
+    assert issues[0].position == "33:7"
     assert (
         issues[0].message
         == "Storage variable 'a' is accessed multiple times; consider caching it to save gas."

tests/rules/test_unused_arg.py

@@ -1,46 +1,39 @@
 from natrix.rules.unused_arg import UnusedArgRule
-from natrix.ast_tools import parse_file
 
 
-def test_unused_arg():
+def test_unused_arg(test_unused_arg_contract):
     """
     Test that the UnusedArgRule correctly identifies unused function arguments.
-    
+
     This test verifies that:
     1. Unused arguments in regular functions are flagged
     2. Interface function definitions are not flagged
     """
-    # Parse the test file with unused arguments
-    ast = parse_file("tests/test_unused_arg.vy")
-    
     rule = UnusedArgRule()
-    issues = rule.run(ast)
-    
+    issues = rule.run(test_unused_arg_contract)
+
     # Check that only the unused argument is flagged
     assert len(issues) == 1
-    assert issues[0].position == "2:49"  # Line for _unused_arg
+    assert issues[0].position == "3:49"  # Line for _unused_arg
     assert "_unused_arg" in issues[0].message
     assert "function_with_unused_arg" in issues[0].message
-    
+
     # Verify that used arguments are not flagged
     for issue in issues:
         assert "_used_arg" not in issue.message
         assert "_arg1" not in issue.message
         assert "_arg2" not in issue.message
 
 
-def test_interface_functions_not_flagged():
+def test_interface_functions_not_flagged(twocrypto_contract):
     """
     Test that the UnusedArgRule does not flag interface function arguments.
-    
+
     Uses the Twocrypto.vy contract which has interface function definitions.
     """
-    # Load the Twocrypto contract directly
-    twocrypto_contract = parse_file("tests/contracts/Twocrypto.vy")
-    
     rule = UnusedArgRule()
     issues = rule.run(twocrypto_contract)
-    
+
     # Check that no interface function arguments are flagged
     for issue in issues:
         # Make sure none of the interface function arguments are flagged

tests/rules/test_unused_variable.py

@@ -32,8 +32,8 @@ def test_unused_variable(uncached_contract):
     ), "No issue found for 'another_unused_var'"
 
     # Check the positions - these should be the declaration positions, not the reassignment positions
-    assert hey_unused_var_issue.position == "6:4"
-    assert another_unused_var_issue.position == "7:4"
+    assert hey_unused_var_issue.position == "11:4"
+    assert another_unused_var_issue.position == "12:4"
 
     # Check the messages
     assert (
@@ -92,10 +92,12 @@ def test_for_loop_underscore(for_loop_underscore_contract):
     sorted_issues = sorted(issues, key=lambda x: int(x.position.split(":")[0]))
 
     # Check exact line numbers and messages to prevent regressions
-    assert sorted_issues[0].position == "23:4"  # Line for another_unused_var
-    assert sorted_issues[1].position == "24:4"  # Line for hey_unused_var
-    assert "another_unused_var" in sorted_issues[0].message
-    assert "hey_unused_var" in sorted_issues[1].message
+    assert sorted_issues[0].position == "6:8"  # Line for i in for loop
+    assert sorted_issues[1].position == "15:8"  # Line for x variable
+    assert sorted_issues[2].position == "18:4"  # Line for unused_var
+    assert "i" in sorted_issues[0].message
+    assert "x" in sorted_issues[1].message
+    assert "unused_var" in sorted_issues[2].message
 
     # Verify that 'owner' is not in the issues
     for issue in issues:

tests/test_unused_arg.vy

@@ -0,0 +1,3 @@
+# Test contract for unused argument rule
+def example_function(used_arg: uint256, _unused_arg: uint256) -> uint256:
+    return used_arg