def test_make(self):
"""Test make method."""
invite_institution = InviteInstitution.create(self.data)
invite_institution.put()
stub_institution = invite_institution.stub_institution_key.get()
maked_invite = invite_institution.make()
expected_maked_invite = {
'admin_name':
self.admin.name,
'sender_name':
self.invite.sender_name,
'key':
invite_institution.key.urlsafe(),
'status':
self.invite.status,
'institution_admin':
self.institution.make(["name"]),
'institution':
self.institution.make(InviteInstitution.INST_PROPS_TO_MAKE),
'invitee':
self.user.email[0],
'suggestion_institution_name':
'new Institution',
'stub_institution':
stub_institution.make(['name', 'key', 'state']),
'type_of_invite':
'INSTITUTION'
}
self.assertEquals(
maked_invite, expected_maked_invite,
"The maked invite should be equal to the expected one")
def test_patch_with_a_wrong_invite(self, verify_token):
"""Test patch with a wrong invite."""
data = {
'invitee': '*****@*****.**',
'admin_key': self.user_admin.key.urlsafe(),
'institution_key': self.inst_test.key.urlsafe(),
'suggestion_institution_name': 'test',
'type_of_invite': 'INSTITUTION'
}
self.invite = InviteInstitution.create(data)
self.invite.put()
with self.assertRaises(Exception) as raises_context:
self.testapp.patch('/api/invites/user/%s' %
self.invite.key.urlsafe())
message_exception = self.get_message_exception(
str(raises_context.exception))
invite_class_name = self.invite.__class__.__name__
expected_message = "Error! The invite's type is %s, but InviteUser is the expected one" % invite_class_name
self.assertEqual(
message_exception, expected_message,
"Expected exception message must be equal to %s" %
expected_message)
def setUp(cls):
"""Provide the base for the tests."""
super(InviteInstitutionHandlerTest, cls).setUp()
app = cls.webapp2.WSGIApplication(
[(InviteInstitutionHandlerTest.INVITE_INSTITUTION_URI, InviteInstitutionHandler),
], debug=True)
cls.testapp = cls.webtest.TestApp(app)
# create models
# new User
cls.user_admin = mocks.create_user('*****@*****.**')
# Other user
cls.other_user = mocks.create_user('*****@*****.**')
# new Institution inst test
cls.inst_test = mocks.create_institution()
cls.inst_test.admin = cls.user_admin.key
cls.inst_test.state = "active"
cls.inst_test.put()
# New invite user
cls.data = {
'invitee': '*****@*****.**',
'admin_key': cls.user_admin.key.urlsafe(),
'institution_key': cls.inst_test.key.urlsafe(),
'suggestion_institution_name': 'test'
}
cls.invite = InviteInstitution.create(cls.data)
cls.invite.put()
def get(self, user):
"""Get all invite whose type is institution."""
invites = []
queryInvites = InviteInstitution.query()
invites = [invite.make() for invite in queryInvites]
self.response.write(json.dumps(invites))
def test_create_accept_notification(self, mock_method):
"""Test create a regular accept response notification."""
invite = InviteInstitution.create(self.data)
invite.put()
self.user.current_institution = self.institution.key
self.user.put()
id = invite.create_accept_response_notification(
'ACCEPT_INVITE_INSTITUTION', self.institution.key,
invite.admin_key.urlsafe(), self.user)
mock_method.assert_called()
self.assertTrue(id != None)
def test_create_system_notification(self, mock_method):
"""Test create a system notification."""
invite = InviteInstitution.create(self.data)
invite.put()
self.user.current_institution = self.institution.key
self.user.put()
id = invite.create_accept_response_notification(
'ADD_ADM_PERMISSIONS', self.institution.key,
self.user.key.urlsafe())
mock_method.assert_called()
self.assertTrue(id != None)
def test_delete(self, verify_token, send_notification):
"""Test method delete of InviteInstitutionHandler."""
invite_institution = InviteInstitution.create(self.data)
invite_institution.put()
self.testapp.delete('/api/invites/institution/%s' %
invite_institution.key.urlsafe())
invite_institution = invite_institution.key.get()
self.assertTrue(invite_institution.status == "rejected")
# assert the notification was sent
send_notification.assert_called()
def test_add_admin_permission_in_institution_hierarchy(
self, verify_token, enqueue_task):
"""Test add admin permissions in institution hierarchy."""
first_user = mocks.create_user()
second_user = mocks.create_user()
third_user = mocks.create_user()
first_inst = mocks.create_institution()
second_inst = mocks.create_institution()
third_inst = mocks.create_institution()
first_inst.admin = first_user.key
second_inst.admin = second_user.key
third_inst.admin = third_user.key
first_user.institutions_admin.append(first_inst.key)
second_user.institutions_admin.append(second_inst.key)
third_user.institutions_admin.append(third_inst.key)
second_inst.parent_institution = first_inst.key
third_inst.parent_institution = second_inst.key
first_inst.children_institutions.append(second_inst.key)
second_inst.children_institutions.append(third_inst.key)
first_inst.put()
second_inst.put()
third_inst.put()
first_user.put()
second_user.put()
third_user.put()
invite = InviteInstitution()
invite.invitee = third_user.email[0]
invite.institution_key = third_inst.key
invite.admin_key = second_user.key
invite.stub_institution_key = third_inst.key
invite.put()
verify_token._mock_return_value = {'email': third_user.email[0]}
enqueue_task.side_effect = self.enqueue_task
self.assertEqual(first_user.permissions, {})
self.assertEqual(second_user.permissions, {})
self.assertEqual(third_user.permissions, {})
self.body['data'] = {'sender_name': 'user name updated'}
self.testapp.put_json(
"/api/institutions/%s/invites/%s" %
(third_inst.key.urlsafe(), invite.key.urlsafe()), self.body)
first_user = first_user.key.get()
second_user = second_user.key.get()
third_user = third_user.key.get()
self.assertTrue(
has_permissions(third_user, third_inst.key.urlsafe(),
permissions.DEFAULT_ADMIN_PERMISSIONS))
self.assertTrue(
has_permissions(second_user, third_inst.key.urlsafe(),
permissions.DEFAULT_ADMIN_PERMISSIONS))
def setUp(cls):
"""Provide the base for the tests."""
super(InstitutionHandlerTest, cls).setUp()
methods = set(cls.webapp2.WSGIApplication.allowed_methods)
methods.add('PATCH')
cls.webapp2.WSGIApplication.allowed_methods = frozenset(methods)
app = cls.webapp2.WSGIApplication(
[("/api/institutions/(.*)/invites/(.*)", InstitutionHandler),
("/api/institutions/(.*)", InstitutionHandler),
("/api/queue/add-admin-permissions",
AddAdminPermissionsInInstitutionHierarchy),
('/api/queue/remove-admin-permissions',
RemoveAdminPermissionsInInstitutionHierarchy),
('/api/queue/remove-inst', RemoveInstitutionHandler)],
debug=True)
cls.testapp = cls.webtest.TestApp(app)
# create models
# new User
cls.user = mocks.create_user('*****@*****.**')
cls.user.name = "User"
# new User Other
cls.other_user = mocks.create_user('*****@*****.**')
cls.other_user.state = "pending"
cls.other_user.put()
# new Institution FIRST INST
cls.first_inst = mocks.create_institution()
cls.first_inst.name = 'FIRST INST'
cls.first_inst.acronym = 'FIRST INST'
cls.first_inst.cnpj = '18.104.068/0001-86'
cls.first_inst.email = '*****@*****.**'
cls.first_inst.members = [cls.user.key, cls.other_user.key]
cls.first_inst.followers = [cls.user.key, cls.other_user.key]
cls.first_inst.admin = cls.user.key
cls.first_inst.put()
cls.user.institutions_admin = [cls.first_inst.key]
cls.user.institutions = [cls.first_inst.key]
cls.user.follows = [cls.first_inst.key]
cls.user.add_permission("update_inst", cls.first_inst.key.urlsafe())
cls.user.add_permission("remove_inst", cls.first_inst.key.urlsafe())
cls.user.put()
# new Institution SECOND INST
cls.second_inst = mocks.create_institution()
cls.second_inst.name = 'SECOND INST'
cls.second_inst.acronym = 'SECOND INST'
cls.second_inst.cnpj = '18.104.068/0000-86'
cls.second_inst.email = '*****@*****.**'
cls.second_inst.members = [cls.user.key, cls.other_user.key]
cls.second_inst.followers = [cls.user.key, cls.other_user.key]
cls.second_inst.posts = []
cls.second_inst.admin = None
cls.second_inst.put()
# Invite for Other create new inst
cls.invite = InviteInstitution()
cls.invite.invitee = '*****@*****.**'
cls.invite.institution_key = cls.second_inst.key
cls.invite.admin_key = cls.user.key
cls.invite.type_of_invite = 'institution'
cls.invite.suggestion_institution_name = "Nova Inst"
cls.invite.put()
# Stub of Institution
cls.stub = Institution()
cls.stub.name = 'Nova Inst'
cls.stub.state = 'pending'
cls.stub.put()
# update invite
cls.invite.stub_institution_key = cls.stub.key
cls.invite.put()
# new Institution ECIS
cls.third_inst = mocks.create_institution()
cls.third_inst.members = [cls.user.key, cls.other_user.key]
cls.other_user.add_institution(cls.third_inst.key)
cls.other_user.follows.append(cls.third_inst.key)
cls.third_inst.followers = [cls.user.key, cls.other_user.key]
cls.third_inst.admin = cls.other_user.key
cls.third_inst.parent_institution = cls.second_inst.key
cls.third_inst.put()
cls.second_inst.children_institutions.append(cls.third_inst.key)
cls.second_inst.put()
# method post body
cls.body = {'data': None}
# create headers
cls.headers = {
'Institution-Authorization': cls.first_inst.key.urlsafe()
}
def test_create(self):
"""Test create method."""
created_invite = InviteInstitution.create(self.data)
stub_institution_key = created_invite.stub_institution_key
expected_invite = InviteInstitution()
expected_invite.admin_key = self.admin.key
expected_invite.is_request = False
expected_invite.institution_key = self.institution.key
expected_invite.sender_key = self.admin.key
expected_invite.sender_name = self.admin.name
expected_invite.invitee = self.user.email[0]
expected_invite.suggestion_institution_name = "new Institution"
expected_invite.stub_institution_key = stub_institution_key
self.assertEquals(
created_invite, expected_invite,
"The created invite should be equal to the expected one")
def test_check_is_invite_institution_valid(self):
"""Test check_is_invite_institution_valid method."""
with self.assertRaises(FieldException):
data = {"suggestion_institution_name": None}
InviteInstitution.check_is_invite_institution_valid(data)
