Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

test(helpers): add comprehensive teists for dependency collection

[email protected]efcb370a554e
diff --git a/libs/python/computer/tests/test_helpers.py b/libs/python/computer/tests/test_helpers.py
new file mode 100644
index 0000000000..1af455efea
--- /dev/null
+++ b/libs/python/computer/tests/test_helpers.py
@@ -0,0 +1,478 @@
+from computer.helpers import generate_source_code
+
+
+class TestSimpleCases:
+ """Test simple dependency cases"""
+
+ def test_simple_function_no_dependencies(self):
+ """Test simple function with no dependencies"""
+
+ def simple_func():
+ return 42
+
+ code = generate_source_code(simple_func)
+
+ assert "def simple_func():" in code
+ assert "return 42" in code
+
+ def test_function_with_parameters(self):
+ """Test function with parameters"""
+
+ def add(a, b):
+ return a + b
+
+ code = generate_source_code(add)
+
+ assert "def add(a, b):" in code
+ assert "return a + b" in code
+
+ def test_function_with_docstring(self):
+ """Test function with docstring"""
+
+ def documented():
+ """This is a docstring"""
+ return True
+
+ code = generate_source_code(documented)
+
+ assert "def documented():" in code
+ assert "This is a docstring" in code
+
+
+class TestImports:
+ """Test import handling"""
+
+ def test_stdlib_import_inside_function(self):
+ """Test function with stdlib import inside"""
+
+ def with_stdlib():
+ import math
+
+ return math.sqrt(16)
+
+ code = generate_source_code(with_stdlib)
+
+ assert "import math" in code
+ assert "def with_stdlib():" in code
+ assert "math.sqrt(16)" in code
+
+ def test_multiple_stdlib_imports(self):
+ """Test function with multiple stdlib imports"""
+
+ def with_multiple():
+ import json
+ import math
+
+ return json.dumps({"value": math.pi})
+
+ code = generate_source_code(with_multiple)
+
+ assert "import json" in code
+ assert "import math" in code
+
+ def test_from_import_stdlib(self):
+ """Test from X import Y style"""
+
+ def with_from_import():
+ from math import pi, sqrt
+
+ return sqrt(16) + pi
+
+ code = generate_source_code(with_from_import)
+
+ assert "from math import" in code
+ assert "sqrt, pi" in code or ("sqrt" in code and "pi" in code)
+
+ def test_third_party_global_import(self):
+ """Test globally imported third-party module"""
+ from requests import get
+
+ def with_requests():
+ return get
+
+ code = generate_source_code(with_requests)
+
+ assert "from requests import get" in code
+ assert "def with_requests():" in code
+
+
+class TestHelperFunctions:
+ """Test helper function dependencies"""
+
+ def test_single_helper_function(self):
+ """Test function with one helper"""
+
+ def helper(x):
+ return x * 2
+
+ def main():
+ return helper(21)
+
+ code = generate_source_code(main)
+
+ assert "def helper(x):" in code
+ assert "return x * 2" in code
+ assert "def main():" in code
+ assert "return helper(21)" in code
+
+ def test_nested_helper_functions(self):
+ """Test function with nested helpers"""
+
+ def helper_a(x):
+ return x + 1
+
+ def helper_b(x):
+ return helper_a(x) * 2
+
+ def main():
+ return helper_b(10)
+
+ code = generate_source_code(main)
+
+ assert "def helper_a(x):" in code
+ assert "def helper_b(x):" in code
+ assert "def main():" in code
+
+ def test_helper_dependency_ordering(self):
+ """Test that helpers are ordered correctly (dependencies first)"""
+
+ def level_3(x):
+ return x + 1
+
+ def level_2(x):
+ return level_3(x) * 2
+
+ def level_1(x):
+ return level_2(x) + 5
+
+ code = generate_source_code(level_1)
+
+ # Check ordering
+ pos_3 = code.find("def level_3")
+ pos_2 = code.find("def level_2")
+ pos_1 = code.find("def level_1")
+
+ assert pos_3 < pos_2 < pos_1, "Functions not in correct dependency order"
+
+ def test_helper_with_import(self):
+ """Test helper function that uses imports"""
+ import math
+
+ def helper(x):
+ return math.sqrt(x)
+
+ def main():
+ return helper(16)
+
+ code = generate_source_code(main)
+
+ assert "import math" in code
+ assert "def helper(x):" in code
+ assert "def main():" in code
+
+
+class TestGlobalConstants:
+ """Test global constant handling"""
+
+ def test_simple_constant(self):
+ """Test function using simple constant"""
+ MY_CONSTANT = 42
+
+ def with_constant():
+ return MY_CONSTANT * 2
+
+ code = generate_source_code(with_constant)
+
+ assert "MY_CONSTANT = 42" in code
+ assert "def with_constant():" in code
+
+ def test_string_constant(self):
+ """Test function using string constant"""
+ API_URL = "https://api.example.com"
+
+ def with_string():
+ return API_URL
+
+ code = generate_source_code(with_string)
+
+ assert "API_URL" in code
+ assert "https://api.example.com" in code
+
+ def test_multiple_constants(self):
+ """Test function using multiple constants"""
+ BASE_URL = "https://example.com"
+ TIMEOUT = 30
+
+ def with_multiple():
+ return f"{BASE_URL}?timeout={TIMEOUT}"
+
+ code = generate_source_code(with_multiple)
+
+ assert "BASE_URL" in code
+ assert "TIMEOUT" in code
+
+
+class TestClassDefinitions:
+ """Test class definition handling"""
+
+ def test_simple_class(self):
+ """Test function using simple class"""
+
+ class Calculator:
+ def __init__(self, value):
+ self.value = value
+
+ def add(self, x):
+ return self.value + x
+
+ def with_class():
+ calc = Calculator(10)
+ return calc.add(5)
+
+ code = generate_source_code(with_class)
+
+ assert "class Calculator:" in code
+ assert "__init__" in code
+ assert "def add" in code
+ assert "def with_class():" in code
+
+ def test_class_with_methods(self):
+ """Test class with multiple methods"""
+
+ class Math:
+ def add(self, a, b):
+ return a + b
+
+ def multiply(self, a, b):
+ return a * b
+
+ def use_math():
+ m = Math()
+ return m.add(2, 3) + m.multiply(4, 5)
+
+ code = generate_source_code(use_math)
+
+ assert "class Math:" in code
+ assert "def add" in code
+ assert "def multiply" in code
+
+
+class TestDecoratorRemoval:
+ """Test decorator removal"""
+
+ def test_simple_decorator_removed(self):
+ """Test that decorators are removed"""
+
+ def my_decorator(f):
+ def wrapper(*args, **kwargs):
+ return f(*args, **kwargs)
+
+ return wrapper
+
+ @my_decorator
+ def decorated():
+ return 42
+
+ code = generate_source_code(decorated)
+
+ assert "@my_decorator" not in code
+ assert "def decorated():" in code
+ assert "return 42" in code
+
+ def test_multiple_decorators_removed(self):
+ """Test that multiple decorators are removed"""
+
+ def decorator1(f):
+ return f
+
+ def decorator2(f):
+ return f
+
+ @decorator1
+ @decorator2
+ def multi_decorated():
+ return True
+
+ code = generate_source_code(multi_decorated)
+
+ assert "@decorator1" not in code
+ assert "@decorator2" not in code
+ assert "def multi_decorated():" in code
+
+
+class TestComplexScenarios:
+ """Test complex real-world scenarios"""
+
+ def test_api_client_pattern(self):
+ """Test typical API client pattern"""
+ import json
+
+ BASE_URL = "https://api.example.com"
+
+ def make_request(endpoint):
+ return f"{BASE_URL}/{endpoint}"
+
+ def parse_response(response):
+ return json.loads(response)
+
+ def get_user(user_id):
+ url = make_request(f"users/{user_id}")
+ response = f'{{"id": {user_id}}}'
+ return parse_response(response)
+
+ code = generate_source_code(get_user)
+
+ assert "import json" in code
+ assert "BASE_URL" in code
+ assert "def make_request" in code
+ assert "def parse_response" in code
+ assert "def get_user" in code
+
+ def test_data_processing_pipeline(self):
+ """Test data processing pipeline"""
+
+ def validate_data(data):
+ return [x for x in data if x > 0]
+
+ def transform_data(data):
+ return [x * 2 for x in data]
+
+ def process_pipeline(raw_data):
+ valid = validate_data(raw_data)
+ return transform_data(valid)
+
+ code = generate_source_code(process_pipeline)
+
+ assert "def validate_data" in code
+ assert "def transform_data" in code
+ assert "def process_pipeline" in code
+
+ # Check ordering
+ validate_pos = code.find("def validate_data")
+ transform_pos = code.find("def transform_data")
+ pipeline_pos = code.find("def process_pipeline")
+
+ assert validate_pos < pipeline_pos
+ assert transform_pos < pipeline_pos
+
+
+class TestEdgeCases:
+ """Test edge cases"""
+
+ def test_function_with_default_args(self):
+ """Test function with default arguments"""
+
+ def with_defaults(a, b=10, c=20):
+ return a + b + c
+
+ code = generate_source_code(with_defaults)
+
+ assert "def with_defaults(a, b=10, c=20):" in code
+
+ def test_function_with_kwargs(self):
+ """Test function with *args and **kwargs"""
+
+ def with_varargs(*args, **kwargs):
+ return sum(args)
+
+ code = generate_source_code(with_varargs)
+
+ assert "def with_varargs(*args, **kwargs):" in code
+
+ def test_async_function(self):
+ """Test async function"""
+
+ async def async_func():
+ return 42
+
+ code = generate_source_code(async_func)
+
+ assert "async def async_func():" in code
+ assert "return 42" in code
+
+ def test_lambda_works_in_files(self):
+ """Test that lambda functions work when defined in files"""
+ lambda_func = lambda x: x * 2
+
+ # Lambda functions defined in files CAN have their source extracted
+ code = generate_source_code(lambda_func)
+
+ # Should include the lambda
+ assert "lambda" in code.lower() or "lambda_func" in code
+
+
+class TestCaching:
+ """Test caching mechanism"""
+
+ def test_cache_returns_same_result(self):
+ """Test that cache returns identical results"""
+
+ def cached_func():
+ return 42
+
+ code1 = generate_source_code(cached_func)
+ code2 = generate_source_code(cached_func)
+
+ assert code1 == code2
+
+ def test_different_functions_different_cache(self):
+ """Test that different functions have different cache entries"""
+
+ def func1():
+ return 1
+
+ def func2():
+ return 2
+
+ code1 = generate_source_code(func1)
+ code2 = generate_source_code(func2)
+
+ assert code1 != code2
+ assert "return 1" in code1
+ assert "return 2" in code2
+
+
+class TestBuiltinHandling:
+ """Test that builtins are handled correctly"""
+
+ def test_builtin_not_included(self):
+ """Test that builtin functions are not included as dependencies"""
+
+ def uses_builtins():
+ data = list(range(10))
+ return len(data)
+
+ code = generate_source_code(uses_builtins)
+
+ # Should not include definitions for list, range, len
+ assert "def list" not in code
+ assert "def range" not in code
+ assert "def len" not in code
+ assert "def uses_builtins():" in code
+
+
+class TestImportStylePreservation:
+ """Test that import styles are preserved"""
+
+ def test_from_import_preserved(self):
+ """Test from X import Y is preserved"""
+ from math import sqrt
+
+ def use_sqrt():
+ return sqrt(16)
+
+ code = generate_source_code(use_sqrt)
+
+ assert "from math import sqrt" in code
+
+ def test_import_as_preserved(self):
+ """Test import X as Y is preserved"""
+ import json as j
+
+ def use_json():
+ return j.dumps({"key": "value"})
+
+ code = generate_source_code(use_json)
+
+ # The import style should be preserved
+ assert "import json" in code