def test_can_get_connections(db, testapp): instance = PersonFactory(first_name='Wolverine') target = PersonFactory(first_name='Sabertooth') db.session.commit() ConnectionFactory(from_person_id=instance.id, to_person_id=target.id, connection_type='coworker') ConnectionFactory(from_person_id=target.id, to_person_id=instance.id, connection_type='coworker') db.session.commit() res = testapp.get('/connections') assert res.status_code == HTTPStatus.OK # assert res.json == None assert len(res.json) == 2 for item in res.json[0]['connection']: for field in EXPECTED_FIELDS: assert field in res.json[0]['connection'] for item in res.json[1]['connection']: for field in EXPECTED_FIELDS: assert field in res.json[1]['connection']
def test_patch_connection(db, testapp): person_from = PersonFactory(first_name='Sally') person_to = PersonFactory(first_name='Harry') db.session.commit() payload = { 'from_person_id': person_from.id, 'to_person_id': person_to.id, 'connection_type': 'mother', } res = testapp.post('/connections', json=payload) assert res.status_code == HTTPStatus.CREATED assert 'id' in res.json # Now Patch! payload = { 'connection_type': 'friend' } res = testapp.patch('/connections/' + str(res.json['id']), json=payload) connection = Connection.query.get(res.json['id']) assert connection is not None assert connection.from_person_id == person_from.id assert connection.to_person_id == person_to.id assert connection.connection_type.value == 'friend'
def test_update_connection_status(db, testapp): person_from = PersonFactory(first_name='Diana') person_to = PersonFactory(first_name='Harry') db.session.commit() connection = ConnectionFactory( from_person=person_from, to_person=person_to, ) db.session.commit() connection_type = 'mother' expected_connection = { 'id': connection.id, 'from_person_id': person_from.id, 'to_person_id': person_to.id, 'connection_type': connection_type, } payload = { 'connection_type': connection_type, } res = testapp.put(f'/connections/{connection.id}', json=payload) assert res.status_code == HTTPStatus.OK result_connection = res.json assert expected_connection['from_person_id'] == result_connection['from_person_id'] assert expected_connection['to_person_id'] == result_connection['to_person_id'] assert expected_connection['connection_type'] == result_connection['connection_type']
def test_get_connections(db, testapp): person_from = PersonFactory(first_name='Diana') person_to = PersonFactory(first_name='Harry') db.session.commit() ConnectionFactory( from_person=person_from, to_person=person_to, ) db.session.commit() expected_connection = { 'from_person_id': person_from.id, 'to_person_id': person_to.id, 'connection_type': 'friend', } res = testapp.get('/connections') assert res.status_code == HTTPStatus.OK assert len(res.json) == 1 result_connection = res.json[0] assert expected_connection['from_person_id'] == result_connection[ 'from_person_id'] assert expected_connection['to_person_id'] == result_connection[ 'to_person_id'] assert expected_connection['connection_type'] == result_connection[ 'connection_type']
def connection_payload(db): person_from = PersonFactory(first_name='Diana') person_to = PersonFactory(first_name='Harry') db.session.commit() return { 'connection_type': 'mother', 'from_person_id': person_from.id, 'to_person_id': person_to.id, }
def test_can_get_people_sort_asc_created_at(db, testapp): PersonFactory(created_at='3000-05-09T14:59:08+00:00') PersonFactory(created_at='1600-05-09T14:59:08+00:00') db.session.commit() res = testapp.get('/people?sort=created_at') assert res.status_code == HTTPStatus.OK assert res.json[0]['created_at'] < res.json[len(res.json) - 1]['created_at']
def test_can_get_people_sort_asc_first_name(db, testapp): PersonFactory(first_name='Aaaa') PersonFactory(first_name='Zzzz') db.session.commit() res = testapp.get('/people?sort=first_name') assert res.status_code == HTTPStatus.OK assert res.json[0]['first_name'] < res.json[len(res.json) - 1]['first_name']
def test_can_get_people(db, testapp): PersonFactory.create_batch(10) db.session.commit() res = testapp.get('/people') assert res.status_code == HTTPStatus.OK assert len(res.json) == 10 for person in res.json: for field in EXPECTED_FIELDS: assert field in person
def test_schema_validates_parent_older_than_child(db, from_dob, to_dob, conn_type, error_message): from_person = PersonFactory(date_of_birth=date(*from_dob)) to_person = PersonFactory(date_of_birth=date(*to_dob)) db.session.commit() schema = ConnectionSchema() with pytest.raises(ValidationError) as exception_info: schema.load({'from_person_id': from_person.id, 'to_person_id': to_person.id, 'connection_type': conn_type}) schema_validation_messages = exception_info.value.messages['_schema'] assert len(schema_validation_messages) == 1 assert schema_validation_messages[0] == f'Invalid connection - {error_message}.'
def test_get_mutual_friends(db, testapp): instance = PersonFactory() target = PersonFactory() # some decoy connections (not mutual) ConnectionFactory.create_batch(5, to_person=instance) ConnectionFactory.create_batch(5, to_person=target) mutual_friends = PersonFactory.create_batch(3) for f in mutual_friends: ConnectionFactory(from_person=instance, to_person=f, connection_type='friend') ConnectionFactory(from_person=target, to_person=f, connection_type='friend') # mutual connections, but not friends decoy = PersonFactory() ConnectionFactory(from_person=instance, to_person=decoy, connection_type='coworker') ConnectionFactory(from_person=target, to_person=decoy, connection_type='coworker') db.session.commit() expected_mutual_friend_ids = [f.id for f in mutual_friends] # Trigger webservice call to get mutual friends res = testapp.get('/people/' + str(instance.id) + '/mutual_friends?target_id=' + str(target.id)) assert res.status_code == HTTPStatus.OK assert len(res.json) == 3 for mutual_friend in res.json: assert mutual_friend.id in expected_mutual_friend_ids # Switch target/instance ids and make sure the resulting friends are the same res2 = testapp.get('/people/' + str(target.id) + '/mutual_friends?target_id=' + str(instance.id)) assert res2.status_code == HTTPStatus.OK assert len(res2.json) == 3 for mutual_friend in res2.json: assert mutual_friend.id in expected_mutual_friend_ids
def test_can_update_connection(db, testapp): person = ConnectionFactory(from_person=PersonFactory(), to_person_id=PersonFactory(), connection_type="friend") db.session.commit() payload = {'connection_type': 'mother'} res = testapp.patch('/connections/' + str(person.id), json=payload) assert res.status_code == HTTPStatus.OK assert 'id' in res.json assert res.json["connection_type"] == 'mother' bad_id = testapp.patch('/connections/99999444', json=payload) assert bad_id.status_code == HTTPStatus.BAD_REQUEST assert bad_id.json['description'] == 'Connection ID does not exist.'
def test_can_get_connection_by_id(db, testapp): instance = PersonFactory(first_name='Thanos') target = PersonFactory(first_name='Inevitable') db.session.commit() conn = ConnectionFactory(from_person_id=instance.id, to_person_id=target.id, connection_type='friend') db.session.commit() res = testapp.get('/connections/' + str(conn.id)) assert res.status_code == HTTPStatus.OK assert res.json['connection_type'] == conn.connection_type.value assert res.json['from_person_id'] == conn.from_person_id assert res.json['to_person_id'] == conn.to_person_id
def test_can_get_connections(db, testapp): ConnectionFactory.create_batch(5, from_person_id=PersonFactory(), to_person_id=PersonFactory()) db.session.commit() res = testapp.get('/connections') assert res.status_code == HTTPStatus.OK assert len(res.json) == 5 pprint(res.json) for connection in res.json: for field in EXPECTED_FIELDS: assert field in connection
def test_m2m_bulk_update(self): """ Bulk update on a m2m field evicts cache for related models. """ group2 = GroupFactory.create(name='group2') MembershipFactory(person=self.person, group=group2, date_joined=datetime.date(2009, 1, 1)).save() person2 = PersonFactory.create(name='person2') MembershipFactory(person=person2, group=self.group, date_joined=datetime.date(2009, 1, 1)).save() self.assertEquals( Person.objects.get(id=self.person.id).groups.order_by( 'membership__date_joined').all()[0].name, 'group1') self.assertEquals( Group.objects.get(id=self.group.id).members.order_by( 'membership__date_joined').all()[0].name, 'person1') Membership.objects.filter(group_id=group2.id).update( date_joined=datetime.date(2007, 1, 1)) self.assertEquals( Person.objects.get(id=self.person.id).groups.order_by( 'membership__date_joined').all()[0].name, 'group2') Membership.objects.filter( group_id=self.group.id, person_id=person2.id).update(date_joined=datetime.date(2006, 1, 1)) self.assertEquals( Group.objects.get(id=self.group.id).members.order_by( 'membership__date_joined').all()[0].name, 'person2')
def mock_person_with_3_books_read(db_session): person = PersonFactory.create(name="mock_pers_with_3_books_read") book1 = BookFactory(reader_id=person.id) book2 = BookFactory(reader_id=person.id) book3 = BookFactory(reader_id=person.id) yield person
def test_can_get_mutual_friends(db, testapp): instance = PersonFactory() target = PersonFactory() ConnectionFactory.create_batch(5, to_person=instance) ConnectionFactory.create_batch(5, to_person=target) mutual_friends = PersonFactory.create_batch(3) for f in mutual_friends: ConnectionFactory(from_person=instance, to_person=f, connection_type='friend') ConnectionFactory(from_person=target, to_person=f, connection_type='friend') decoy = PersonFactory() ConnectionFactory(from_person=instance, to_person=decoy, connection_type='coworker') ConnectionFactory(from_person=target, to_person=decoy, connection_type='coworker') db.session.commit() expected_mutual_friend_ids = [f.id for f in mutual_friends] res = (testapp.get('/people/{}/mutual_friends?target_id={}'.format( instance.id, target.id))) res_reverse = (testapp.get('/people/{}/mutual_friends?target_id={}'.format( target.id, instance.id))) assert res.status_code == HTTPStatus.OK assert res_reverse.status_code == HTTPStatus.OK assert len(res.json) == 3 for f in res.json: assert f['id'] in expected_mutual_friend_ids assert res.json == res_reverse.json for person in res.json: for field in EXPECTED_FIELDS: assert field in person
def test_can_get_mutual_friends(db, testapp): instance = PersonFactory() target = PersonFactory() # some decoy connections (not mutual) ConnectionFactory.create_batch(5, to_person=instance) ConnectionFactory.create_batch(5, to_person=target) mutual_friends = PersonFactory.create_batch(3) for f in mutual_friends: ConnectionFactory(from_person=instance, to_person=f, connection_type='friend') ConnectionFactory(from_person=target, to_person=f, connection_type='friend') # mutual connections, but not friends decoy = PersonFactory() ConnectionFactory(from_person=instance, to_person=decoy, connection_type='coworker') ConnectionFactory(from_person=target, to_person=decoy, connection_type='coworker') db.session.commit() res = testapp.get( f'/people/{instance.id}/mutual_friends?target_id={target.id}') assert res.status_code == HTTPStatus.OK for person in res.json: for field in EXPECTED_FIELDS: assert field in person assert len(res.json) == 3 # This might make sense as a separate test, probably ideally in the unit tests, not here switched_res = testapp.get( f'/people/{target.id}/mutual_friends?target_id={instance.id}') assert set([p['id'] for p in res.json ]) == set([p['id'] for p in switched_res.json])
def test_get_related_generic_fk_objects(self): person = PersonFactory.create() tagged_item = TaggedItemFactory.create(tag='dog-person', content_object=person) related_objects = get_related_objects(person) self.assertEqual(len(related_objects[MockTaggedItem.content_object]), 1) for tagged_item in related_objects[MockTaggedItem.content_object]: self.assertEqual(tagged_item.content_object.id, person.id)
def test_can_get_connections(db, testapp): personA = PersonFactory() personB = PersonFactory() ConnectionFactory.create_batch(10, from_person=personA, to_person=personB) db.session.commit() res = testapp.get('/connections') assert res.status_code == HTTPStatus.OK assert len(res.json) == 10 for connection in res.json: for field in EXPECTED_FIELDS: assert field in connection for p_field in PEOPLE_EXPECTED_FIELDS: assert p_field in connection['from_person'] assert p_field in connection['to_person']
def test_get_mutual_friends_correct_data(db, testapp): instance = PersonFactory() target = PersonFactory() # some decoy connections (not mutual) ConnectionFactory.create_batch(5, to_person=instance) ConnectionFactory.create_batch(5, to_person=target) mutual_friends = PersonFactory.create_batch(3) for f in mutual_friends: ConnectionFactory(from_person=instance, to_person=f, connection_type='friend') ConnectionFactory(from_person=target, to_person=f, connection_type='friend') # mutual connections, but not friends decoy = PersonFactory() ConnectionFactory(from_person=instance, to_person=decoy, connection_type='coworker') ConnectionFactory(from_person=target, to_person=decoy, connection_type='coworker') db.session.commit() # call mutual_friends endpoints res_a = testapp.get('/people/' + str(instance.id) + '/mutual_friends?target_id=' + str(target.id)) res_b = testapp.get('/people/' + str(target.id) + '/mutual_friends?target_id=' + str(instance.id)) assert res_a.status_code == HTTPStatus.OK assert res_b.status_code == HTTPStatus.OK # confirm that both calls return the same values instance_f_ids = [f['id'] for f in res_a.json] target_f_ids = [f['id'] for f in res_b.json] assert set(instance_f_ids) == set(target_f_ids)
def test_create_connection_parent_and_child_validation(db, testapp): parent = PersonFactory(date_of_birth=date(1950, 10, 1)) child = PersonFactory(date_of_birth=date(1990, 10, 1)) db.session.commit() payload = { 'from_person_id': parent.id, 'to_person_id': child.id, 'connection_type': 'son', } res = testapp.post('/connections', json=payload) assert res.status_code == HTTPStatus.BAD_REQUEST assert res.status_code == HTTPStatus.BAD_REQUEST assert res.json['description'] == 'Input failed validation.' errors = res.json['errors'] assert len(errors['_schema']) == 1 assert errors['_schema'][ 0] == 'Invalid connection - son older than parent.'
def test_can_get_connection_patch_by_id(db, testapp): instance = PersonFactory(first_name='Tony') target = PersonFactory(first_name='IronMan') db.session.commit() pre_patch_conn = ConnectionFactory(from_person_id=instance.id, to_person_id=target.id, connection_type='friend') db.session.commit() pre = testapp.get('/connections/' + str(pre_patch_conn.id)) assert pre.json['connection_type'] == 'friend' res = testapp.patch('/connections/' + str(pre_patch_conn.id) + '?connection_type=mother') assert res.status_code == HTTPStatus.OK assert res.json['id'] == pre.json['id'] assert res.json['connection_type'] == 'mother'
def test_can_create_connection(db, testapp): person_from = PersonFactory(first_name='Diana') person_to = PersonFactory(first_name='Harry') db.session.commit() payload = { 'from_person_id': person_from.id, 'to_person_id': person_to.id, 'connection_type': 'mother', } res = testapp.post('/connections', json=payload) assert res.status_code == HTTPStatus.CREATED assert 'id' in res.json connection = Connection.query.get(res.json['id']) assert connection is not None assert connection.from_person_id == person_from.id assert connection.to_person_id == person_to.id assert connection.connection_type.value == 'mother'
def test_mutual_friends(db): instance = PersonFactory() target = PersonFactory() # some decoy connections (not mutual) ConnectionFactory.create_batch(5, to_person=instance) ConnectionFactory.create_batch(5, to_person=target) mutual_friends = PersonFactory.create_batch(3) for f in mutual_friends: ConnectionFactory(from_person=instance, to_person=f, connection_type='friend') ConnectionFactory(from_person=target, to_person=f, connection_type='friend') # mutual connections, but not friends decoy = PersonFactory() ConnectionFactory(from_person=instance, to_person=decoy, connection_type='coworker') ConnectionFactory(from_person=target, to_person=decoy, connection_type='coworker') db.session.commit() expected_mutual_friend_ids = [f.id for f in mutual_friends] results = instance.mutual_friends(target) assert len(results) == 3 for f in results: assert f.id in expected_mutual_friend_ids
def test_can_get_connection_people(db, testapp): from_person = PersonFactory() to_person = PersonFactory() ConnectionFactory(from_person=from_person, to_person=to_person, connection_type=ConnectionType.friend) db.session.commit() res = testapp.get('/connections') assert res.status_code == HTTPStatus.OK # Because we're not currently tearing down between tests, this is 11 assert len(res.json) == 11 connection = res.json[10] assert connection['from_person']['id'] == from_person.id assert connection['to_person']['id'] == to_person.id assert connection['connection_type'] == ConnectionType.friend.value for field in EXPECTED_PERSON_FIELDS: assert field in connection['to_person'] assert field in connection['from_person']
def test_get_mutual_friends(db, testapp): instance = PersonFactory() target = PersonFactory() # some decoy connections (not mutual) ConnectionFactory.create_batch(5, to_person=instance) ConnectionFactory.create_batch(5, to_person=target) mutual_friends = PersonFactory.create_batch(3) for f in mutual_friends: ConnectionFactory(from_person=instance, to_person=f, connection_type='friend') ConnectionFactory(from_person=target, to_person=f, connection_type='friend') # mutual connections, but not friends decoy = PersonFactory() ConnectionFactory(from_person=instance, to_person=decoy, connection_type='coworker') ConnectionFactory(from_person=target, to_person=decoy, connection_type='coworker') db.session.commit() res = testapp.get('/people/' + str(instance.id) + '/mutual_friends?target_id=' + str(target.id)) assert res.status_code == HTTPStatus.OK for person in res.json: for field in EXPECTED_FIELDS: assert field in person
def test_get_related_fk_objects(self): person = PersonFactory.create() for i in range(3): PetFactory.create(owner=person) location = PersonLocationFactory.create(owner=person) related_objects = get_related_objects(person) self.assertEqual(len(related_objects[MockPet.owner.field]), 3) for pet in related_objects[MockPet.owner.field]: self.assertEqual(pet.owner.id, person.id) self.assertEqual(len(related_objects[MockPersonLocation.owner.field]), 1) for location in related_objects[MockPersonLocation.owner.field]: self.assertEqual(location.owner.id, person.id)
def test_m2m_bulk_update(self): """ Bulk update on a m2m field evicts cache for related models. """ group2 = GroupFactory.create(name='group2') MembershipFactory(person=self.person, group=group2, date_joined = datetime.date(2009, 1, 1)).save() person2 = PersonFactory.create(name='person2') MembershipFactory(person=person2, group=self.group, date_joined=datetime.date(2009, 1, 1)).save() self.assertEquals(Person.objects.get(id=self.person.id).groups.order_by('membership__date_joined').all()[0].name, 'group1') self.assertEquals(Group.objects.get(id=self.group.id).members.order_by('membership__date_joined').all()[0].name, 'person1') Membership.objects.filter(group_id=group2.id).update(date_joined=datetime.date(2007, 1, 1)) self.assertEquals(Person.objects.get(id=self.person.id).groups.order_by('membership__date_joined').all()[0].name, 'group2') Membership.objects.filter(group_id=self.group.id, person_id=person2.id).update(date_joined=datetime.date(2006, 1, 1)) self.assertEquals(Group.objects.get(id=self.group.id).members.order_by('membership__date_joined').all()[0].name, 'person2')
def setUp(self): subject = _subject(self) self.person = PersonFactory.build() self.subject = subject('person')
def test_m2m_add_person(self): person2 = PersonFactory.create() g = Group.objects.get(id=self.group.id) self.assertEqual(len(g.members.all()), 1) MembershipFactory(person=person2, group=self.group).save() self.assertEqual(len(g.members.all()), 2)
def setUp(self): self.person = PersonFactory.create(name='person1') self.group = GroupFactory.create(name='group1') MembershipFactory(person=self.person, group=self.group,date_joined = datetime.date(2008, 1, 1)).save()
def setUp(self): self.person = PersonFactory.build()
def setUpTestData(cls): super(ModelMapTestsMixin, cls).setUpTestData() cls.instance = PersonFactory.create() cls.field = cls.get_field() cls.model_map = cls.get_model_map()
def setUp(self): self.person = PersonFactory.create(name='person1') self.group = GroupFactory.create(name='group1') MembershipFactory(person=self.person, group=self.group, date_joined=datetime.date(2008, 1, 1)).save()