Spaces:
Running
Running
File size: 4,114 Bytes
d202ada |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 |
from pathlib import Path
from unittest import mock
import pytest
from langflow.utils.validate import (
create_class,
create_function,
execute_function,
extract_function_name,
validate_code,
)
from requests.exceptions import MissingSchema
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), pytest.raises(MissingSchema):
execute_function(code, "my_function", "invalid_url")
def test_create_class():
code = """
from langflow.custom import CustomComponent
class ExternalClass:
def __init__(self, value):
self.value = value
class MyComponent(CustomComponent):
def build(self):
return ExternalClass("test")
"""
class_name = "MyComponent"
created_class = create_class(code, class_name)
instance = created_class()
result = instance.build()
assert result.value == "test"
def test_create_class_with_multiple_external_classes():
code = """
from langflow.custom import CustomComponent
class ExternalClass1:
def __init__(self, value):
self.value = value
class ExternalClass2:
def __init__(self, value):
self.value = value
class MyComponent(CustomComponent):
def build(self):
return ExternalClass1("test1"), ExternalClass2("test2")
"""
class_name = "MyComponent"
created_class = create_class(code, class_name)
instance = created_class()
result1, result2 = instance.build()
assert result1.value == "test1"
assert result2.value == "test2"
def test_create_class_with_external_variables_and_functions():
code = """
from langflow.custom import CustomComponent
external_variable = "external_value"
def external_function():
return "external_function_value"
class MyComponent(CustomComponent):
def build(self):
return external_variable, external_function()
"""
class_name = "MyComponent"
created_class = create_class(code, class_name)
instance = created_class()
result_variable, result_function = instance.build()
assert result_variable == "external_value"
assert result_function == "external_function_value"
|