def setUp(self):
self.bran_user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.ned_user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.sansa_user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.jamie_user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.bran_actor = Actor(user_id=self.bran_user.id, name="bran")
self.bran_actor.save()
self.ned_actor = Actor(user_id=self.ned_user.id, name="ned")
self.ned_actor.save()
self.sansa_actor = Actor(user_id=self.sansa_user.id, name="sansa")
self.sansa_actor.save()
self.jamie_actor = Actor(user_id=self.jamie_user.id, name="jamie")
self.jamie_actor.save()
self.starks = Organization(name="starks")
self.starks.save()
self.lannisters = Organization(name="lannisters")
self.lannisters.save()
Membership(organization=self.starks, actor=self.bran_actor).save()
Membership(organization=self.starks, actor=self.ned_actor).save()
Membership(organization=self.starks, actor=self.sansa_actor).save()
Membership(organization=self.lannisters, actor=self.sansa_actor).save()
Membership(organization=self.lannisters, actor=self.jamie_actor).save()
class MembershipTestCase(TestCase):
def setUp(self):
self.organization = Organization()
self.organization.save()
self.actor = Actor()
self.actor.save()
self.membership = Membership()
self.membership.organization = self.organization
self.membership.actor = self.actor
self.membership.save()
def tearDown(self):
self.actor.delete()
self.organization.delete()
def test__actor__returns_actor(self):
self.assertEquals(self.membership.actor_id, self.actor.id)
self.assertEquals(self.membership.actor.id, self.actor.id)
self.assertEquals(self.organization.actors.get().id, self.actor.id)
def test__organization__returns_organization(self):
self.assertEquals(self.membership.organization_id,
self.organization.id)
self.assertEquals(self.membership.organization.id,
self.organization.id)
self.assertEquals(self.actor.organizations.get().id,
self.organization.id)
def setUp(self):
self.organization = Organization()
self.organization.save()
self.actor = Actor()
self.actor.save()
self.membership = Membership()
self.membership.organization = self.organization
self.membership.actor = self.actor
self.membership.save()
def setUp(self):
self.user = self.create_user()
self.organization1 = Organization(name="tk1")
self.organization1.save()
self.organization2 = Organization(name="tk2")
self.organization2.save()
self.organization3 = Organization(name="tk3")
self.organization3.save()
self.actor = Actor(user_id=self.user.id)
self.actor.save()
self.membership1 = Membership(organization=self.organization1,
actor=self.actor)
self.membership1.save()
self.membership2 = Membership(organization=self.organization2,
actor=self.actor)
self.membership2.save()
def test_valid(self):
"""
tests with a valid membership
:return:
"""
membership = Membership(member_id=1, organization_id=1, is_admin=True, is_owner=False, joined=True)
assert membership is not None
membership_dict = org_utils.membership_to_dict(membership)
assert membership_dict is not None
assert 'id' in membership_dict
assert membership_dict['id'] == membership.id
assert 'member_id' in membership_dict
assert membership_dict['member_id'] == membership.member_id
assert 'organization_id' in membership_dict
assert membership_dict['organization_id'] == membership.organization_id
assert 'is_owner' in membership_dict
assert membership_dict['is_owner'] == False
assert 'is_admin' in membership_dict
assert membership_dict['is_admin'] == True
assert 'joined' in membership_dict
assert membership_dict['joined'] == True
def test_invalid_type(self):
"""
Tets converting an object that isn't a membership
:return:
"""
membership = Membership(member_id=1, organization_id=1, is_admin=True, is_owner=False, joined=True)
self.assertRaises(TypeError, org_utils.shift_to_dict, membership)
def setUp(self):
db.create_all()
user = User(email='*****@*****.**',
first_name='Organization',
last_name='Owner',
password='******',
confirmed=True)
db.session.add(user)
db.session.commit()
org = Organization('Test', user.id)
db.session.add(org)
db.session.commit()
john = User(email='*****@*****.**',
first_name='John',
last_name='Doe',
password='******',
confirmed=True)
db.session.add(john)
db.session.commit()
john_membership = Membership(member_id=john.id,
organization_id=org.id,
is_owner=False,
joined=True)
db.session.add(john_membership)
db.session.commit()
position = Position(title='Test Position',
organization_id=org.id,
description='This is a description')
db.session.add(position)
db.session.commit()
shift = Shift(
position_id=position.id,
assigned_user_id=None,
start_time='2016-10-26T06:00:00',
end_time='2016-10-26T07:00:00',
description=None,
)
db.session.add(shift)
db.session.commit()
self.owner = user
self.john = john
self.john_membership = john_membership
self.organization = org
self.position = position
self.shift = shift
def invite_member(org, email, first_name, last_name):
"""
Invite a user to the organization id, creating a dummy account if needed
:param org:
:param email:
:param first_name:
:param last_name:
:return:
"""
user = User.query.filter_by(email=email).first()
return_dict = {}
if user is None:
user = User(first_name=first_name,
last_name=last_name,
email=email,
password="******",
confirmed=False)
db.session.add(user)
db.session.commit()
membership = get_membership(org, user)
if membership is not None:
return_dict['status'] = 'error'
return_dict[
'message'] = user.first_name + ' ' + user.last_name + ' is already a member of ' + org.name
return return_dict
membership = Membership(member_id=user.id, organization_id=org.id)
db.session.add(membership)
db.session.commit()
token = generate_invitation_token(user.email)
confirm_url = url_for('main.confirm_invite',
key=org.id,
token=token,
_external=True)
html = render_template('emails/invitation.html',
confirm_url=confirm_url,
user=user,
organization=org)
subject = "You've been invited to use SKEDD"
send_email(user.email, subject, html)
return_dict['status'] = 'success'
return_dict['message'] = 'You succesfully invited ' + str(
user.first_name) + ' ' + str(user.last_name) + '.'
return_dict['membership'] = membership_to_dict(membership)
return return_dict
def setUp(self):
self.bran_user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.sansa_user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.jamie_user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.bran_actor = Actor(user_id=self.bran_user.id, name="bran")
self.bran_actor.save()
self.sansa_actor = Actor(user_id=self.sansa_user.id, name="sansa")
self.sansa_actor.save()
self.jamie_actor = Actor(user_id=self.jamie_user.id, name="jamie")
self.jamie_actor.save()
self.starks = Organization(name="starks")
self.starks.save()
self.lannisters = Organization(name="lannisters")
self.lannisters.save()
Membership(organization=self.starks, actor=self.bran_actor).save()
Membership(organization=self.starks, actor=self.sansa_actor).save()
Membership(organization=self.lannisters, actor=self.sansa_actor).save()
Membership(organization=self.lannisters, actor=self.jamie_actor).save()
self.winterfell = Project(organization=self.starks, name="winterfell")
self.winterfell.save()
self.kingslanding = Project(organization=self.lannisters,
name="king's landing")
self.kingslanding.save()
self.casterlyrock = Project(organization=self.lannisters,
name="casterly rock")
self.casterlyrock.save()
def create_organization(name, owner_id):
"""
Creates a new organization with paramaters and returns the created
organization object
:param owner_id:
:param name:
:return:
"""
org = Organization(name=name, owner_id=owner_id)
db.session.add(org)
db.session.commit()
membership = Membership(member_id=owner_id,
organization_id=org.id,
is_owner=True,
is_admin=True,
joined=True)
db.session.add(membership)
db.session.commit()
return org, membership
def test_admin_of_org(self):
org = org_utils.get_organization(1)
assert org is not None
assert org.id == 1
assert org.owner_id == 1
assert org.name == 'Test'
john = org_utils.get_user(2) # john
membership = org_utils.get_membership(org, john)
assert john is not None
assert membership is not None
assert membership.is_admin == False
membership.change_admin()
jane = User(email='*****@*****.**',
first_name='Jane',
last_name='Doe',
password='******',
confirmed=True)
db.session.add(jane)
db.session.commit()
jane_membership = Membership(member_id=jane.id,
organization_id=org.id,
is_owner=False,
joined=True)
db.session.add(jane_membership)
db.session.commit()
g.user = john
does_nothing_admin(key=org.id)
g.user = jane
self.assertRaises(NotAdmin, does_nothing_admin, key=org.id)
membership.change_admin() # reset john to non-admin
def create(self, validated_data):
org = super().create(validated_data)
user = self.context['request'].user
actor = Actor.objects.get(user_id=user.id)
Membership(actor=actor, organization=org).save()
return org
class OrganizationsAPITestCase(APITestCase):
def setUp(self):
self.user = self.create_user()
self.organization1 = Organization(name="tk1")
self.organization1.save()
self.organization2 = Organization(name="tk2")
self.organization2.save()
self.organization3 = Organization(name="tk3")
self.organization3.save()
self.actor = Actor(user_id=self.user.id)
self.actor.save()
self.membership1 = Membership(organization=self.organization1,
actor=self.actor)
self.membership1.save()
self.membership2 = Membership(organization=self.organization2,
actor=self.actor)
self.membership2.save()
def create_user(self):
user = User.objects.create_user(username="******",
email="*****@*****.**",
password="******")
self.client.login(username='******', password='******')
return user
def tearDown(self):
self.actor.delete()
self.organization1.delete()
self.organization2.delete()
self.user.delete()
def test__list_organizations__lists_all_organizations_user_belongs(self):
response = self.client.get(reverse('organizations-list'))
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, [{
'id': self.organization1.id,
'name': self.organization1.name
}, {
'id': self.organization2.id,
'name': self.organization2.name
}])
def test__list_organizations__filters_on_name(self):
url = reverse('organizations-list') + '?name=tk2'
response = self.client.get(url)
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, [{
'id': self.organization2.id,
'name': self.organization2.name
}])
def test__get_organization__returns_org_if_user_belongs(self):
url = reverse('organizations-detail',
kwargs={'pk': self.organization1.id})
response = self.client.get(url)
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, {
'id': self.organization1.id,
'name': self.organization1.name
})
def test__get_organization__returns_404_if_user_doesnt_belong(self):
url = reverse('organizations-detail',
kwargs={'pk': self.organization3.id})
response = self.client.get(url)
self.assertEquals(response.status_code, status.HTTP_404_NOT_FOUND)
def test__create_organization__creates_organization(self):
url = reverse('organizations-list')
response = self.client.post(url, {'name': 'new org'})
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
self.assertEquals(response.data['name'], 'new org')
def test__patch_organization__updates_name(self):
url = reverse('organizations-detail',
kwargs={'pk': self.organization1.id})
response = self.client.patch(url, {'name': 'name1'})
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, {
'name': 'name1',
'id': self.organization1.id
})
def test__patch_organization__returns_404_if_user_doesnt_belong(self):
url = reverse('organizations-detail',
kwargs={'pk': self.organization3.id})
response = self.client.patch(url, {'name': 'name1'})
self.assertEquals(response.status_code, status.HTTP_404_NOT_FOUND)
def test__put_organization__updates_name(self):
url = reverse('organizations-detail',
kwargs={'pk': self.organization1.id})
response = self.client.put(url, {'name': 'name1'})
self.assertEquals(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, {
'name': 'name1',
'id': self.organization1.id
})
def test__put_organization__returns_404_if_user_doesnt_belong(self):
url = reverse('organizations-detail',
kwargs={'pk': self.organization3.id})
response = self.client.put(url, {'name': 'name1'})
self.assertEquals(response.status_code, status.HTTP_404_NOT_FOUND)
def test__delete_organization__deletes_org(self):
url = reverse('organizations-detail',
kwargs={'pk': self.organization1.id})
response = self.client.delete(url)
self.assertEquals(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEquals(
Organization.objects.filter(pk=self.organization1.id).count(), 0)
def test__delete_organization__returns_404_if_user_doesnt_belong(self):
url = reverse('organizations-detail',
kwargs={'pk': self.organization3.id})
response = self.client.delete(url, {'name': 'name1'})
self.assertEquals(response.status_code, status.HTTP_404_NOT_FOUND)