def test_constructor_invalid_name(zero_prop_counter):
with pytest.raises(TypeError):
model.Property(name=["not", "a", "string"])
with pytest.raises(ValueError):
model.Property(name="has.a.dot")
# Check that the creation counter was not updated.
assert model.Property._CREATION_COUNTER == 0
def test_constructor_repeated_not_allowed(zero_prop_counter):
with pytest.raises(ValueError):
model.Property(name="a", repeated=True, required=True)
with pytest.raises(ValueError):
model.Property(name="b", repeated=True, default="zim")
# Check that the creation counter was not updated.
assert model.Property._CREATION_COUNTER == 0
def test__delete_value():
prop = model.Property(name="prop")
value = b"\x00\x01"
values = {prop._name: value}
entity = unittest.mock.Mock(_values=values, spec=("_values", ))
prop._delete_value(entity)
assert values == {}
def test_class_descriptors():
prop = model.Property(name="prop", required=True)
class Model:
prop2 = prop
assert Model.prop2 is prop
def test__set_value(property_clean_cache):
entity = unittest.mock.Mock(_projection=None,
_values={},
spec=("_projection", "_values"))
prop = model.Property(name="foo", repeated=False)
prop._set_value(entity, 19)
assert entity._values == {prop._name: 19}
def test__IN_not_indexed():
prop = model.Property("name", indexed=False)
with pytest.raises(exceptions.BadFilterError):
prop._IN([10, 20, 81])
# Cache is untouched.
assert model.Property._FIND_METHODS_CACHE == {}
def test__IN_wrong_container():
prop = model.Property("name", indexed=True)
with pytest.raises(exceptions.BadArgumentError):
prop._IN({1: "a", 11: "b"})
# Cache is untouched.
assert model.Property._FIND_METHODS_CACHE == {}
def test___repr__():
prop = model.Property(name="val")
param = query.Parameter("abc")
parameter_node = query.ParameterNode(prop, "=", param)
expected = "ParameterNode({!r}, '=', Parameter('abc'))".format(prop)
assert repr(parameter_node) == expected
def test_constructor():
prop = model.Property(name="val")
param = query.Parameter("abc")
parameter_node = query.ParameterNode(prop, "=", param)
assert parameter_node._prop is prop
assert parameter_node._op == "="
assert parameter_node._param is param
def test__set_value_projection():
entity = unittest.mock.Mock(_projection=True, spec=("_projection", ))
prop = model.Property(name="foo", repeated=True)
with pytest.raises(model.ReadonlyPropertyError):
prop._set_value(entity, None)
# Cache is untouched.
assert model.Property._FIND_METHODS_CACHE == {}
def test___eq__():
prop1 = model.Property(name="val")
param1 = query.Parameter("abc")
parameter_node1 = query.ParameterNode(prop1, "=", param1)
prop2 = model.Property(name="ue")
parameter_node2 = query.ParameterNode(prop2, "=", param1)
parameter_node3 = query.ParameterNode(prop1, "<", param1)
param2 = query.Parameter(900)
parameter_node4 = query.ParameterNode(prop1, "=", param2)
parameter_node5 = unittest.mock.sentinel.parameter_node
assert parameter_node1 == parameter_node1
assert not parameter_node1 == parameter_node2
assert not parameter_node1 == parameter_node3
assert not parameter_node1 == parameter_node4
assert not parameter_node1 == parameter_node5
def test__set_value_repeated(property_clean_cache):
entity = unittest.mock.Mock(_projection=False,
_values={},
spec=("_projection", "_values"))
prop = model.Property(name="foo", repeated=True)
prop._set_value(entity, (11, 12, 13))
assert entity._values == {prop._name: [11, 12, 13]}
def test_constructor_defaults(zero_prop_counter):
prop = model.Property()
# Check that the creation counter was updated.
assert model.Property._CREATION_COUNTER == 1
assert prop._creation_counter == 1
# Check that none of the constructor defaults were used.
assert prop.__dict__ == {"_creation_counter": 1}
def test__get_value_projected_absent():
prop = model.Property(name="prop")
entity = unittest.mock.Mock(_projection=("nope", ),
spec=("_projection", ))
with pytest.raises(model.UnprojectedPropertyError):
prop._get_value(entity)
# Cache is untouched.
assert model.Property._FIND_METHODS_CACHE == {}
def test__do_validate_base_value():
value = model._BaseValue(b"\x00\x01")
prop = model.Property(name="foo")
result = prop._do_validate(value)
assert result is value
# Cache is untouched.
assert model.Property._FIND_METHODS_CACHE == {}
def test__get_base_value_wrapped():
prop = model.Property(name="prop")
value = model._BaseValue(b"\x00\x01")
values = {prop._name: value}
entity = unittest.mock.Mock(_values=values, spec=("_values", ))
assert value is prop._get_base_value(entity)
# Cache is untouched.
assert model.Property._FIND_METHODS_CACHE == {}
def test__fix_up_no_name():
prop = model.Property()
assert prop._name is None
assert prop._code_name is None
prop._fix_up(None, "both")
assert prop._code_name == "both"
assert prop._name == "both"
def test_pickling():
prop = model.Property(name="val")
param = query.Parameter("abc")
parameter_node = query.ParameterNode(prop, "=", param)
pickled = pickle.dumps(parameter_node)
unpickled = pickle.loads(pickled)
assert parameter_node == unpickled
def test__has_value():
prop = model.Property(name="foo")
values = {prop._name: 88}
entity1 = unittest.mock.Mock(_values=values, spec=("_values", ))
entity2 = unittest.mock.Mock(_values={}, spec=("_values", ))
assert prop._has_value(entity1)
assert not prop._has_value(entity2)
def test_resolve():
prop = model.Property(name="val")
param = query.Parameter("abc")
parameter_node = query.ParameterNode(prop, "=", param)
used = {}
with pytest.raises(NotImplementedError):
parameter_node.resolve({}, used)
assert used == {}
def test__set_value_repeated_bad_container():
entity = unittest.mock.Mock(_projection=False,
_values={},
spec=("_projection", "_values"))
prop = model.Property(name="foo", repeated=True)
with pytest.raises(exceptions.BadValueError):
prop._set_value(entity, None)
# Cache is untouched.
assert model.Property._FIND_METHODS_CACHE == {}
def test___lt__(property_clean_cache):
prop = model.Property("name", indexed=True)
value = 2.0
expected = query.FilterNode(b"name", "<", value)
filter_node_left = prop < value
assert filter_node_left == expected
filter_node_right = value > prop
assert filter_node_right == expected
def test___gt__(property_clean_cache):
prop = model.Property("name", indexed=True)
value = "new"
expected = query.FilterNode(b"name", ">", value)
filter_node_left = prop > value
assert filter_node_left == expected
filter_node_right = value < prop
assert filter_node_right == expected
def test___ge__():
prop = model.Property("name", indexed=True)
value = "old"
expected = query.FilterNode(b"name", ">=", value)
filter_node_left = prop >= value
assert filter_node_left == expected
filter_node_right = value <= prop
assert filter_node_right == expected
def test___le__():
prop = model.Property("name", indexed=True)
value = 20.0
expected = query.FilterNode(b"name", "<=", value)
filter_node_left = prop <= value
assert filter_node_left == expected
filter_node_right = value >= prop
assert filter_node_right == expected
def test___eq__():
prop = model.Property("name", indexed=True)
value = 1337
expected = query.FilterNode(b"name", "=", value)
filter_node_left = prop == value
assert filter_node_left == expected
filter_node_right = value == prop
assert filter_node_right == expected
def test__retrieve_value():
prop = model.Property(name="foo")
values = {prop._name: b"\x00\x01"}
entity1 = unittest.mock.Mock(_values=values, spec=("_values", ))
entity2 = unittest.mock.Mock(_values={}, spec=("_values", ))
assert prop._retrieve_value(entity1) == b"\x00\x01"
assert prop._retrieve_value(entity2) is None
assert prop._retrieve_value(entity2, default=b"zip") == b"zip"
def test__is_initialized_set_to_none():
prop = model.Property(name="prop", required=True)
values = {prop._name: None}
entity = unittest.mock.Mock(_projection=None,
_values=values,
spec=("_projection", "_values"))
assert not prop._is_initialized(entity)
# Cache is untouched.
assert model.Property._FIND_METHODS_CACHE == {}
def test__do_validate_validator_none(property_clean_cache):
validator = unittest.mock.Mock(spec=(), return_value=None)
value = 18
prop = model.Property(name="foo", validator=validator)
result = prop._do_validate(value)
assert result == value
# Check validator call.
validator.assert_called_once_with(prop, value)
def test__set_value_none():
entity = unittest.mock.Mock(_projection=False,
_values={},
spec=("_projection", "_values"))
prop = model.Property(name="foo", repeated=False)
prop._set_value(entity, None)
assert entity._values == {prop._name: None}
# Cache is untouched.
assert model.Property._FIND_METHODS_CACHE == {}
