d28fe8eedc* feat: improve is_vertex_runnable method in RunnableVerticesManager This commit improves the `is_vertex_runnable` method in the `RunnableVerticesManager` class. It adds an additional parameter `activated_vertices` to the method signature and updates the logic to check if a vertex is runnable based on the presence of activated vertices. This enhancement improves the accuracy of determining whether a vertex is runnable or not. * fix: add predecessors to vertices_to_run * style: fix lint issues * feat: optimize vertex filtering in useFlowStore This commit optimizes the vertex filtering logic in the `useFlowStore` function in `flowStore.ts`. It introduces a more efficient way to filter out vertices that are already being built, resulting in improved performance and accuracy. * refactor: add is_active method to Vertex class This commit adds the `is_active` method to the `Vertex` class in the `base.py` file. The `is_active` method checks if the state of the vertex is set to `ACTIVE` and returns a boolean value accordingly. This enhancement improves the readability and maintainability of the codebase. * refactor: improve is_vertex_runnable method in RunnableVerticesManager * refactor: improve find_runnable_predecessors_for_successors method in Graph class * refactor: move test_create_function
104 lines
2.4 KiB
Python
104 lines
2.4 KiB
Python
from pathlib import Path
|
|
from unittest import mock
|
|
|
|
import pytest
|
|
from requests.exceptions import MissingSchema
|
|
|
|
from langflow.utils.validate import create_function, execute_function, extract_function_name, validate_code
|
|
|
|
|
|
def test_create_function():
|
|
code = """
|
|
from pathlib import Path
|
|
|
|
def my_function(x: str) -> Path:
|
|
return Path(x)
|
|
"""
|
|
|
|
function_name = extract_function_name(code)
|
|
function = create_function(code, function_name)
|
|
result = function("test")
|
|
assert result == Path("test")
|
|
|
|
|
|
def test_validate_code():
|
|
# Test case with a valid import and function
|
|
code1 = """
|
|
import math
|
|
|
|
def square(x):
|
|
return x ** 2
|
|
"""
|
|
errors1 = validate_code(code1)
|
|
assert errors1 == {"imports": {"errors": []}, "function": {"errors": []}}
|
|
|
|
# Test case with an invalid import and valid function
|
|
code2 = """
|
|
import non_existent_module
|
|
|
|
def square(x):
|
|
return x ** 2
|
|
"""
|
|
errors2 = validate_code(code2)
|
|
assert errors2 == {
|
|
"imports": {"errors": ["No module named 'non_existent_module'"]},
|
|
"function": {"errors": []},
|
|
}
|
|
|
|
# Test case with a valid import and invalid function syntax
|
|
code3 = """
|
|
import math
|
|
|
|
def square(x)
|
|
return x ** 2
|
|
"""
|
|
errors3 = validate_code(code3)
|
|
assert errors3 == {
|
|
"imports": {"errors": []},
|
|
"function": {"errors": ["expected ':' (<unknown>, line 4)"]},
|
|
}
|
|
|
|
|
|
def test_execute_function_success():
|
|
code = """
|
|
import math
|
|
|
|
def my_function(x):
|
|
return math.sin(x) + 1
|
|
"""
|
|
result = execute_function(code, "my_function", 0.5)
|
|
assert result == 1.479425538604203
|
|
|
|
|
|
def test_execute_function_missing_module():
|
|
code = """
|
|
import some_missing_module
|
|
|
|
def my_function(x):
|
|
return some_missing_module.some_function(x)
|
|
"""
|
|
with pytest.raises(ModuleNotFoundError):
|
|
execute_function(code, "my_function", 0.5)
|
|
|
|
|
|
def test_execute_function_missing_function():
|
|
code = """
|
|
import math
|
|
|
|
def my_function(x):
|
|
return math.some_missing_function(x)
|
|
"""
|
|
with pytest.raises(AttributeError):
|
|
execute_function(code, "my_function", 0.5)
|
|
|
|
|
|
def test_execute_function_missing_schema():
|
|
code = """
|
|
import requests
|
|
|
|
def my_function(x):
|
|
return requests.get(x).text
|
|
"""
|
|
with mock.patch("requests.get", side_effect=MissingSchema):
|
|
with pytest.raises(MissingSchema):
|
|
execute_function(code, "my_function", "invalid_url")
|