コード例 #1
0
 def test_slice(self, client: Client):
     client.records.delete(*[x for x in client.records.query('person')])
     assert_that(client.records.query('person'), has_length(0))
     client.records.create(
         Record(obj='person',
                **{
                    'name': 'Feodor',
                    'is_active': True,
                    'age': 23,
                    'street': 'street'
                }),
         Record(obj='person',
                **{
                    'name': 'Victor',
                    'is_active': False,
                    'age': 22,
                    'street': 'street'
                }),
         Record(obj='person',
                **{
                    'name': 'Artem',
                    'is_active': True,
                    'age': 35,
                    'street': 'street'
                }),
         Record(obj='person',
                **{
                    'name': 'Anton',
                    'is_active': False,
                    'age': 55,
                    'street': 'street'
                }))
     assert_that(client.records.query('person'), has_length(4))
     two_first_records = client.records.query('person')[:2]
     assert_that(two_first_records, has_length(2))
コード例 #2
0
def test_client_returns_list_of_records_on_bulk_update(person_object: Object,
                                                       client: Client):
    records_to_update = [
        Record(obj=person_object,
               name='Ivan Petrov',
               is_active=False,
               age=15,
               id=23,
               street=""),
        Record(obj=person_object,
               name='Nikolay Kozlov',
               is_active=True,
               age=44,
               id=34,
               street="")
    ]

    with requests_mock.Mocker() as mocker:
        mocker.post('/'.join(
            [client.server_url, 'data/bulk/{}'.format(person_object.name)]),
                    json={
                        'status': 'OK',
                        'data': [x.serialize() for x in records_to_update]
                    })
        updated_records = client.records.bulk_update(*records_to_update)
        for updated_record in updated_records:
            assert_that(updated_record, instance_of(Record))
            assert_that(updated_record.name)
        assert_that(updated_records, equal_to(records_to_update))
コード例 #3
0
def test_client_returns_list_of_records_on_bulk_create(person_object: Object,
                                                       client: Client):
    records_to_create = [
        Record(obj=person_object,
               name='Ivan Petrov',
               is_active=False,
               street="street",
               age=42),
        Record(obj=person_object,
               name='Nikolay Kozlov',
               is_active=True,
               street="street",
               age=36)
    ]

    with requests_mock.Mocker() as mocker:
        mocker.put('/'.join(
            [client.server_url, 'data/bulk/{}'.format(person_object.name)]),
                   json={
                       'status':
                       'OK',
                       'data': [{
                           **x.serialize(),
                           **{
                               'id': records_to_create.index(x) + 1
                           }
                       } for x in records_to_create]
                   })
        created_records = client.records.bulk_create(*records_to_create)
        for created_record in created_records:
            assert_that(created_record, instance_of(Record))
            assert_that(created_record.name)
コード例 #4
0
 def test_records_are_created(self, person_object: Object, client: Client):
     """
     Create two records and verify pk values are assigned
     :param person_object:
     :param client:
     """
     first_record = Record(obj=person_object,
                           **{
                               'name': 'Feodor',
                               'is_active': True,
                               'age': 23,
                               "street": "St"
                           })
     second_record = Record(obj=person_object,
                            **{
                                'name': 'Victor',
                                'is_active': False,
                                'age': 22,
                                "street": "St"
                            })
     first_record, second_record = client.records.bulk_create(
         first_record, second_record)
     assert_that(first_record.get_pk(), instance_of(int))
     assert_that(second_record.get_pk(), instance_of(int))
     self._created_records = (first_record, second_record)
コード例 #5
0
    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"))
コード例 #6
0
    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]
コード例 #7
0
def two_records(client, existing_person_object):
    client.records.bulk_delete(*[x for x in client.records.query(existing_person_object)])
    first_record = Record(obj=existing_person_object,
                          **{'name': 'Feodor', 'is_active': True, 'age': 20, 'street': 'street'})
    second_record = Record(obj=existing_person_object,
                           **{'name': 'Victor', 'is_active': False, 'age': 40, 'street': 'street'})
    first_record, second_record = client.records.bulk_create(first_record, second_record)
    return first_record, second_record
コード例 #8
0
def test_client_returns_list_of_records_without_pk_value_on_bulk_delete(
        client: Client):
    records_to_delete = [
        Record(obj='person', name='Ivan Petrov', is_active=False, id=23),
        Record(obj='person', name='Nikolay Kozlov', is_active=True, id=34)
    ]

    with requests_mock.Mocker() as mocker:
        mocker.delete('/'.join([client.server_url, 'data/person']),
                      json={'status': 'OK'})
        client.records.delete(*records_to_delete)
        for record in records_to_delete:
            assert_that(not record.exists())
