def test_constraint():
"""Test Constraint."""
c1 = Constraint("author", ConstraintType("==", "Stephen King"))
c2 = Constraint("author", ConstraintType("in", ["Stephen King"]))
book_1 = Description({
"author": "Stephen King",
"year": 1991,
"genre": "horror"
})
book_2 = Description({
"author": "George Orwell",
"year": 1948,
"genre": "horror"
})
assert c1.check(book_1)
assert not c1.check(book_2)
# empty description
assert not c1.check(Description({}))
# bad type
assert not c1.check(Description({"author": 12}))
# bad type
assert not c2.check(Description({"author": 12}))
assert c1.is_valid(generate_data_model("test", {"author": "some author"}))
assert not c1.is_valid(
generate_data_model("test", {"not_author": "some author"}))
assert c1 == c1
assert c1 != c2
def test_query():
"""Test Query."""
c1 = Constraint("author", ConstraintType("==", "Stephen King"))
query = Query([c1])
query.check_validity()
assert query.check(
Description({"author": "Stephen King", "year": 1991, "genre": "horror"})
)
assert query.is_valid(generate_data_model("test", {"author": "some author"}))
with pytest.raises(ValueError, match=r"Constraints must be a list .*"):
query = Query(c1)
Query([]).check_validity()
with pytest.raises(
ValueError,
match=r"Invalid input value for type 'Query': the query is not valid for the given data model.",
):
Query(
[c1], generate_data_model("test", {"notauthor": "not some author"})
).check_validity()
assert Query([]) == Query([])
mock = Mock()
Query.encode(mock, Query([]))
assert Query.decode(mock) == Query([])
def test_query():
"""Test Query."""
c1 = Constraint("author", ConstraintType("==", "Stephen King"))
model = generate_data_model("book_author",
{"author": "author of the book"})
query = Query([c1], model=model)
assert query.check(
Description({
"author": "Stephen King",
"year": 1991,
"genre": "horror"
}))
assert query.is_valid(
generate_data_model("test", {"author": "some author"}))
query.check_validity()
with pytest.raises(ValueError, match=r"Constraints must be a list .*"):
query = Query(c1)
Query([]).check_validity()
with pytest.raises(
ValueError,
match=
r"Invalid input value for type 'Query': the query is not valid for the given data model.",
):
Query([c1],
generate_data_model(
"test", {"notauthor": "not some author"})).check_validity()
assert query == Query([c1],
model=generate_data_model(
"book_author", {"author": "author of the book"}))
assert (
str(query) ==
f"Query(constraints=['Constraint(attribute_name=author,constraint_type=ConstraintType(value=Stephen King,type===))'],model={model})"
)
query_pb = query._encode()
actual_query = Query._decode(query_pb)
assert actual_query == query
query_pb = MagicMock()
query_pb.query_bytes = None
Query.encode(query_pb, query)
assert query_pb.query_bytes is not None
query = Query.decode(query_pb)
assert "author" in query.model.attributes_by_name
def test_generate_data_model():
"""Test model generated from description."""
params = dict(name="test", type_=str, is_required=True)
data_model = DataModel("test", [Attribute(**params)])
assert generate_data_model("test", {"test": "str"}) == data_model
def test_description():
"""Test model description."""
values = {"test": "test"}
Description(values=values, data_model=generate_data_model("test", values))
desc = Description(values=values)
assert (
str(desc) ==
"Description(values={'test': 'test'},data_model=DataModel(name=,attributes={'test': \"Attribute(name=test,type=<class 'str'>,is_required=True)\"},description=))"
)
assert Description(values=values) == Description(values=values)
assert list(Description(values=values)) == list(values.values())
with pytest.raises(AttributeInconsistencyException,
match=r"Missing required attribute."):
Description(values=values,
data_model=generate_data_model("test",
{"extra_key": "key"}))
with pytest.raises(
AttributeInconsistencyException,
match=r"Have extra attribute not in data model.",
):
Description(values=values, data_model=generate_data_model("test", {}))
with pytest.raises(AttributeInconsistencyException,
match=r".* has incorrect type:.*"):
Description(values=values,
data_model=generate_data_model("test", {"test": 12}))
with pytest.raises(AttributeInconsistencyException,
match=r".* has unallowed type:.*"):
Description(
values={"test": object()},
data_model=generate_data_model("test", {"test": object()}),
)
desc = Description(values=values)
mock = Mock()
Description.encode(mock, desc)
assert Description.decode(mock) == desc
def test_description():
"""Test model description."""
values = {"test": "test"}
Description(values=values, data_model=generate_data_model("test", values))
Description(values=values)
assert Description(values=values) == Description(values=values)
assert list(Description(values=values)) == list(values.values())
with pytest.raises(
AttributeInconsistencyException, match=r"Missing required attribute."
):
Description(
values=values, data_model=generate_data_model("test", {"extra_key": "key"})
)
with pytest.raises(
AttributeInconsistencyException,
match=r"Have extra attribute not in data model.",
):
Description(values=values, data_model=generate_data_model("test", {}))
with pytest.raises(
AttributeInconsistencyException, match=r".* has incorrect type:.*"
):
Description(values=values, data_model=generate_data_model("test", {"test": 12}))
with pytest.raises(
AttributeInconsistencyException, match=r".* has unallowed type:.*"
):
Description(
values={"test": object()},
data_model=generate_data_model("test", {"test": object()}),
)
desc = Description(values=values)
mock = Mock()
Description.encode(mock, desc)
assert Description.decode(mock) == desc
def test_description():
"""Test model description."""
values = {
"test": "test_value",
"bool": True,
"float": 1.1,
"int": int(1),
"loc": Location(1, 1),
}
description = Description(values=values,
data_model=generate_data_model("test", values))
assert description.values == values
assert description == Description(values=values,
data_model=generate_data_model(
"test", values))
assert list(description.values.values()) == list(values.values())
assert list(description) == list(values)
with pytest.raises(AttributeInconsistencyException,
match=r"Missing required attribute."):
Description(values=values,
data_model=generate_data_model("test",
{"extra_key": "key"}))
with pytest.raises(
AttributeInconsistencyException,
match=r"Have extra attribute not in data model.",
):
Description(values=values, data_model=generate_data_model("test", {}))
with pytest.raises(AttributeInconsistencyException,
match=r".* has incorrect type:.*"):
Description(
values=values,
data_model=generate_data_model("test", {
**values, "test": 12
}),
)
with pytest.raises(AttributeInconsistencyException,
match=r".* has unallowed type:.*"):
Description(
values={"test": object()},
data_model=generate_data_model("test", {"test": object()}),
)
assert re.match(r"Description\(values=.*data_model=.*", str(description))
description_pb = description._encode()
actual_description = Description._decode(description_pb)
assert actual_description == description
mock = MagicMock()
mock.description_bytes = None
Description.encode(mock, description)
assert mock.description_bytes is not None
description = Description.decode(mock)
assert "test" in description.values
def test_constraint():
"""Test Constraint."""
c1 = Constraint("author", ConstraintType("==", "Stephen King"))
c2 = Constraint("year", ConstraintType("within", (2000, 2010)))
c3 = Constraint("author",
ConstraintType("in", ("Stephen King", "J. K. Rowling")))
c4 = Constraint(
"author", ConstraintType("not_in", ("Stephen King", "J. K. Rowling")))
c5 = Constraint("address",
ConstraintType("distance", (Location(1.1, 2.2), 2.2)))
book_1 = Description({
"author": "Stephen King",
"year": 2005,
"address": Location(1.1, 2.2)
})
book_2 = Description({
"author": "George Orwell",
"year": 1948,
"address": Location(1.1, 2.2)
})
assert c1.check(book_1)
assert not c1.check(book_2)
# empty description
assert not c1.check(Description({}))
# bad type
assert not c1.check(Description({"author": 12}))
# bad type
assert not c2.check(Description({"author": 12}))
assert c1.is_valid(generate_data_model("test", {"author": "some author"}))
assert not c1.is_valid(
generate_data_model("test", {"not_author": "some author"}))
assert c1 == c1
assert c1 != c2
assert (
str(c1) ==
f"Constraint(attribute_name=author,constraint_type={c1.constraint_type})"
)
assert (
str(c2) ==
f"Constraint(attribute_name=year,constraint_type={c2.constraint_type})"
)
c1_pb = c1.encode()
actual_c1 = Constraint.decode(c1_pb)
assert actual_c1 == c1
c2_pb = c2.encode()
actual_c2 = Constraint.decode(c2_pb)
assert actual_c2 == c2
c3_pb = c3.encode()
actual_c3 = Constraint.decode(c3_pb)
assert actual_c3 == c3
c4_pb = c4.encode()
actual_c4 = Constraint.decode(c4_pb)
assert actual_c4 == c4
c5_pb = c5.encode()
actual_c5 = Constraint.decode(c5_pb)
assert actual_c5 == c5
