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 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 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 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_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 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_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 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_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 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 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 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))