コード例 #9
0
ファイル: conftest.py プロジェクト: kirpastuhov/trood-sdk
def two_records(client):
    client.records.delete(*[x for x in client.records.query('person')])
    first_record = Record(obj='person',
                          **{
                              'name': 'Feodor',
                              'is_active': True,
                              'age': 20,
                              'street': 'street'
                          })
    second_record = Record(obj='person',
                           **{
                               'name': 'Victor',
                               'is_active': False,
                               'age': 40,
                               'street': 'street'
                           })
    first_record, second_record = client.records.create(
        first_record, second_record)
    return first_record, second_record
コード例 #10
0
 def get(self, obj_name: str, record_id: str, **kwargs):
     """
     Retrieves an existing record from Custodian
     :param obj_name:
     :param record_id:
     """
     data, ok = self.client.execute(
         command=Command(name=self._get_record_command_name(obj_name, record_id), method=COMMAND_METHOD.GET),
         params=kwargs
     )
     return Record(obj_name, **data) if ok else None
コード例 #11
0
    def test_field_value_creation_and_retrieving_with_nested_record_as_object_and_depth_set_to_2(
            self, client: Client):
        self.setup_objects(client)
        b_record = Record(self.b_object, a_records=[self.a_record])

        # create and check value with depth set to 2
        b_record_with_depth_set_to_2 = client.records.create(b_record, depth=2)
        assert_that(b_record_with_depth_set_to_2.a_records, instance_of(list))
        assert_that(b_record_with_depth_set_to_2.a_records, has_length(1))
        assert_that(b_record_with_depth_set_to_2.a_records[0],
                    instance_of(Record))
コード例 #12
0
    def test_field_value_serializing_with_nested_record_as_array_of_ids(
            self, client: Client):
        self.setup_objects(client)
        b_record = Record(self.b_object, a_records=[self.a_record])

        # create and check value with depth set to 1
        b_record_with_depth_set_to_1 = client.records.create(b_record)

        serialized_data = b_record_with_depth_set_to_1.serialize()
        assert_that(serialized_data['a_records'], has_length(1))
        assert_that(serialized_data['a_records'][0], instance_of(float))
コード例 #13
0
def test_client_updates_record_with_partial_data(existing_person_object: Object, client: Client):
    record = Record(obj=existing_person_object, id=23, age=20, name='Ivan', is_active=True, street="Street")
    record = client.records.create(record=record)
    assert_that(record, instance_of(Record))

    # perform partial update
    record = client.records.partial_update(existing_person_object, record.get_pk(), {'name': 'Petr'})
    assert_that(record.name, equal_to('Petr'))

    # check that new data got stored in Custodian
    record = client.records.get(existing_person_object, record.get_pk())
    assert_that(record.name, equal_to('Petr'))
コード例 #14
0
    def create(self, *records: Record, **kwargs):
        """
        Creates new records in the Custodian.
        :param records:
        """
        requests_data = self._get_request_data(*records)
        self._check_records_have_same_object(*records)
        obj = records[0].obj
        data, ok = self.client.execute(
            command=Command(name=self._get_record_command_name(obj), method=COMMAND_METHOD.POST),
            data=requests_data, params=kwargs
        )
        records = []
        if ok:
            if isinstance(data, dict):
                return Record(obj, **data)

            elif isinstance(data, list):
                return [Record(obj, **d) for d in data]

        elif data.get('Msg', '').find('duplicate') != -1:
            raise RecordAlreadyExistsException
        else:
            raise CommandExecutionFailureException(data.get('Msg'))
コード例 #15
0
ファイル: test_serialization.py プロジェクト: orn0t/trood-sdk
    def test_record_is_serialized_with_generic_field_value(self, task_object: Object, person_object: Object):
        """
        Create two records and verify pk values are assigned
        :param person_object:
        :param client:
        """

        task_record = Record(
            task_object,
            **{'name': 'Some task', 'owner': {"_object": person_object.name, person_object.key: 5}}
        )
        data = task_record.serialize()
        assert_that(data, instance_of(dict))
        assert_that(data, has_entry('name', 'Some task'))
        assert_that(data, has_entry('owner', {'_object': person_object.name, person_object.key: 5}))
コード例 #16
0
ファイル: manager.py プロジェクト: orn0t/trood-sdk
 def update(self, record: Record, **kwargs):
     """
     Updates an existing record in the Custodian
     """
     data, ok = self.client.execute(command=Command(
         name=self._get_record_command_name(record.obj, record.get_pk()),
         method=COMMAND_METHOD.PATCH),
                                    data=record.serialize(),
                                    params=kwargs)
     if ok:
         return Record(obj=record.obj, **data)
     else:
         if data.get('code') == 'cas_failed':
             raise CasFailureException(data.get('Msg', ''))
         else:
             raise RecordUpdateException(data.get('Msg', ''))
