def setup_objects(self, client):
if not client.objects.get('a'):
a_object = Object(name='a',
fields=[
NumberField(name='id',
optional=True,
default={'func': 'nextval'}),
StringField(name='name')
],
key='id',
cas=False,
objects_manager=client.objects)
b_object = Object(name='b',
key='id',
cas=False,
fields=[
NumberField(name='id',
optional=True,
default={'func': 'nextval'}),
ObjectsField(name='a_records',
link_type=LINK_TYPES.INNER,
obj=a_object)
],
objects_manager=client.objects)
self.a_object = client.objects.create(a_object)
self.b_object = client.objects.create(b_object)
self.a_record = client.records.create(
Record(self.a_object, name="A record"))
else:
self.a_object = client.objects.get('a')
self.b_object = client.objects.get('b')
self.a_record = client.records.create(
Record(self.a_object, name="A record"))
def _factory_field(cls, field_data, objects_manager):
if field_data.get('linkMeta') or field_data.get('linkMetaList'):
if field_data.get('linkMeta'):
field_data['obj'] = Object(name=field_data['linkMeta'],
cas=False,
objects_manager=objects_manager)
del field_data['linkMeta']
if field_data.get('linkMetaList'):
field_data['objs'] = [
Object(name=object_name,
cas=False,
objects_manager=objects_manager)
for object_name in field_data['linkMetaList']
]
del field_data['linkMetaList']
if field_data['type'] in ["object", "array"]:
field_data['type'] = RelatedObjectField.type
field_data['link_type'] = field_data.get('linkType')
field_data['outer_link_field'] = field_data.get('outerLinkField')
del field_data['linkType']
if field_data.get('outerLinkField'):
del field_data['outerLinkField']
return FieldsManager.get_field_by_type(
field_data['type'])(**field_data)
def test_object_with_related_outer_object_field_serializes_itself(client):
address_object = Object(name='address',
key='id',
cas=True,
fields=[
NumberField(name='id', optional=True),
StringField(name='street')
],
objects_manager=client.objects)
person_obj = Object(name='person',
key='id',
cas=True,
fields=[
NumberField(name='id', optional=True),
StringField(name='street'),
RelatedObjectField(name='addresses',
obj=address_object,
outer_link_field='address_id',
link_type=LINK_TYPES.OUTER,
many=True)
],
objects_manager=client.objects)
serialized_object = person_obj.serialize()
assert_that(serialized_object, is_(instance_of(dict)))
expected_serialized_field = {
'name': 'addresses',
'type': 'array',
'optional': False,
'linkMeta': 'address',
'linkType': 'outer',
'outerLinkField': 'address_id'
}
assert_that(serialized_object['fields'][2],
equal_to(expected_serialized_field))
def test_improper_object_operations_cause_custodian_error(
client: Client, flush_database):
assert_that(client.objects.get_all(), has_length(0))
person_obj = Object(name='person',
key='id',
cas=False,
fields=[
NumberField(name='id',
optional=True,
default={'func': 'nextval'}),
StringField(name='street')
],
objects_manager=client.objects)
client.objects.create(person_obj)
assert_that(client.objects.get_all(), has_length(1))
with pytest.raises(ObjectUpdateException) as error:
person_obj = Object(name='person',
key='id',
cas=False,
fields=[
NumberField(name='id', optional=True),
StringField(name='street')
],
objects_manager=client.objects)
client.objects.update(person_obj)
assert_that(error.value.args[0], contains_string('cannot drop sequence'))
def test_field_serialization(self, existing_person_object, client):
address_object = Object(name='address',
key='id',
cas=False,
fields=[
NumberField(name='id', optional=True),
StringField(name='street'),
ObjectsField(name='neighbours',
obj=existing_person_object,
link_type=LINK_TYPES.INNER)
],
objects_manager=client.objects)
serialized_object = address_object.serialize()
assert_that(serialized_object, is_(instance_of(dict)))
expected_serialized_field = {
'name': 'neighbours',
'type': 'objects',
'optional': False,
'linkMeta': 'person',
'linkType': 'inner'
}
assert_that(serialized_object['fields'][2],
equal_to(expected_serialized_field))
client.objects.create(address_object)
def setup_objects(self, client):
if not client.objects.get('a'):
object_a = Object(name='a',
fields=[
NumberField(name='id',
optional=True,
default={'func': 'nextval'})
],
key='id',
cas=False,
objects_manager=client.objects)
object_b = Object(name='b',
key='id',
cas=False,
fields=[
NumberField(name='id',
optional=True,
default={'func': 'nextval'}),
GenericField(name='target_object',
link_type=LINK_TYPES.INNER,
objs=[object_a]),
StringField(name='name'),
],
objects_manager=client.objects)
object_a_with_manually_set_b_set = Object(
name='a',
fields=[
NumberField(name='id',
optional=True,
default={'func': 'nextval'}),
GenericField(name='b_set',
link_type=LINK_TYPES.OUTER,
obj=object_b,
outer_link_field='target_object',
optional=True)
],
key='id',
cas=False,
objects_manager=client.objects)
client.objects.create(object_a)
self.object_b = client.objects.create(object_b)
self.object_a = client.objects.update(
object_a_with_manually_set_b_set)
a_record = Record(self.object_a)
self.a_record = client.records.create(a_record)
b_record = Record(self.object_b,
target_object={
"_object": "a",
"id": self.a_record.id
},
name="B record")
self.b_record = client.records.create(b_record)
else:
self.object_b = client.objects.get('b')
self.object_a = client.objects.get('a')
self.a_record = client.records.query(self.object_a)[0]
self.b_record = client.records.query(self.object_b)[0]
def test_client_retrieves_list_of_objects(client: Client,
person_object: Object):
with requests_mock.Mocker() as mocker:
mocker.get('/'.join([client.server_url, 'meta/']),
json={
'status': 'OK',
'data': [person_object.serialize()]
})
objs = client.objects.get_all()
assert_that(objs, has_length(1))
assert_that(person_object.serialize(), equal_to(objs[0].serialize()))
def test_client_retrieves_existing_object(person_object: Object):
client = Client(server_url='http://mocked/custodian')
with requests_mock.Mocker() as mocker:
mocker.get('http://mocked/custodian/meta/{}'.format(
person_object.name),
json={
'status': 'OK',
'data': person_object.serialize()
})
obj = client.objects.get(person_object.name)
assert_that(obj, is_(instance_of(Object)))
assert_that(person_object.serialize(), equal_to(obj.serialize()))
def test_object_serializes_itself(client):
obj = Object(name='person',
key='id',
cas=True,
fields=[
NumberField(name='id', optional=True),
StringField(name='name'),
BooleanField(name='is_active')
],
objects_manager=client.objects)
serialized_object = obj.serialize()
assert_that(serialized_object, is_(instance_of(dict)))
assert_that(serialized_object, has_entry('name', obj.name))
assert_that(serialized_object['fields'][0]['type'], equal_to('number'))
def test_client_makes_correct_request_on_object_creation(
person_object: Object, client: Client):
with requests_mock.Mocker() as mocker:
mocker.put('/'.join([client.server_url, 'meta']),
json={
'status': 'OK',
'data': person_object.serialize()
})
mocker.get('/'.join([client.server_url, 'meta', person_object.name]),
json={
'status': 'OK',
'data': person_object.serialize()
})
client.objects.create(person_object)
assert_that(person_object, is_(instance_of(Object)))
def test_client_makes_correct_request_on_object_update(person_object: Object,
client: Client):
with requests_mock.Mocker() as mocker:
mocker.post('/'.join(
[client.server_url, 'meta/{}'.format(person_object.name)]),
json={
'status': 'OK',
'data': person_object.serialize()
})
# mock preprocess request
mocker.get('/'.join(
[client.server_url, 'meta/{}'.format(person_object.name)]),
json={
'status': 'OK',
'data': person_object.serialize()
})
obj = client.objects.update(person_object)
assert_that(obj, is_(instance_of(Object)))
def test_inner_generic_field_serialization(self, client: Client):
object_a = Object(name='a',
fields=[NumberField(name='id')],
key='id',
cas=False,
objects_manager=client.objects)
object_b = Object(name='b',
key='id',
cas=False,
fields=[
NumberField(name='id', optional=True),
GenericField(name='target_object',
link_type=LINK_TYPES.INNER,
objs=[object_a])
],
objects_manager=client.objects)
object_b.fields["target_object"].objs = [object_a]
object_a_with_manually_set_b_set = Object(
name='a',
fields=[
NumberField(name='id'),
GenericField(name='b_set',
link_type=LINK_TYPES.OUTER,
obj=object_b,
outer_link_field='target_object')
],
key='id',
cas=False,
objects_manager=client.objects)
serialized_object_b = object_b.serialize()
assert_that(serialized_object_b["fields"][1],
has_entry("linkMetaList", [object_a.name]))
assert_that(serialized_object_b["fields"][1],
has_entry("type", "generic"))
assert_that(serialized_object_b["fields"][1],
has_entry("name", "target_object"))
client.objects.create(object_a)
client.objects.create(object_b)
client.objects.update(object_a_with_manually_set_b_set)
def test_client_makes_correct_request_on_object_delete(person_object: Object):
client = Client(server_url='http://mocked/custodian')
with requests_mock.Mocker() as mocker:
mocker.delete('/'.join(
[client.server_url, 'meta/{}'.format(person_object.name)]),
json={
'status': 'OK',
'data': person_object.serialize()
})
obj = client.objects.delete(person_object)
assert_that(obj, is_(instance_of(Object)))
def task_object(client, person_object):
return Object(
name='task',
key='id',
cas=False,
fields=[
IntegerField(name='id', optional=True, default={'func': 'nextval'}),
StringField(name='name'),
GenericField(name='owner', link_type=LINK_TYPES.INNER, objs=[person_object], optional=True)
],
objects_manager=client.objects
)
def test_object_is_updated(self, person_object: Object, client: Client):
"""
Add a new field to an existing object and extract the object from the database to verify that the field has
been added
:param person_object:
:param client:
"""
assert_that('last_name' not in person_object.fields.keys())
person_object.fields['last_name'] = StringField(name='last_name')
client.objects.update(person_object)
retrieved_person_obj = client.objects.get(person_object.name)
assert_that(retrieved_person_obj.fields, has_key('last_name'))
def test_actions_serialization(self, client: Client):
object_a = Object(name='a',
fields=[NumberField(name='id')],
key='id',
cas=False,
objects_manager=client.objects,
actions=[
Action(method=METHODS.CREATE,
protocol='REST',
args=["http://localhost/"],
include_values={'a': 'b.c.name'})
])
serialized_object = object_a.serialize()
assert_that(serialized_object['actions'], has_length(1))
assert_that(serialized_object['actions'][0]['method'],
equal_to(METHODS.CREATE))
assert_that(serialized_object['actions'][0]['protocol'],
equal_to('REST'))
assert_that(serialized_object['actions'][0]['args'], has_length(1))
assert_that(serialized_object['actions'][0]['includeValues'],
has_length(1))
client.objects.create(object_a)
def person_object(client):
return Object(
name='person',
key='id',
cas=False,
fields=[
IntegerField(name='id', optional=True, default={'func': 'nextval'}),
StringField(name='name'),
NumberField(name='age'),
StringField(name='street'),
BooleanField(name='is_active'),
DateTimeField(name='created_at', default={'func': 'now'}, optional=True)
],
objects_manager=client.objects
)
def test_object_with_related_inner_object_field_serializes_itself(
person_object, client):
obj = Object(name='address',
key='id',
cas=True,
fields=[
NumberField(name='id', optional=True),
StringField(name='street'),
RelatedObjectField(name='person',
obj=person_object,
link_type=LINK_TYPES.INNER)
],
objects_manager=client.objects)
serialized_object = obj.serialize()
assert_that(serialized_object, is_(instance_of(dict)))
expected_serialized_field = {
'name': 'person',
'type': 'object',
'optional': False,
'linkMeta': 'person',
'linkType': 'inner'
}
assert_that(serialized_object['fields'][2],
equal_to(expected_serialized_field))
def update(self, obj: Object) -> Object:
"""
Updates existing object in Custodian
:param obj:
:return:
"""
self._pre_process_reverse_relations(obj)
data, ok = self.client.execute(command=Command(
name=self._get_object_command_name(obj.name),
method=COMMAND_METHOD.POST),
data=obj.serialize())
if ok:
self._cache.flush()
return obj
else:
raise ObjectUpdateException(data.get('Msg'))
def factory(cls, object_data, objects_manager):
"""
Assembles object with provided data
:param object_data:
:return:
"""
fields = []
for field_data in object_data['fields']:
fields.append(cls._factory_field(field_data, objects_manager))
object_data['fields'] = fields
object_data['objects_manager'] = objects_manager
if 'actions' in object_data:
object_data['actions'] = [
Action.factory(data) for data in object_data['actions']
]
return Object(**object_data)
def test_object_is_deleted(self, person_object: Object, client: Client):
"""
Remove the object from the database and verify it not longer exists in the database
:param client:
"""
account_object = Object(name='account',
fields=[
NumberField(name='id'),
StringField(name='number'),
RelatedObjectField(
name='person',
obj=person_object,
link_type=LINK_TYPES.INNER)
],
key='id',
cas=False,
objects_manager=client.objects)
assert_that(client.objects.get('account'), instance_of(Object))
client.objects.delete(account_object)
assert_that(client.objects.get(account_object.name), is_(None))
def _split_object_by_phases(self, obj: Object):
"""
In case of referencing non-existing object split object into "safe" object and fields to add to this object later
:param obj:
:return:
"""
safe_fields = []
fields_to_add_later = []
for field in obj.fields.values():
if isinstance(field, RelatedObjectField):
# if object contains field which references the object which does not exist yet
# or if referenced object is not actual
if not self.get(field.obj.name
) or field.outer_link_field not in self.get(
field.obj.name).fields:
fields_to_add_later.append(field)
continue
safe_fields.append(field)
return Object(name=obj.name,
cas=obj.cas,
objects_manager=self,
key=obj.key,
fields=safe_fields,
actions=obj.actions), fields_to_add_later
def test_related_object_is_created(self, person_object: Object,
client: Client):
"""
Create a new object, which has a foreign key to the Person object
:param person_object:
:param client:
"""
account_object = Object(name='account',
fields=[
NumberField(name='id'),
StringField(name='number'),
RelatedObjectField(
name='person',
obj=person_object,
link_type=LINK_TYPES.INNER)
],
key='id',
cas=False,
objects_manager=client.objects)
client.objects.create(account_object)
account_object = client.objects.get(account_object.name)
assert_that(account_object, instance_of(Object))
assert_that(account_object.fields['person'],
instance_of(RelatedObjectField))
