def test_full_qualified_field_fqid(self) -> None:
fqfield = FullQualifiedField(Collection("collection_quephah8Oo"),
3148072663, "field_Ein2Aos0Ku")
self.assertEqual(
fqfield.fqid,
FullQualifiedId(Collection("collection_quephah8Oo"), 3148072663),
)
class FakeModelB(Model):
collection = Collection("fake_model_b")
verbose_name = "fake model b"
id = fields.IntegerField()
meeting_id = fields.RelationField(
to={Collection("meeting"): "fake_model_b_ids"},
required=True,
)
fake_model_a_oo = fields.RelationField(
to={Collection("fake_model_a"): "fake_model_b_oo"})
fake_model_a_mo = fields.RelationListField(
to={Collection("fake_model_a"): "fake_model_b_om"})
fake_model_a_mm = fields.RelationListField(
to={Collection("fake_model_a"): "fake_model_b_mm"})
fake_model_a_generic_oo = fields.GenericRelationField(
to={Collection("fake_model_a"): "fake_model_b_generic_oo"}, )
fake_model_a_generic_mo = fields.GenericRelationListField(
to={Collection("fake_model_a"): "fake_model_b_generic_om"}, )
fake_model_a_generic_mm = fields.GenericRelationListField(
to={Collection("fake_model_a"): "fake_model_b_generic_mm"}, )
structured_relation_field = fields.RelationField(
to={Collection("fake_model_a"): "fake_model_b_$_ids"}, )
fake_model_c_ids = fields.RelationListField(
to={Collection("fake_model_c"): "foreign_key_field"}, )
def test_getMany() -> None:
gmr = GetManyRequest(Collection("a"), ids=[1, 2], mapped_fields=["f"])
gmr2 = GetManyRequest(Collection("b"), [1, 2], mapped_fields=["f"])
result = db.getMany([gmr, gmr2])
assert result is not None
assert result["a/1"] is not None
assert result["a/2"] is not None
assert result["b/1"] is not None
class FakeModelCRD(Model):
collection = Collection("fake_model_cr_d")
verbose_name = "fake model for create relation d"
id = fields.IntegerField()
name = fields.CharField()
fake_model_cr_c_ids = fields.RelationListField(
to={Collection("fake_model_cr_c"): "fake_model_cr_d_id"},
required=True)
class FakeModelURA(Model):
collection = Collection("fake_model_ur_a")
verbose_name = "fake model for cascade update a"
id = fields.IntegerField()
fake_model_ur_b_id = fields.RelationField(
to={Collection("fake_model_ur_b"): "fake_model_ur_a_id"}, )
fake_model_ur_b_required_id = fields.RelationField(
to={Collection("fake_model_ur_b"): "fake_model_ur_a_required_id"}, )
class FakeModelEFA(Model):
collection = Collection("fake_model_ef_a")
verbose_name = "fake model for equal field check a"
id = fields.IntegerField()
b_id = fields.RelationField(
to={Collection("fake_model_ef_b"): "meeting_id"}, )
c_id = fields.RelationField(
to={Collection("fake_model_ef_c"): "meeting_id"}, )
class FakeModelEFA(Model):
collection = Collection("fake_model_ef_a")
verbose_name = "fake model for equal field check a"
b_id = fields.RelationField(
to=Collection("fake_model_ef_b"), related_name="reference_field",
)
c_id = fields.RelationField(
to=Collection("fake_model_ef_c"), related_name="reference_field",
)
class FakeModelCDC(Model):
collection = Collection("fake_model_cd_c")
verbose_name = "fake model for cascade deletion c"
id = fields.IntegerField()
fake_model_cd_a = fields.RelationField(
to={Collection("fake_model_cd_a"): "fake_model_cd_c"})
fake_model_cd_b_protected = fields.RelationField(
to={Collection("fake_model_cd_b"): "fake_model_cd_c_protect"})
fake_model_cd_b_cascaded = fields.RelationField(
to={Collection("fake_model_cd_b"): "fake_model_cd_c_cascade"})
class FakeModelCDC(Model):
collection = Collection("fake_model_cd_c")
verbose_name = "fake model for cascade deletion c"
fake_model_cd_a = fields.RelationField(
to=Collection("fake_model_cd_a"), related_name="fake_model_cd_c"
)
fake_model_cd_b_protected = fields.RelationField(
to=Collection("fake_model_cd_b"), related_name="fake_model_cd_c_protect"
)
fake_model_cd_b_cascaded = fields.RelationField(
to=Collection("fake_model_cd_b"), related_name="fake_model_cd_c_cascade"
)
class FakeModelCDA(Model):
collection = Collection("fake_model_cd_a")
verbose_name = "fake model for cascade deletion a"
fake_model_cd_b = fields.RelationField(
to=Collection("fake_model_cd_b"),
related_name="fake_model_cd_a",
on_delete=fields.OnDelete.CASCADE,
)
fake_model_cd_c = fields.RelationField(
to=Collection("fake_model_cd_c"),
related_name="fake_model_cd_a",
on_delete=fields.OnDelete.CASCADE,
)
class FakeModel2(Model):
"""
Fake model for testing purposes. With relation field.
"""
collection = Collection("fake_model_2")
verbose_name = "fake_model_2"
id = fields.IntegerField(required=True)
relation_field = fields.RelationField(
to={Collection("fake_model"): "fake_model_2_ids"},
)
generic_relation_field = fields.RelationField(
to={Collection("fake_model"): "fake_model_2_generic_ids"},
)
def test_max(self) -> None:
collection = Collection("a")
field = "f"
value = "1"
operator = "="
filter = FilterOperator(field=field, value=value, operator=operator)
command = commands.Max(collection=collection,
filter=filter,
field=field)
self.engine.retrieve.return_value = json.dumps({
"max": 1,
"position": 1
}), 200
agg = self.db.max(collection=collection, filter=filter, field=field)
assert agg is not None
assert command.get_raw_data() == {
"collection": str(collection),
"filter": {
"field": field,
"operator": operator,
"value": value
},
"field": field,
}
self.engine.retrieve.called_with("max", command.data)
def test_count(self) -> None:
collection = Collection("a")
field = "f"
value = "1"
operator = "="
filter = FilterOperator(field=field, value=value, operator=operator)
command = commands.Count(collection=collection, filter=filter)
self.engine.retrieve.return_value = (
json.dumps({
"count": True,
"position": 1
}),
200,
)
count = self.db.count(collection=collection, filter=filter)
assert count is not None
assert command.get_raw_data() == {
"collection": str(collection),
"filter": {
"field": field,
"operator": operator,
"value": value
},
}
self.engine.retrieve.called_with("count", command.data)
def test_fetch_model_ADD_BEFORE_DB_nothing_no_exception(self) -> None:
result = self.datastore.fetch_model(
fqid=FullQualifiedId(Collection("meeting"), 1),
mapped_fields=["name"],
exception=False,
)
self.assertEqual(result.get("name"), None)
def test_structured_relation_init_2(self) -> None:
with self.assertRaises(ValueError):
fields.ForeignKeyField(
description="The foreign key of fake_model_tahheque7O.",
to=Collection("fake_model_tahheque7O"),
related_name="invalid_related_name_with_$",
)
class FakeModelC(Model):
collection = Collection("fake_model_c")
verbose_name = "fake model c"
id = fields.IntegerField()
# nested structured field
foreign_key_field = fields.RelationField(
to=Collection("fake_model_b"),
related_name="fake_model_c_ids",
)
structured_relation_field = fields.RelationField(
to=Collection("fake_model_a"),
related_name="fake_model_c_$_ids",
structured_relation=["foreign_key_field", "meeting_id"],
)
def test_getAll() -> None:
fields = ["f"]
collection = Collection("a")
partial_models = db.getAll(collection=collection, mapped_fields=fields)
assert isinstance(partial_models, list)
assert partial_models is not None
assert len(partial_models) > 0
def test_use_changed_models_multiple_models(self) -> None:
self.set_additional_models({
"test/1": {
"a": 2,
"weight": 10
},
"test/2": {
"a": 2,
"weight": 20
},
"test/3": {
"a": 2,
"weight": 30
},
"test/4": {
"a": 3,
"weight": 1
},
})
result = self.adapter.min(
Collection("test"),
FilterOperator("a", "=", 2),
"weight",
)
assert result == 10
self.db_method_mock.assert_not_called()
self.filter_mock.assert_called()
self.add_filter_mock.assert_called()
def test_getAll(self) -> None:
fields = set(["a", "b", "c"])
collection = Collection("a")
command = commands.GetAll(collection=collection, mapped_fields=fields)
self.engine.retrieve.return_value = (
json.dumps([{
"f": 1,
"meta_deleted": False,
"meta_position": 1
}]),
200,
)
partial_models = self.db.get_all(collection=collection,
mapped_fields=list(fields))
raw_data = command.get_raw_data()
assert raw_data["collection"] == str(collection)
assert isinstance(raw_data["mapped_fields"], list)
assert set(raw_data["mapped_fields"]) == fields
assert partial_models is not None
self.engine.retrieve.assert_called()
call_args = self.engine.retrieve.call_args[0]
assert call_args[0] == "get_all"
data = json.loads(call_args[1])
assert data["collection"] == str(collection)
assert set(data["mapped_fields"]) == fields
def test_fetch_model_ADD_BEFORE_DB_onlyAdd(self) -> None:
self.init_only_add()
result = self.datastore.fetch_model(
fqid=FullQualifiedId(Collection("meeting"), 1),
mapped_fields=["name"],
)
self.assertEqual(result["name"], "meetingAdd")
class FakeModelC(Model):
collection = Collection("fake_model_c")
verbose_name = "fake model c"
id = fields.IntegerField()
meeting_id = fields.RelationField(
to={Collection("meeting"): "fake_model_b_ids"},
required=True,
)
# nested structured field
foreign_key_field = fields.RelationField(
to={Collection("fake_model_b"): "fake_model_c_ids"}, )
structured_relation_field = fields.RelationField(
to={Collection("fake_model_a"): "fake_model_c_$_ids"}, )
class FakeModelCRA(Model):
collection = Collection("fake_model_cr_a")
verbose_name = "fake model for simple field creation"
id = fields.IntegerField()
req_field = fields.IntegerField(required=True)
not_req_field = fields.IntegerField()
def test_simple_filter(self) -> None:
collection = Collection("a")
field = "f"
value = "1"
operator = "="
filter = FilterOperator(field, operator, value)
command = commands.Filter(collection=collection, filter=filter)
self.engine.retrieve.return_value = (
json.dumps(
{
"1": {"f": 1, "meta_deleted": False, "meta_position": 1},
"5": {"f": 1, "meta_deleted": False, "meta_position": 5},
"6": {"f": 1, "meta_deleted": False, "meta_position": 6},
"7": {"f": 1, "meta_deleted": False, "meta_position": 7},
}
),
200,
)
found = self.db.filter(collection=collection, filter=filter)
assert found is not None
assert command.get_raw_data() == {
"collection": str(collection),
"filter": {"field": field, "operator": operator, "value": value},
}
self.engine.retrieve.called_with("filter", command.data)
class FakeModel(Model):
"""
Fake Model for testing purposes.
"""
collection = Collection("fake_model")
verbose_name = "fake_model"
id = fields.IntegerField(required=True)
text = fields.CharField(
required=True,
constraints={"description": "The text of this fake model."})
fake_model_2_ids = fields.RelationListField(to=Collection("fake_model_2"),
related_name="relation_field")
fake_model_2_generic_ids = fields.GenericRelationListField(
to=[Collection("fake_model_2")], related_name="generic_relation_field")
def parse_collectionfield(self, collectionfield: str) -> Dict[Collection, str]:
"""
Parses the given collectionfield into its parts and returns a dict consisting of a single
respective entry.
"""
collection, field = collectionfield.split(KEYSEPARATOR)
return {Collection(collection): field}
def test_structured_relation_init(self) -> None:
with self.assertRaises(ValueError):
fields.RelationField(
to=Collection("fake_model_tahheque7O"),
related_name="invalid_related_name",
structured_relation=["invalid_structured_relation"],
)
def test_get_many(self) -> None:
fields = ["a", "b", "c"]
collection = Collection("a")
ids = [1]
gmr = GetManyRequest(collection, ids, fields)
command = commands.GetMany([gmr])
self.engine.retrieve.return_value = (
json.dumps({
"a": {
"1": {
"c": 1,
"meta_deleted": False,
"meta_position": 1
}
}
}),
200,
)
result = self.db.get_many([gmr])
assert result is not None
assert command.get_raw_data() == {
"requests": [gmr.to_dict()],
"get_deleted_models": 1,
}
self.engine.retrieve.assert_called_with("get_many", command.data)
def init_both(self) -> None:
self.set_models(
{"meeting/1": {"name": "meetingDB", "description": "descriptionDB"}}
)
self.datastore.additional_relation_models[
FullQualifiedId(Collection("meeting"), 1)
] = {"id": 1, "name": "meetingAdd"}
def test_full_qualified_field_repr(self) -> None:
fqfield = FullQualifiedField(Collection("collection_yaiS2uthi8"),
78718784720, "field_ueth3Rohv8")
self.assertEqual(
repr(fqfield),
"FullQualifiedField('collection_yaiS2uthi8/78718784720/field_ueth3Rohv8')",
)
def test_max() -> None:
collection = Collection("a")
field = "f"
value = "1"
operator = "="
filter = FilterOperator(field=field, value=value, operator=operator)
agg = db.max(collection=collection, filter=filter, field=field)
assert agg is not None
