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