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