def test_strictus_field_required_option():
f1 = strictus_field()
assert not f1.required
assert not f1.clone().required
f2 = strictus_field(required=True)
assert f2.required
assert f2.clone().required
def test_unnamed_field_gets_name_from_getter():
def zzz(self) -> str:
return "z-value"
f1 = strictus_field(zzz)
assert f1.name == "zzz"
assert f1.type is str
f2 = strictus_field()(zzz)
assert f2.name == "zzz"
assert f2.type is str
class A(strictus):
v: int = strictus_field(init=True)
w: int
# a virtual field that is included in the dict output.
@strictus_field
def x(self):
return "xxx"
# a virtual field that is NOT included in the dict output
@strictus_field(dict=False)
def y(self):
return "yyy"
z: int = strictus_field(init=False)
class C(CBase, strictus):
class Meta:
init_all = True
q: B
r: int = 5
s: List[int] = strictus_field(default_factory=list)
def test_calling_strictus_field_with_func_produces_strictus_field_with_getter(
):
def x(self, value):
self._x = value
f = strictus_field(x)
assert f.name == "x"
assert f.getter is x
class C(strictus):
n: int = 0
o: int = strictus_field(default=1, dict=False)
@strictus_field(dict=False)
def p(self):
return 2
@strictus_field
def q(self):
return 3
def test_calling_strictus_field_instance_registers_getter():
f = strictus_field(name="x")
assert f.name == "x"
def x(self) -> str:
return "normal-x"
f(x)
assert f.getter is x
assert f.type is str
lambda_getter = lambda self: "lambda-x"
f(lambda_getter)
assert f.getter is lambda_getter
# Getter's name must match the field name
def bad_getter(self):
return "bad-x"
with pytest.raises(ValueError):
f(bad_getter)
class B(strictus):
a: A = strictus_field(default_factory=A)
a_list: List[A] = strictus_field(default_factory=list)
class A(strictus):
x: int = strictus_field(read_only=True)
class A(strictus):
x1: int = strictus_field(dict=False)
x2: int = strictus_field(dict=False, default=22)
y1: str = strictus_field(dict=True)
y2: str = strictus_field(dict=True, default="yy")
z: float
def test_fields_by_default_are_included_in_dict_repr():
f = strictus_field()
assert f.dict is True
g = strictus_field(dict=False)
assert g.dict is False
class ExampleProcess(strictus):
id: str = None
status: str = None
events: ExampleEvents = strictus_field(default_factory=ExampleEvents)
class A(strictus):
x: int = strictus_field(default=55)
class A(strictus):
x: int
y: int
label: str = strictus_field(default=None, read_only=True)
class B(A):
y: int = strictus_field(required=True)
z: int
class A(strictus):
x: int = strictus_field(required=True)
y: int
class B(A):
x: int = strictus_field(default=55,
dict=False,
read_only=True,
init=False)
def test_strictus_field_without_func_produces_strictus_field_instance():
f = strictus_field(name="f", type=int)
assert isinstance(f, strictus_field)
assert f.name == "f"
assert f.type is int