コード例 #17
0
    def factory(cls, obj, **raw_data):
        from trood.api.custodian.records.model import Record
        values = {}
        # Use meta fields only if object is evaluated
        if obj._evaluated:
            for field_name in obj.fields.keys():
                if field_name in raw_data:
                    field = obj.fields[field_name]
                    if field_name in obj.fields:
                        values[field_name] = cls.factory_field_value(field, raw_data[field_name])
        else:
            values = raw_data

        record = Record(obj, _factory_mode=True)
        for key, value in values.items():
            setattr(record, key, value)
        return record
コード例 #18
0
    def _query(self, obj_name: str, query_string: str, **kwargs):
        """
        Performs an Custodian API call and returns a list of records
        :param obj_name:
        :param query_string:
        """
        if kwargs.get("omit_outers", None) is False:
            del kwargs['omit_outers']
        data, _ = self.client.execute(
            command=Command(name=self._get_record_command_name(obj_name), method=COMMAND_METHOD.GET),
            params={'q': query_string, **kwargs}
        )

        records = []
        for record_data in data:
            records.append(Record(obj_name, **record_data))
        return records
コード例 #19
0
ファイル: manager.py プロジェクト: orn0t/trood-sdk
 def partial_update(self, obj: Object, pk, values, **kwargs):
     """
     Performs partial update of existing record
     """
     self._validation_class.validate_partial(obj, values)
     data, ok = self.client.execute(
         command=Command(name=self._get_record_command_name(obj, pk),
                         method=COMMAND_METHOD.PATCH),
         data=self._serialization_class.serialize(obj, values),
         params=kwargs)
     if ok:
         return Record(obj=obj, **data)
     else:
         if data.get('code') == 'cas_failed':
             raise CasFailureException(data.get('Msg', ''))
         else:
             raise RecordUpdateException(data.get('Msg', ''))
コード例 #20
0
ファイル: manager.py プロジェクト: orn0t/trood-sdk
 def create(self, record: Record, **kwargs) -> Record:
     """
     Creates a new record in the Custodian
     :param record:
     :return:
     """
     data, ok = self.client.execute(command=Command(
         name=self._get_record_command_name(record.obj),
         method=COMMAND_METHOD.POST),
                                    data=record.serialize(),
                                    params=kwargs)
     if ok:
         return Record(obj=record.obj, **data)
     elif data.get('Msg', '').find('duplicate') != -1:
         raise RecordAlreadyExistsException
     else:
         raise CommandExecutionFailureException(data.get('Msg'))
コード例 #21
0
 def partial_update(self, obj_name: str, pk, values, **kwargs):
     """
     Performs partial update of existing record
     :param obj_name:        
     """
     data, ok = self.client.execute(
         command=Command(name=self._get_record_command_name(obj_name, pk),
                         method=COMMAND_METHOD.PATCH),
         data=values,
         params=kwargs
     )
     if ok:
         return Record(obj_name, **data)
     else:
         if data.get('code') == 'cas_failed':
             raise CasFailureException(data.get('Msg', ''))
         else:
             raise RecordUpdateException(data.get('Msg', ''))
コード例 #22
0
ファイル: manager.py プロジェクト: orn0t/trood-sdk
 def bulk_create(self, *records: Record):
     """
     Creates new records in the Custodian
     :param records:
     :return:
     """
     self._check_records_have_same_object(*records)
     obj = records[0].obj
     data, ok = self.client.execute(
         command=Command(name=self._get_record_command_name(obj),
                         method=COMMAND_METHOD.POST),
         data=[record.serialize() for record in records])
     records = []
     if ok:
         for i in range(0, len(data)):
             records.append(Record(obj, **data[i]))
         return list(records)
     else:
         raise CommandExecutionFailureException(data.get('Msg'))
コード例 #23
0
 def test_datetime_field_handled_right(self, person_object: Object,
                                       client: Client):
     """
     Create two records and verify pk values are assigned
     :param person_object:
     :param client:
     """
     first_record = Record(obj=person_object,
                           **{
                               'name':
                               'Feodor',
                               'is_active':
                               True,
                               'age':
                               23,
                               "street":
                               "St",
                               "created_at":
                               datetime.datetime.now() +
                               datetime.timedelta(days=4)
                           })
     first_record = client.records.create(first_record)
     assert_that(first_record.created_at, instance_of(datetime.datetime))
コード例 #24
0
def person_record(person_object):
    return Record(obj=person_object, id=23, age=20, name='Ivan', is_active=True, street="Street")
コード例 #25
0
ファイル: conftest.py プロジェクト: kirpastuhov/trood-sdk
def person_record():
    return Record(obj='person',
                  age=20,
                  name='Ivan',
                  is_active=True,
                  street="Street")