import json
import math
import typing
from typing import Dict, List, Set, Tuple, Union
import pytest
from pandas import DataFrame
from reflex.base import Base
from reflex.constants.base import REFLEX_VAR_CLOSING_TAG, REFLEX_VAR_OPENING_TAG
from reflex.experimental.vars.base import (
ImmutableVar,
LiteralVar,
var_operation,
)
from reflex.experimental.vars.function import ArgsFunctionOperation, FunctionStringVar
from reflex.experimental.vars.number import (
LiteralBooleanVar,
LiteralNumberVar,
NumberVar,
)
from reflex.experimental.vars.object import LiteralObjectVar
from reflex.experimental.vars.sequence import (
ArrayVar,
ConcatVarOperation,
LiteralArrayVar,
LiteralStringVar,
)
from reflex.state import BaseState
from reflex.utils.imports import ImportVar
from reflex.vars import (
BaseVar,
ComputedVar,
ImmutableVarData,
Var,
VarData,
computed_var,
)
test_vars = [
BaseVar(_var_name="prop1", _var_type=int),
BaseVar(_var_name="key", _var_type=str),
BaseVar(_var_name="value", _var_type=str)._var_set_state("state"),
BaseVar(_var_name="local", _var_type=str, _var_is_local=True)._var_set_state(
"state"
),
BaseVar(_var_name="local2", _var_type=str, _var_is_local=True),
]
class ATestState(BaseState):
"""Test state."""
value: str
dict_val: Dict[str, List] = {}
@pytest.fixture
def TestObj():
class TestObj(Base):
foo: int
bar: str
return TestObj
@pytest.fixture
def ParentState(TestObj):
class ParentState(BaseState):
foo: int
bar: int
@computed_var
def var_without_annotation(self):
return TestObj
return ParentState
@pytest.fixture
def ChildState(ParentState, TestObj):
class ChildState(ParentState):
@computed_var
def var_without_annotation(self):
return TestObj
return ChildState
@pytest.fixture
def GrandChildState(ChildState, TestObj):
class GrandChildState(ChildState):
@computed_var
def var_without_annotation(self):
return TestObj
return GrandChildState
@pytest.fixture
def StateWithAnyVar(TestObj):
class StateWithAnyVar(BaseState):
@computed_var
def var_without_annotation(self) -> typing.Any:
return TestObj
return StateWithAnyVar
@pytest.fixture
def StateWithCorrectVarAnnotation():
class StateWithCorrectVarAnnotation(BaseState):
@computed_var
def var_with_annotation(self) -> str:
return "Correct annotation"
return StateWithCorrectVarAnnotation
@pytest.fixture
def StateWithWrongVarAnnotation(TestObj):
class StateWithWrongVarAnnotation(BaseState):
@computed_var
def var_with_annotation(self) -> str:
return TestObj
return StateWithWrongVarAnnotation
@pytest.fixture
def StateWithInitialComputedVar():
class StateWithInitialComputedVar(BaseState):
@computed_var(initial_value="Initial value")
def var_with_initial_value(self) -> str:
return "Runtime value"
return StateWithInitialComputedVar
@pytest.fixture
def ChildWithInitialComputedVar(StateWithInitialComputedVar):
class ChildWithInitialComputedVar(StateWithInitialComputedVar):
@computed_var(initial_value="Initial value")
def var_with_initial_value_child(self) -> str:
return "Runtime value"
return ChildWithInitialComputedVar
@pytest.fixture
def StateWithRuntimeOnlyVar():
class StateWithRuntimeOnlyVar(BaseState):
@computed_var(initial_value=None)
def var_raises_at_runtime(self) -> str:
raise ValueError("So nicht, mein Freund")
return StateWithRuntimeOnlyVar
@pytest.fixture
def ChildWithRuntimeOnlyVar(StateWithRuntimeOnlyVar):
class ChildWithRuntimeOnlyVar(StateWithRuntimeOnlyVar):
@computed_var(initial_value="Initial value")
def var_raises_at_runtime_child(self) -> str:
raise ValueError("So nicht, mein Freund")
return ChildWithRuntimeOnlyVar
@pytest.mark.parametrize(
"prop,expected",
zip(
test_vars,
[
"prop1",
"key",
"state.value",
"state.local",
"local2",
],
),
)
def test_full_name(prop, expected):
"""Test that the full name of a var is correct.
Args:
prop: The var to test.
expected: The expected full name.
"""
assert prop._var_full_name == expected
@pytest.mark.parametrize(
"prop,expected",
zip(
test_vars,
["{prop1}", "{key}", "{state.value}", "state.local", "local2"],
),
)
def test_str(prop, expected):
"""Test that the string representation of a var is correct.
Args:
prop: The var to test.
expected: The expected string representation.
"""
assert str(prop) == expected
@pytest.mark.parametrize(
"prop,expected",
[
(BaseVar(_var_name="p", _var_type=int), 0),
(BaseVar(_var_name="p", _var_type=float), 0.0),
(BaseVar(_var_name="p", _var_type=str), ""),
(BaseVar(_var_name="p", _var_type=bool), False),
(BaseVar(_var_name="p", _var_type=list), []),
(BaseVar(_var_name="p", _var_type=dict), {}),
(BaseVar(_var_name="p", _var_type=tuple), ()),
(BaseVar(_var_name="p", _var_type=set), set()),
],
)
def test_default_value(prop, expected):
"""Test that the default value of a var is correct.
Args:
prop: The var to test.
expected: The expected default value.
"""
assert prop.get_default_value() == expected
@pytest.mark.parametrize(
"prop,expected",
zip(
test_vars,
[
"set_prop1",
"set_key",
"state.set_value",
"state.set_local",
"set_local2",
],
),
)
def test_get_setter(prop, expected):
"""Test that the name of the setter function of a var is correct.
Args:
prop: The var to test.
expected: The expected name of the setter function.
"""
assert prop.get_setter_name() == expected
@pytest.mark.parametrize(
"value,expected",
[
(None, None),
(1, BaseVar(_var_name="1", _var_type=int, _var_is_local=True)),
("key", BaseVar(_var_name="key", _var_type=str, _var_is_local=True)),
(3.14, BaseVar(_var_name="3.14", _var_type=float, _var_is_local=True)),
([1, 2, 3], BaseVar(_var_name="[1, 2, 3]", _var_type=list, _var_is_local=True)),
(
{"a": 1, "b": 2},
BaseVar(_var_name='{"a": 1, "b": 2}', _var_type=dict, _var_is_local=True),
),
],
)
def test_create(value, expected):
"""Test the var create function.
Args:
value: The value to create a var from.
expected: The expected name of the setter function.
"""
prop = Var.create(value)
if value is None:
assert prop == expected
else:
assert prop.equals(expected) # type: ignore
def test_create_type_error():
"""Test the var create function when inputs type error."""
class ErrorType:
pass
value = ErrorType()
with pytest.raises(TypeError):
Var.create(value)
def v(value) -> Var:
val = (
Var.create(json.dumps(value), _var_is_string=True, _var_is_local=False)
if isinstance(value, str)
else Var.create(value, _var_is_local=False)
)
assert val is not None
return val
def test_basic_operations(TestObj):
"""Test the var operations.
Args:
TestObj: The test object.
"""
assert str(v(1) == v(2)) == "{((1) === (2))}"
assert str(v(1) != v(2)) == "{((1) !== (2))}"
assert str(v(1) < v(2)) == "{((1) < (2))}"
assert str(v(1) <= v(2)) == "{((1) <= (2))}"
assert str(v(1) > v(2)) == "{((1) > (2))}"
assert str(v(1) >= v(2)) == "{((1) >= (2))}"
assert str(v(1) + v(2)) == "{((1) + (2))}"
assert str(v(1) - v(2)) == "{((1) - (2))}"
assert str(v(1) * v(2)) == "{((1) * (2))}"
assert str(v(1) / v(2)) == "{((1) / (2))}"
assert str(v(1) // v(2)) == "{Math.floor((1) / (2))}"
assert str(v(1) % v(2)) == "{((1) % (2))}"
assert str(v(1) ** v(2)) == "{Math.pow((1) , (2))}"
assert str(v(1) & v(2)) == "{((1) && (2))}"
assert str(v(1) | v(2)) == "{((1) || (2))}"
assert str(v([1, 2, 3])[v(0)]) == "{[1, 2, 3].at(0)}"
assert str(v({"a": 1, "b": 2})["a"]) == '{{"a": 1, "b": 2}["a"]}'
assert str(v("foo") == v("bar")) == '{(("foo") === ("bar"))}'
assert (
str(
Var.create("foo", _var_is_local=False)
== Var.create("bar", _var_is_local=False)
)
== "{((foo) === (bar))}"
)
assert (
str(
BaseVar(
_var_name="foo", _var_type=str, _var_is_string=True, _var_is_local=True
)
== BaseVar(
_var_name="bar", _var_type=str, _var_is_string=True, _var_is_local=True
)
)
== "((`foo`) === (`bar`))"
)
assert (
str(
BaseVar(
_var_name="foo",
_var_type=TestObj,
_var_is_string=True,
_var_is_local=False,
)
._var_set_state("state")
.bar
== BaseVar(
_var_name="bar", _var_type=str, _var_is_string=True, _var_is_local=True
)
)
== "{((state.foo.bar) === (`bar`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=TestObj)._var_set_state("state").bar)
== "{state.foo.bar}"
)
assert str(abs(v(1))) == "{Math.abs(1)}"
assert str(v([1, 2, 3]).length()) == "{[1, 2, 3].length}"
assert str(v([1, 2]) + v([3, 4])) == "{spreadArraysOrObjects(([1, 2]) , ([3, 4]))}"
# Tests for reverse operation
assert str(v([1, 2, 3]).reverse()) == "{[...[1, 2, 3]].reverse()}"
assert str(v(["1", "2", "3"]).reverse()) == '{[...["1", "2", "3"]].reverse()}'
assert (
str(BaseVar(_var_name="foo", _var_type=list)._var_set_state("state").reverse())
== "{[...state.foo].reverse()}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=list).reverse())
== "{[...foo].reverse()}"
)
assert str(BaseVar(_var_name="foo", _var_type=str)._type()) == "{typeof foo}" # type: ignore
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() == str) # type: ignore
== "{((typeof foo) === (`string`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() == str) # type: ignore
== "{((typeof foo) === (`string`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() == int) # type: ignore
== "{((typeof foo) === (`number`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() == list) # type: ignore
== "{((typeof foo) === (`Array`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() == float) # type: ignore
== "{((typeof foo) === (`number`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() == tuple) # type: ignore
== "{((typeof foo) === (`Array`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() == dict) # type: ignore
== "{((typeof foo) === (`Object`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() != str) # type: ignore
== "{((typeof foo) !== (`string`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() != int) # type: ignore
== "{((typeof foo) !== (`number`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() != list) # type: ignore
== "{((typeof foo) !== (`Array`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() != float) # type: ignore
== "{((typeof foo) !== (`number`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() != tuple) # type: ignore
== "{((typeof foo) !== (`Array`))}"
)
assert (
str(BaseVar(_var_name="foo", _var_type=str)._type() != dict) # type: ignore
== "{((typeof foo) !== (`Object`))}"
)
@pytest.mark.parametrize(
"var, expected",
[
(v([1, 2, 3]), "[1, 2, 3]"),
(v(set([1, 2, 3])), "[1, 2, 3]"),
(v(["1", "2", "3"]), '["1", "2", "3"]'),
(BaseVar(_var_name="foo", _var_type=list)._var_set_state("state"), "state.foo"),
(BaseVar(_var_name="foo", _var_type=list), "foo"),
(v((1, 2, 3)), "[1, 2, 3]"),
(v(("1", "2", "3")), '["1", "2", "3"]'),
(
BaseVar(_var_name="foo", _var_type=tuple)._var_set_state("state"),
"state.foo",
),
(BaseVar(_var_name="foo", _var_type=tuple), "foo"),
],
)
def test_list_tuple_contains(var, expected):
assert str(var.contains(1)) == f"{{{expected}.includes(1)}}"
assert str(var.contains("1")) == f'{{{expected}.includes("1")}}'
assert str(var.contains(v(1))) == f"{{{expected}.includes(1)}}"
assert str(var.contains(v("1"))) == f'{{{expected}.includes("1")}}'
other_state_var = BaseVar(_var_name="other", _var_type=str)._var_set_state("state")
other_var = BaseVar(_var_name="other", _var_type=str)
assert str(var.contains(other_state_var)) == f"{{{expected}.includes(state.other)}}"
assert str(var.contains(other_var)) == f"{{{expected}.includes(other)}}"
@pytest.mark.parametrize(
"var, expected",
[
(v("123"), json.dumps("123")),
(BaseVar(_var_name="foo", _var_type=str)._var_set_state("state"), "state.foo"),
(BaseVar(_var_name="foo", _var_type=str), "foo"),
],
)
def test_str_contains(var, expected):
assert str(var.contains("1")) == f'{{{expected}.includes("1")}}'
assert str(var.contains(v("1"))) == f'{{{expected}.includes("1")}}'
other_state_var = BaseVar(_var_name="other", _var_type=str)._var_set_state("state")
other_var = BaseVar(_var_name="other", _var_type=str)
assert str(var.contains(other_state_var)) == f"{{{expected}.includes(state.other)}}"
assert str(var.contains(other_var)) == f"{{{expected}.includes(other)}}"
assert (
str(var.contains("1", "hello")) == f'{{{expected}.some(e=>e[`hello`]==="1")}}'
)
@pytest.mark.parametrize(
"var, expected",
[
(v({"a": 1, "b": 2}), '{"a": 1, "b": 2}'),
(BaseVar(_var_name="foo", _var_type=dict)._var_set_state("state"), "state.foo"),
(BaseVar(_var_name="foo", _var_type=dict), "foo"),
],
)
def test_dict_contains(var, expected):
assert str(var.contains(1)) == f"{{{expected}.hasOwnProperty(1)}}"
assert str(var.contains("1")) == f'{{{expected}.hasOwnProperty("1")}}'
assert str(var.contains(v(1))) == f"{{{expected}.hasOwnProperty(1)}}"
assert str(var.contains(v("1"))) == f'{{{expected}.hasOwnProperty("1")}}'
other_state_var = BaseVar(_var_name="other", _var_type=str)._var_set_state("state")
other_var = BaseVar(_var_name="other", _var_type=str)
assert (
str(var.contains(other_state_var))
== f"{{{expected}.hasOwnProperty(state.other)}}"
)
assert str(var.contains(other_var)) == f"{{{expected}.hasOwnProperty(other)}}"
@pytest.mark.parametrize(
"var",
[
BaseVar(_var_name="list", _var_type=List[int]),
BaseVar(_var_name="tuple", _var_type=Tuple[int, int]),
BaseVar(_var_name="str", _var_type=str),
],
)
def test_var_indexing_lists(var):
"""Test that we can index into str, list or tuple vars.
Args:
var : The str, list or tuple base var.
"""
# Test basic indexing.
assert str(var[0]) == f"{{{var._var_name}.at(0)}}"
assert str(var[1]) == f"{{{var._var_name}.at(1)}}"
# Test negative indexing.
assert str(var[-1]) == f"{{{var._var_name}.at(-1)}}"
@pytest.mark.parametrize(
"var, type_",
[
(BaseVar(_var_name="list", _var_type=List[int]), [int, int]),
(BaseVar(_var_name="tuple", _var_type=Tuple[int, str]), [int, str]),
],
)
def test_var_indexing_types(var, type_):
"""Test that indexing returns valid types.
Args:
var : The list, typle base var.
type_ : The type on indexed object.
"""
assert var[2]._var_type == type_[0]
assert var[3]._var_type == type_[1]
def test_var_indexing_str():
"""Test that we can index into str vars."""
str_var = BaseVar(_var_name="str", _var_type=str)
# Test that indexing gives a type of Var[str].
assert isinstance(str_var[0], Var)
assert str_var[0]._var_type == str
# Test basic indexing.
assert str(str_var[0]) == "{str.at(0)}"
assert str(str_var[1]) == "{str.at(1)}"
# Test negative indexing.
assert str(str_var[-1]) == "{str.at(-1)}"
@pytest.mark.parametrize(
"var",
[
(BaseVar(_var_name="foo", _var_type=int)),
(BaseVar(_var_name="bar", _var_type=float)),
],
)
def test_var_replace_with_invalid_kwargs(var):
with pytest.raises(TypeError) as excinfo:
var._replace(_this_should_fail=True)
assert "Unexpected keyword arguments" in str(excinfo.value)
def test_computed_var_replace_with_invalid_kwargs():
@computed_var(initial_value=1)
def test_var(state) -> int:
return 1
with pytest.raises(TypeError) as excinfo:
test_var._replace(_random_kwarg=True)
assert "Unexpected keyword arguments" in str(excinfo.value)
@pytest.mark.parametrize(
"var, index",
[
(BaseVar(_var_name="lst", _var_type=List[int]), [1, 2]),
(BaseVar(_var_name="lst", _var_type=List[int]), {"name": "dict"}),
(BaseVar(_var_name="lst", _var_type=List[int]), {"set"}),
(
BaseVar(_var_name="lst", _var_type=List[int]),
(
1,
2,
),
),
(BaseVar(_var_name="lst", _var_type=List[int]), 1.5),
(BaseVar(_var_name="lst", _var_type=List[int]), "str"),
(
BaseVar(_var_name="lst", _var_type=List[int]),
BaseVar(_var_name="string_var", _var_type=str),
),
(
BaseVar(_var_name="lst", _var_type=List[int]),
BaseVar(_var_name="float_var", _var_type=float),
),
(
BaseVar(_var_name="lst", _var_type=List[int]),
BaseVar(_var_name="list_var", _var_type=List[int]),
),
(
BaseVar(_var_name="lst", _var_type=List[int]),
BaseVar(_var_name="set_var", _var_type=Set[str]),
),
(
BaseVar(_var_name="lst", _var_type=List[int]),
BaseVar(_var_name="dict_var", _var_type=Dict[str, str]),
),
(BaseVar(_var_name="str", _var_type=str), [1, 2]),
(BaseVar(_var_name="lst", _var_type=str), {"name": "dict"}),
(BaseVar(_var_name="lst", _var_type=str), {"set"}),
(
BaseVar(_var_name="lst", _var_type=str),
BaseVar(_var_name="string_var", _var_type=str),
),
(
BaseVar(_var_name="lst", _var_type=str),
BaseVar(_var_name="float_var", _var_type=float),
),
(BaseVar(_var_name="str", _var_type=Tuple[str]), [1, 2]),
(BaseVar(_var_name="lst", _var_type=Tuple[str]), {"name": "dict"}),
(BaseVar(_var_name="lst", _var_type=Tuple[str]), {"set"}),
(
BaseVar(_var_name="lst", _var_type=Tuple[str]),
BaseVar(_var_name="string_var", _var_type=str),
),
(
BaseVar(_var_name="lst", _var_type=Tuple[str]),
BaseVar(_var_name="float_var", _var_type=float),
),
],
)
def test_var_unsupported_indexing_lists(var, index):
"""Test unsupported indexing throws a type error.
Args:
var: The base var.
index: The base var index.
"""
with pytest.raises(TypeError):
var[index]
@pytest.mark.parametrize(
"var",
[
BaseVar(_var_name="lst", _var_type=List[int]),
BaseVar(_var_name="tuple", _var_type=Tuple[int, int]),
BaseVar(_var_name="str", _var_type=str),
],
)
def test_var_list_slicing(var):
"""Test that we can slice into str, list or tuple vars.
Args:
var : The str, list or tuple base var.
"""
assert str(var[:1]) == f"{{{var._var_name}.slice(0, 1)}}"
assert str(var[:1]) == f"{{{var._var_name}.slice(0, 1)}}"
assert str(var[:]) == f"{{{var._var_name}.slice(0, undefined)}}"
def test_dict_indexing():
"""Test that we can index into dict vars."""
dct = BaseVar(_var_name="dct", _var_type=Dict[str, int])
# Check correct indexing.
assert str(dct["a"]) == '{dct["a"]}'
assert str(dct["asdf"]) == '{dct["asdf"]}'
@pytest.mark.parametrize(
"var, index",
[
(
BaseVar(_var_name="dict", _var_type=Dict[str, str]),
[1, 2],
),
(
BaseVar(_var_name="dict", _var_type=Dict[str, str]),
{"name": "dict"},
),
(
BaseVar(_var_name="dict", _var_type=Dict[str, str]),
{"set"},
),
(
BaseVar(_var_name="dict", _var_type=Dict[str, str]),
(
1,
2,
),
),
(
BaseVar(_var_name="lst", _var_type=Dict[str, str]),
BaseVar(_var_name="list_var", _var_type=List[int]),
),
(
BaseVar(_var_name="lst", _var_type=Dict[str, str]),
BaseVar(_var_name="set_var", _var_type=Set[str]),
),
(
BaseVar(_var_name="lst", _var_type=Dict[str, str]),
BaseVar(_var_name="dict_var", _var_type=Dict[str, str]),
),
(
BaseVar(_var_name="df", _var_type=DataFrame),
[1, 2],
),
(
BaseVar(_var_name="df", _var_type=DataFrame),
{"name": "dict"},
),
(
BaseVar(_var_name="df", _var_type=DataFrame),
{"set"},
),
(
BaseVar(_var_name="df", _var_type=DataFrame),
(
1,
2,
),
),
(
BaseVar(_var_name="df", _var_type=DataFrame),
BaseVar(_var_name="list_var", _var_type=List[int]),
),
(
BaseVar(_var_name="df", _var_type=DataFrame),
BaseVar(_var_name="set_var", _var_type=Set[str]),
),
(
BaseVar(_var_name="df", _var_type=DataFrame),
BaseVar(_var_name="dict_var", _var_type=Dict[str, str]),
),
],
)
def test_var_unsupported_indexing_dicts(var, index):
"""Test unsupported indexing throws a type error.
Args:
var: The base var.
index: The base var index.
"""
with pytest.raises(TypeError):
var[index]
@pytest.mark.parametrize(
"fixture",
[
"ParentState",
"ChildState",
"GrandChildState",
"StateWithAnyVar",
],
)
def test_computed_var_without_annotation_error(request, fixture):
"""Test that a type error is thrown when an attribute of a computed var is
accessed without annotating the computed var.
Args:
request: Fixture Request.
fixture: The state fixture.
"""
with pytest.raises(TypeError) as err:
state = request.getfixturevalue(fixture)
state.var_without_annotation.foo
full_name = state.var_without_annotation._var_full_name
assert (
err.value.args[0]
== f"You must provide an annotation for the state var `{full_name}`. Annotation cannot be `typing.Any`"
)
@pytest.mark.parametrize(
"fixture",
[
"StateWithCorrectVarAnnotation",
"StateWithWrongVarAnnotation",
],
)
def test_computed_var_with_annotation_error(request, fixture):
"""Test that an Attribute error is thrown when a non-existent attribute of an annotated computed var is
accessed or when the wrong annotation is provided to a computed var.
Args:
request: Fixture Request.
fixture: The state fixture.
"""
with pytest.raises(AttributeError) as err:
state = request.getfixturevalue(fixture)
state.var_with_annotation.foo
full_name = state.var_with_annotation._var_full_name
assert (
err.value.args[0]
== f"The State var `{full_name}` has no attribute 'foo' or may have been annotated wrongly."
)
@pytest.mark.parametrize(
"fixture,var_name,expected_initial,expected_runtime,raises_at_runtime",
[
(
"StateWithInitialComputedVar",
"var_with_initial_value",
"Initial value",
"Runtime value",
False,
),
(
"ChildWithInitialComputedVar",
"var_with_initial_value_child",
"Initial value",
"Runtime value",
False,
),
(
"StateWithRuntimeOnlyVar",
"var_raises_at_runtime",
None,
None,
True,
),
(
"ChildWithRuntimeOnlyVar",
"var_raises_at_runtime_child",
"Initial value",
None,
True,
),
],
)
def test_state_with_initial_computed_var(
request, fixture, var_name, expected_initial, expected_runtime, raises_at_runtime
):
"""Test that the initial and runtime values of a computed var are correct.
Args:
request: Fixture Request.
fixture: The state fixture.
var_name: The name of the computed var.
expected_initial: The expected initial value of the computed var.
expected_runtime: The expected runtime value of the computed var.
raises_at_runtime: Whether the computed var is runtime only.
"""
state = request.getfixturevalue(fixture)()
state_name = state.get_full_name()
initial_dict = state.dict(initial=True)[state_name]
assert initial_dict[var_name] == expected_initial
if raises_at_runtime:
with pytest.raises(ValueError):
state.dict()[state_name][var_name]
else:
runtime_dict = state.dict()[state_name]
assert runtime_dict[var_name] == expected_runtime
def test_literal_var():
complicated_var = LiteralVar.create(
[
{"a": 1, "b": 2, "c": {"d": 3, "e": 4}},
[1, 2, 3, 4],
9,
"string",
True,
False,
None,
set([1, 2, 3]),
]
)
assert (
str(complicated_var)
== '[({ ["a"] : 1, ["b"] : 2, ["c"] : ({ ["d"] : 3, ["e"] : 4 }) }), [1, 2, 3, 4], 9, "string", true, false, null, [1, 2, 3]]'
)
def test_function_var():
addition_func = FunctionStringVar("((a, b) => a + b)")
assert str(addition_func.call(1, 2)) == "(((a, b) => a + b)(1, 2))"
manual_addition_func = ArgsFunctionOperation(
("a", "b"),
{
"args": [ImmutableVar.create_safe("a"), ImmutableVar.create_safe("b")],
"result": ImmutableVar.create_safe("a + b"),
},
)
assert (
str(manual_addition_func.call(1, 2))
== '(((a, b) => (({ ["args"] : [a, b], ["result"] : a + b })))(1, 2))'
)
increment_func = addition_func(1)
assert (
str(increment_func.call(2))
== "(((...args) => ((((a, b) => a + b)(1, ...args))))(2))"
)
create_hello_statement = ArgsFunctionOperation(
("name",), f"Hello, {ImmutableVar.create_safe('name')}!"
)
first_name = LiteralStringVar("Steven")
last_name = LiteralStringVar("Universe")
assert (
str(create_hello_statement.call(f"{first_name} {last_name}"))
== '(((name) => (("Hello, "+name+"!")))(("Steven"+" "+"Universe")))'
)
def test_var_operation():
@var_operation(output=NumberVar)
def add(a: Union[NumberVar, int], b: Union[NumberVar, int]) -> str:
return f"({a} + {b})"
assert str(add(1, 2)) == "(1 + 2)"
assert str(add(a=4, b=-9)) == "(4 + -9)"
five = LiteralNumberVar(5)
seven = add(2, five)
assert isinstance(seven, NumberVar)
def test_string_operations():
basic_string = LiteralStringVar.create("Hello, World!")
assert str(basic_string.length()) == '"Hello, World!".split("").length'
assert str(basic_string.lower()) == '"Hello, World!".toLowerCase()'
assert str(basic_string.upper()) == '"Hello, World!".toUpperCase()'
assert str(basic_string.strip()) == '"Hello, World!".trim()'
assert str(basic_string.contains("World")) == '"Hello, World!".includes("World")'
assert (
str(basic_string.split(" ").join(",")) == '"Hello, World!".split(" ").join(",")'
)
def test_all_number_operations():
starting_number = LiteralNumberVar(-5.4)
complicated_number = (((-(starting_number + 1)) * 2 / 3) // 2 % 3) ** 2
assert (
str(complicated_number)
== "((Math.floor(((-((-5.4 + 1)) * 2) / 3) / 2) % 3) ** 2)"
)
even_more_complicated_number = ~(
abs(math.floor(complicated_number)) | 2 & 3 & round(complicated_number)
)
assert (
str(even_more_complicated_number)
== "!(((Math.abs(Math.floor(((Math.floor(((-((-5.4 + 1)) * 2) / 3) / 2) % 3) ** 2))) != 0) || (true && (Math.round(((Math.floor(((-((-5.4 + 1)) * 2) / 3) / 2) % 3) ** 2)) != 0))))"
)
assert str(LiteralNumberVar(5) > False) == "(5 > 0)"
assert str(LiteralBooleanVar(False) < 5) == "((false ? 1 : 0) < 5)"
assert (
str(LiteralBooleanVar(False) < LiteralBooleanVar(True))
== "((false ? 1 : 0) < (true ? 1 : 0))"
)
def test_index_operation():
array_var = LiteralArrayVar([1, 2, 3, 4, 5])
assert str(array_var[0]) == "[1, 2, 3, 4, 5].at(0)"
assert str(array_var[1:2]) == "[1, 2, 3, 4, 5].slice(1, 2)"
assert (
str(array_var[1:4:2])
== "[1, 2, 3, 4, 5].slice(1, 4).filter((_, i) => i % 2 === 0)"
)
assert (
str(array_var[::-1])
== "[1, 2, 3, 4, 5].slice(0, [1, 2, 3, 4, 5].length).reverse().slice(undefined, undefined).filter((_, i) => i % 1 === 0)"
)
assert str(array_var.reverse()) == "[1, 2, 3, 4, 5].reverse()"
assert str(array_var[0].to(NumberVar) + 9) == "([1, 2, 3, 4, 5].at(0) + 9)"
def test_array_operations():
array_var = LiteralArrayVar.create([1, 2, 3, 4, 5])
assert str(array_var.length()) == "[1, 2, 3, 4, 5].length"
assert str(array_var.contains(3)) == "[1, 2, 3, 4, 5].includes(3)"
assert str(array_var.reverse()) == "[1, 2, 3, 4, 5].reverse()"
assert (
str(ArrayVar.range(10))
== "Array.from({ length: (10 - 0) / 1 }, (_, i) => 0 + i * 1)"
)
assert (
str(ArrayVar.range(1, 10))
== "Array.from({ length: (10 - 1) / 1 }, (_, i) => 1 + i * 1)"
)
assert (
str(ArrayVar.range(1, 10, 2))
== "Array.from({ length: (10 - 1) / 2 }, (_, i) => 1 + i * 2)"
)
assert (
str(ArrayVar.range(1, 10, -1))
== "Array.from({ length: (10 - 1) / -1 }, (_, i) => 1 + i * -1)"
)
def test_object_operations():
object_var = LiteralObjectVar({"a": 1, "b": 2, "c": 3})
assert (
str(object_var.keys()) == 'Object.keys(({ ["a"] : 1, ["b"] : 2, ["c"] : 3 }))'
)
assert (
str(object_var.values())
== 'Object.values(({ ["a"] : 1, ["b"] : 2, ["c"] : 3 }))'
)
assert (
str(object_var.entries())
== 'Object.entries(({ ["a"] : 1, ["b"] : 2, ["c"] : 3 }))'
)
assert str(object_var.a) == '({ ["a"] : 1, ["b"] : 2, ["c"] : 3 })["a"]'
assert str(object_var["a"]) == '({ ["a"] : 1, ["b"] : 2, ["c"] : 3 })["a"]'
assert (
str(object_var.merge(LiteralObjectVar({"c": 4, "d": 5})))
== 'Object.assign(({ ["a"] : 1, ["b"] : 2, ["c"] : 3 }), ({ ["c"] : 4, ["d"] : 5 }))'
)
def test_type_chains():
object_var = LiteralObjectVar({"a": 1, "b": 2, "c": 3})
assert (object_var._key_type(), object_var._value_type()) == (str, int)
assert (object_var.keys()._var_type, object_var.values()._var_type) == (
List[str],
List[int],
)
assert (
str(object_var.keys()[0].upper()) # type: ignore
== 'Object.keys(({ ["a"] : 1, ["b"] : 2, ["c"] : 3 })).at(0).toUpperCase()'
)
assert (
str(object_var.entries()[1][1] - 1) # type: ignore
== '(Object.entries(({ ["a"] : 1, ["b"] : 2, ["c"] : 3 })).at(1).at(1) - 1)'
)
assert (
str(object_var["c"] + object_var["b"]) # type: ignore
== '(({ ["a"] : 1, ["b"] : 2, ["c"] : 3 })["c"] + ({ ["a"] : 1, ["b"] : 2, ["c"] : 3 })["b"])'
)
def test_nested_dict():
arr = LiteralArrayVar([{"bar": ["foo", "bar"]}], List[Dict[str, List[str]]])
assert (
str(arr[0]["bar"][0]) == '[({ ["bar"] : ["foo", "bar"] })].at(0)["bar"].at(0)'
)
def nested_base():
class Boo(Base):
foo: str
bar: int
class Foo(Base):
bar: Boo
baz: int
parent_obj = LiteralVar.create(Foo(bar=Boo(foo="bar", bar=5), baz=5))
assert (
str(parent_obj.bar.foo)
== '({ ["bar"] : ({ ["foo"] : "bar", ["bar"] : 5 }), ["baz"] : 5 })["bar"]["foo"]'
)
def test_retrival():
var_without_data = ImmutableVar.create("test")
assert var_without_data is not None
original_var_data = VarData(
state="Test",
imports={"react": [ImportVar(tag="useRef")]},
hooks={"const state = useContext(StateContexts.state)": None},
)
var_with_data = var_without_data._replace(merge_var_data=original_var_data)
f_string = f"foo{var_with_data}bar"
assert REFLEX_VAR_OPENING_TAG in f_string
assert REFLEX_VAR_CLOSING_TAG in f_string
result_var_data = Var.create_safe(f_string)._var_data
result_immutable_var_data = ImmutableVar.create_safe(f_string)._var_data
assert result_var_data is not None and result_immutable_var_data is not None
assert (
result_var_data.state
== result_immutable_var_data.state
== original_var_data.state
)
assert (
result_var_data.imports
== (
result_immutable_var_data.imports
if isinstance(result_immutable_var_data.imports, dict)
else {
k: list(v)
for k, v in result_immutable_var_data.imports
if k in original_var_data.imports
}
)
== original_var_data.imports
)
assert (
list(result_var_data.hooks.keys())
== (
list(result_immutable_var_data.hooks.keys())
if isinstance(result_immutable_var_data.hooks, dict)
else list(result_immutable_var_data.hooks)
)
== list(original_var_data.hooks.keys())
)
def test_fstring_concat():
original_var_with_data = Var.create_safe(
"imagination", _var_data=VarData(state="fear")
)
immutable_var_with_data = ImmutableVar.create_safe(
"consequences",
_var_data=VarData(
imports={
"react": [ImportVar(tag="useRef")],
"utils": [ImportVar(tag="useEffect")],
}
),
)
f_string = f"foo{original_var_with_data}bar{immutable_var_with_data}baz"
string_concat = LiteralStringVar.create(
f_string,
_var_data=VarData(
hooks={"const state = useContext(StateContexts.state)": None}
),
)
assert str(string_concat) == '("foo"+imagination+"bar"+consequences+"baz")'
assert isinstance(string_concat, ConcatVarOperation)
assert string_concat._get_all_var_data() == ImmutableVarData(
state="fear",
imports={
"react": [ImportVar(tag="useRef")],
"utils": [ImportVar(tag="useEffect")],
},
hooks={"const state = useContext(StateContexts.state)": None},
)
@pytest.mark.parametrize(
"out, expected",
[
(f"{BaseVar(_var_name='var', _var_type=str)}", "${var}"),
(
f"testing f-string with {BaseVar(_var_name='myvar', _var_type=int)._var_set_state('state')}",
'testing f-string with $<reflex.Var>{"state": "state", "interpolations": [], "imports": {"/utils/context": [{"tag": "StateContexts", "is_default": false, "alias": null, "install": true, "render": true, "transpile": false}], "react": [{"tag": "useContext", "is_default": false, "alias": null, "install": true, "render": true, "transpile": false}]}, "hooks": {"const state = useContext(StateContexts.state)": null}, "string_length": 13}</reflex.Var>{state.myvar}',
),
(
f"testing local f-string {BaseVar(_var_name='x', _var_is_local=True, _var_type=str)}",
"testing local f-string x",
),
],
)
def test_fstrings(out, expected):
assert out == expected
@pytest.mark.parametrize(
("value", "expect_state"),
[
([1], ""),
({"a": 1}, ""),
([Var.create_safe(1)._var_set_state("foo")], "foo"),
({"a": Var.create_safe(1)._var_set_state("foo")}, "foo"),
],
)
def test_extract_state_from_container(value, expect_state):
"""Test that _var_state is extracted from containers containing BaseVar.
Args:
value: The value to create a var from.
expect_state: The expected state.
"""
assert Var.create_safe(value)._var_state == expect_state
@pytest.mark.parametrize(
"value",
[
"var",
"\nvar",
],
)
def test_fstring_roundtrip(value):
"""Test that f-string roundtrip carries state.
Args:
value: The value to create a Var from.
"""
var = BaseVar.create_safe(value)._var_set_state("state")
rt_var = Var.create_safe(f"{var}")
assert var._var_state == rt_var._var_state
assert var._var_full_name_needs_state_prefix
assert not rt_var._var_full_name_needs_state_prefix
assert rt_var._var_name == var._var_full_name
@pytest.mark.parametrize(
"var",
[
BaseVar(_var_name="var", _var_type=int),
BaseVar(_var_name="var", _var_type=float),
BaseVar(_var_name="var", _var_type=str),
BaseVar(_var_name="var", _var_type=bool),
BaseVar(_var_name="var", _var_type=dict),
BaseVar(_var_name="var", _var_type=tuple),
BaseVar(_var_name="var", _var_type=set),
BaseVar(_var_name="var", _var_type=None),
],
)
def test_unsupported_types_for_reverse(var):
"""Test that unsupported types for reverse throw a type error.
Args:
var: The base var.
"""
with pytest.raises(TypeError) as err:
var.reverse()
assert err.value.args[0] == f"Cannot reverse non-list var var."
@pytest.mark.parametrize(
"var",
[
BaseVar(_var_name="var", _var_type=int),
BaseVar(_var_name="var", _var_type=float),
BaseVar(_var_name="var", _var_type=bool),
BaseVar(_var_name="var", _var_type=None),
],
)
def test_unsupported_types_for_contains(var):
"""Test that unsupported types for contains throw a type error.
Args:
var: The base var.
"""
with pytest.raises(TypeError) as err:
assert var.contains(1)
assert (
err.value.args[0]
== f"Var var of type {var._var_type} does not support contains check."
)
@pytest.mark.parametrize(
"other",
[
BaseVar(_var_name="other", _var_type=int),
BaseVar(_var_name="other", _var_type=float),
BaseVar(_var_name="other", _var_type=bool),
BaseVar(_var_name="other", _var_type=list),
BaseVar(_var_name="other", _var_type=dict),
BaseVar(_var_name="other", _var_type=tuple),
BaseVar(_var_name="other", _var_type=set),
],
)
def test_unsupported_types_for_string_contains(other):
with pytest.raises(TypeError) as err:
assert BaseVar(_var_name="var", _var_type=str).contains(other)
assert (
err.value.args[0]
== f"'in <string>' requires string as left operand, not {other._var_type}"
)
def test_unsupported_default_contains():
with pytest.raises(TypeError) as err:
assert 1 in BaseVar(_var_name="var", _var_type=str)
assert (
err.value.args[0]
== "'in' operator not supported for Var types, use Var.contains() instead."
)
@pytest.mark.parametrize(
"operand1_var,operand2_var,operators",
[
(
Var.create(10),
Var.create(5),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"&",
],
),
(
Var.create(10.5),
Var.create(5),
["+", "-", "/", "//", "*", "%", "**", ">", "<", "<=", ">="],
),
(
Var.create(5),
Var.create(True),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"&",
],
),
(
Var.create(10.5),
Var.create(5.5),
["+", "-", "/", "//", "*", "%", "**", ">", "<", "<=", ">="],
),
(
Var.create(10.5),
Var.create(True),
["+", "-", "/", "//", "*", "%", "**", ">", "<", "<=", ">="],
),
(Var.create("10"), Var.create("5"), ["+", ">", "<", "<=", ">="]),
(Var.create([10, 20]), Var.create([5, 6]), ["+", ">", "<", "<=", ">="]),
(Var.create([10, 20]), Var.create(5), ["*"]),
(Var.create([10, 20]), Var.create(True), ["*"]),
(
Var.create(True),
Var.create(True),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"&",
],
),
],
)
def test_valid_var_operations(operand1_var: Var, operand2_var, operators: List[str]):
"""Test that operations do not raise a TypeError.
Args:
operand1_var: left operand.
operand2_var: right operand.
operators: list of supported operators.
"""
for operator in operators:
operand1_var.operation(op=operator, other=operand2_var)
operand1_var.operation(op=operator, other=operand2_var, flip=True)
@pytest.mark.parametrize(
"operand1_var,operand2_var,operators",
[
(
Var.create(10),
Var.create(5),
[
"^",
"<<",
">>",
],
),
(
Var.create(10.5),
Var.create(5),
[
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create(10.5),
Var.create(True),
[
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create(10.5),
Var.create(5.5),
[
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create("10"),
Var.create("5"),
[
"-",
"/",
"//",
"*",
"%",
"**",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create([10, 20]),
Var.create([5, 6]),
[
"-",
"/",
"//",
"*",
"%",
"**",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create([10, 20]),
Var.create(5),
[
"+",
"-",
"/",
"//",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create([10, 20]),
Var.create(True),
[
"+",
"-",
"/",
"//",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create([10, 20]),
Var.create("5"),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create([10, 20]),
Var.create({"key": "value"}),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create([10, 20]),
Var.create(5.5),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create({"key": "value"}),
Var.create({"another_key": "another_value"}),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create({"key": "value"}),
Var.create(5),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create({"key": "value"}),
Var.create(True),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create({"key": "value"}),
Var.create(5.5),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
(
Var.create({"key": "value"}),
Var.create("5"),
[
"+",
"-",
"/",
"//",
"*",
"%",
"**",
">",
"<",
"<=",
">=",
"|",
"^",
"<<",
">>",
"&",
],
),
],
)
def test_invalid_var_operations(operand1_var: Var, operand2_var, operators: List[str]):
for operator in operators:
with pytest.raises(TypeError):
operand1_var.operation(op=operator, other=operand2_var)
with pytest.raises(TypeError):
operand1_var.operation(op=operator, other=operand2_var, flip=True)
@pytest.mark.parametrize(
"var, expected",
[
(Var.create("string_value", _var_is_string=True), "`string_value`"),
(Var.create(1), "1"),
(Var.create([1, 2, 3]), "[1, 2, 3]"),
(Var.create({"foo": "bar"}), '{"foo": "bar"}'),
(
Var.create(ATestState.value, _var_is_string=True),
f"{ATestState.get_full_name()}.value",
),
(
Var.create(f"{ATestState.value} string", _var_is_string=True),
f"`${{{ATestState.get_full_name()}.value}} string`",
),
(Var.create(ATestState.dict_val), f"{ATestState.get_full_name()}.dict_val"),
],
)
def test_var_name_unwrapped(var, expected):
assert var._var_name_unwrapped == expected
def cv_fget(state: BaseState) -> int:
return 1
@pytest.mark.parametrize(
"deps,expected",
[
(["a"], {"a"}),
(["b"], {"b"}),
([ComputedVar(fget=cv_fget)], {"cv_fget"}),
],
)
def test_computed_var_deps(deps: List[Union[str, Var]], expected: Set[str]):
@computed_var(
deps=deps,
cache=True,
)
def test_var(state) -> int:
return 1
assert test_var._static_deps == expected
@pytest.mark.parametrize(
"deps",
[
[""],
[1],
["", "abc"],
],
)
def test_invalid_computed_var_deps(deps: List):
with pytest.raises(TypeError):
@computed_var(
deps=deps,
cache=True,
)
def test_var(state) -> int:
return 1