Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
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.pynew file mode 100644index 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