def setUp(self):
password = '******'
self.admin = UserFactory(is_admin=True,
email='*****@*****.**',
password=password,
first_name='admin',
last_name='brt')
self.user = UserFactory(email='*****@*****.**',
password=password,
first_name='nonny',
last_name='amadi',
is_admin=False)
def setUp(self):
password = '******'
self.admin = UserFactory(is_admin=True,
email='*****@*****.**',
password=password,
first_name='admin',
last_name='brt',
is_staff=True)
self.user = UserFactory(email='*****@*****.**',
password=password,
first_name='nonny',
last_name='amadi',
is_admin=False)
admin_token = self._login(
dict(email=self.admin.email,
password=password)).data['data']['token']
self._admin_header = self._auth_header(admin_token)
token = self._login(dict(email=self.user.email,
password=password)).data['data']['token']
self._header = self._auth_header(token)
self._bus_data = {
"number_plate": "EMX5000M",
"manufacturer": "Toyota",
"model": "Hiace",
"year": "2020",
"capacity": 20
}
self._bus_data_two = {
"number_plate": "AJM120P",
"manufacturer": "Honda",
"model": "Pilot",
"year": "2010",
"capacity": 18
}
self._bus_data_three = {
"number_plate": "RMD120P",
"manufacturer": "Honda",
"model": "Pilot",
"year": "2010",
"capacity": 18
}
self.buses = BusFactory(**self._bus_data_two)
def test_update_ticket_permission_denied(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
payload = {
'title': 'Some Title',
'body': 'Some Body',
'due_date': '2021-01-01',
}
with patch.object(PermissionsService,
'get_ticket_permissions',
return_value=Permissions.with_read_permissions()
) as mocked_get_ticket_permissions:
response = api_client.patch('/api/v1/tickets/1',
data=payload,
format='json')
self.assertEqual(response.status_code, 403)
expected_response = {
'error_code': PermissionDeniedException.code,
'error_message': PermissionDeniedException.message,
}
mocked_get_ticket_permissions.assert_called_with(
user_id=user.id,
ticket_id=1,
)
self.assertDictEqual(response.data, expected_response)
def test_create_ticket(self):
api_client = APIClient()
user = UserFactory()
payload = {
'category_id': 1,
}
api_client.force_authenticate(user=user)
ticket = TicketFactory()
with \
patch.object(
PermissionsService,
'get_category_permissions',
return_value=Permissions.with_mutate_permissions(),
) as mocked_get_permissions, \
patch.object(TicketService, 'create_ticket', return_value=ticket) as mocked_create_ticket:
response = api_client.post('/api/v1/tickets',
data=payload,
format='json')
self.assertEqual(response.status_code, 201)
mocked_get_permissions.assert_called_with(
user_id=user.id,
category_id=payload['category_id'],
)
mocked_create_ticket.assert_called_with(
category_id=payload['category_id'], )
expected_response = {
'id': str(ticket.id),
'category_id': str(ticket.category_id),
'priority': ticket.priority,
}
self.assertDictEqual(response.data, expected_response)
def setUp(self):
self.resource_url = reverse("token-refresh-time")
self.user = UserFactory()
self.payload = {"foo": "bar"}
self.headers = {"HTTP_AUTHORIZATION": "Bearer some_token"}
def test_create_ticket_category_not_found(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
payload = {
'category_id': 1,
}
with \
patch.object(
PermissionsService,
'get_category_permissions',
return_value=Permissions.with_mutate_permissions(),
) as mocked_get_permissions, \
patch.object(TicketService, 'create_ticket', side_effect=CategoryNotFoundException) \
as mocked_create_ticket:
response = api_client.post('/api/v1/tickets',
data=payload,
format='json')
self.assertEqual(response.status_code, 400)
expected_response = {
'error_code': CategoryNotFoundException.code,
'error_message': CategoryNotFoundException.message,
}
mocked_get_permissions.assert_called_with(
category_id=payload['category_id'],
user_id=user.id,
)
mocked_create_ticket.assert_called_with(
category_id=payload['category_id'], )
self.assertDictEqual(response.data, expected_response)
def test_create_invite_permission_denied(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
payload = {
'organization_id': 1,
'email': '*****@*****.**',
'message': 'message',
}
with \
patch.object(
PermissionsService,
'get_organization_permissions',
return_value=Permissions.with_no_permissions(),
) as mocked_get_permissions, \
patch.object(OrganizationInviteService, 'create_organization_invite') as mocked_send_invite:
response = api_client.post('/api/v1/organization-invites', data=payload, format='json')
self.assertEqual(response.status_code, 403)
expected_response = {
'error_code': PermissionDeniedException.code,
'error_message': PermissionDeniedException.message,
}
mocked_get_permissions.assert_called_with(
user_id=user.id,
organization_id=payload['organization_id'],
)
mocked_send_invite.assert_not_called()
self.assertDictEqual(response.data, expected_response)
def test_create_board_membership_permission_denied(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
with \
patch.object(
PermissionsService,
'get_board_membership_permissions',
return_value=Permissions.with_mutate_permissions(),
) as mocked_get_permissions, \
patch.object(BoardMembershipService, 'delete_board_membership') as mocked_delete_member:
response = api_client.delete('/api/v1/board-memberships/1')
self.assertEqual(response.status_code, 403)
mocked_get_permissions.assert_called_with(
user_id=user.id,
board_membership_id=1,
)
mocked_delete_member.assert_not_called()
expected_response = {
'error_code': PermissionDeniedException.code,
'error_message': PermissionDeniedException.message,
}
self.assertDictEqual(response.data, expected_response)
def test_accept_or_decline_invite_already_a_member(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
payload = {'accept': True}
with \
patch.object(
PermissionsService,
'get_organization_invite_permissions',
return_value=Permissions.with_all_permissions(),
) as mocked_get_permissions, \
patch.object(
OrganizationInviteService,
'accept_or_decline_invite',
side_effect=OrganizationMembershipAlreadyExistsException
) as mocked_accept_or_decline_invite:
response = api_client.patch(f'/api/v1/organization-invites/42', data=payload, format='json')
self.assertEqual(response.status_code, 400)
mocked_get_permissions.assert_called_with(
organization_invite_id=42,
user_id=user.id,
)
mocked_accept_or_decline_invite.assert_called_with(
organization_invite_id=42,
accept=payload['accept'],
)
expected_response = {
'error_code': OrganizationMembershipAlreadyExistsException.code,
'error_message': OrganizationMembershipAlreadyExistsException.message,
}
self.assertDictEqual(response.data, expected_response)
def test_create_ticket_assignment_request_not_valid(self):
payload = {
'extra_argument': 42,
'ticket_id': 'not-an-integer',
}
api_client = APIClient()
api_client.force_authenticate(user=UserFactory())
response = api_client.post('/api/v1/ticket-assignments', data=payload, format='json')
self.assertEqual(response.status_code, 400)
expected_response = {
'error_code': APIRequestValidationException.code,
'error_message': APIRequestValidationException.message,
'error_details': {
"ticket_id": [
"A valid integer is required."
],
"board_membership_id": [
"This field is required."
],
}
}
self.assertDictEqual(response.data, expected_response)
def test_delete_ticket_assignment_ticket_assignment_not_found(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
with \
patch.object(
PermissionsService,
'get_ticket_assignment_permissions',
return_value=Permissions.with_all_permissions(),
) as mocked_get_permissions, \
patch.object(
TicketAssignmentService,
'delete_ticket_assignment',
side_effect=TicketAssignmentNotFoundException,
) as mocked_unassign_member:
response = api_client.delete('/api/v1/ticket-assignments/1')
self.assertEqual(response.status_code, 400)
expected_response = {
'error_code': TicketAssignmentNotFoundException.code,
'error_message': TicketAssignmentNotFoundException.message,
}
mocked_get_permissions.assert_called_with(
ticket_assignment_id=1,
user_id=user.id,
)
mocked_unassign_member.assert_called_with(
ticket_assignment_id=1,
)
self.assertDictEqual(response.data, expected_response)
def test_create_ticket_assignment_permission_denied(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
payload = {
'ticket_id': 1,
'board_membership_id': 1,
}
with \
patch.object(
PermissionsService,
'get_ticket_permissions',
return_value=Permissions.with_read_permissions(),
) as mocked_get_permissions, \
patch.object(TicketAssignmentService, 'create_ticket_assignment') as mocked_assign_member:
response = api_client.post('/api/v1/ticket-assignments', data=payload, format='json')
self.assertEqual(response.status_code, 403)
expected_response = {
'error_code': PermissionDeniedException.code,
'error_message': PermissionDeniedException.message,
}
mocked_get_permissions.assert_called_with(
user_id=user.id,
ticket_id=payload['ticket_id'],
)
mocked_assign_member.assert_not_called()
self.assertDictEqual(response.data, expected_response)
def test_create_organization_already_exists(self):
organization = OrganizationFactory(name='GITRello')
payload = {
'name': organization.name,
}
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
with patch.object(
OrganizationService,
'create_organization',
side_effect=OrganizationAlreadyExistsException) as mocked_create_organization:
response = api_client.post('/api/v1/organizations', data=payload, format='json')
self.assertEqual(response.status_code, 400)
mocked_create_organization.assert_called_with(
owner_id=user.id,
name=payload['name'],
)
expected_response = {
'error_code': OrganizationAlreadyExistsException.code,
'error_message': OrganizationAlreadyExistsException.message,
}
self.assertDictEqual(response.data, expected_response)
def test_create_board_permission_denied(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
payload = {
'name': 'Main Board',
'organization_id': 1,
}
with \
patch.object(
PermissionsService,
'get_organization_permissions',
return_value=Permissions.with_no_permissions(),
) as mocked_get_permissions, \
patch.object(BoardService, 'create_board') as mocked_create_board:
response = api_client.post('/api/v1/boards',
data=payload,
format='json')
self.assertEqual(response.status_code, 403)
mocked_create_board.assert_not_called()
mocked_get_permissions.assert_called_with(
user_id=user.id, organization_id=payload['organization_id'])
expected_response = {
'error_code': PermissionDeniedException.code,
'error_message': PermissionDeniedException.message,
}
self.assertDictEqual(response.data, expected_response)
def test_create_category_permission_denied(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
payload = {
'board_id': 1,
'name': 'category',
}
with \
patch.object(
PermissionsService,
'get_board_permissions',
return_value=Permissions.with_no_permissions(),
) as mocked_get_permissions, \
patch.object(CategoryService, 'create_category') as mocked_create_category:
response = api_client.post('/api/v1/categories',
data=payload,
format='json')
self.assertEqual(response.status_code, 403)
expected_response = {
'error_code': PermissionDeniedException.code,
'error_message': PermissionDeniedException.message,
}
mocked_get_permissions.assert_called_with(
user_id=user.id,
board_id=payload['board_id'],
)
mocked_create_category.assert_not_called()
self.assertDictEqual(response.data, expected_response)
def test_create_user(self):
payload = {
'username': '******',
'first_name': 'fn',
'last_name': 'ln',
'email': '*****@*****.**',
'password': '******',
}
user = UserFactory()
with patch.object(UserService, 'create_user',
return_value=user) as mocked_create_user:
response = APIClient().post('/api/v1/users',
data=payload,
format='json')
self.assertEqual(response.status_code, 201)
mocked_create_user.assert_called_with(
username=payload['username'],
first_name=payload['first_name'],
last_name=payload['last_name'],
email=payload['email'],
password=payload['password'],
)
self.assertDictEqual(
response.data,
{
'id': str(user.id),
'token': UserService().get_jwt_token(user.id),
'username': user.username,
'first_name': user.first_name,
'last_name': user.last_name,
'email': user.email,
},
)
def test_accept_or_decline_invite_permission_denied(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
payload = {'accept': True}
with \
patch.object(
PermissionsService,
'get_organization_invite_permissions',
return_value=Permissions.with_no_permissions(),
) as mocked_get_permissions, \
patch.object(
OrganizationInviteService,
'accept_or_decline_invite',
) as mocked_accept_or_decline_invite:
response = api_client.patch('/api/v1/organization-invites/1', data=payload, format='json')
self.assertEqual(response.status_code, 403)
mocked_get_permissions.assert_called_with(
user_id=user.id,
organization_invite_id=1,
)
mocked_accept_or_decline_invite.assert_not_called()
expected_response = {
'error_code': PermissionDeniedException.code,
'error_message': PermissionDeniedException.message,
}
self.assertDictEqual(response.data, expected_response)
def test_create_invite_request_not_valid(self):
payload = {
'extra_argument': 42,
'email': 'not-a-email',
}
api_client = APIClient()
api_client.force_authenticate(user=UserFactory())
response = api_client.post('/api/v1/organization-invites', data=payload, format='json')
self.assertEqual(response.status_code, 400)
expected_response = {
'error_code': APIRequestValidationException.code,
'error_message': APIRequestValidationException.message,
'error_details': {
"organization_id": [
"This field is required."
],
"email": [
"Enter a valid email address."
],
"message": [
"This field is required."
],
}
}
self.assertDictEqual(response.data, expected_response)
def test_send_invite_organization_not_found(self):
user = UserFactory()
with self.assertRaises(OrganizationNotFoundException):
_ = OrganizationInviteService.create_organization_invite(
organization_id=-1,
email=user.email,
message='message',
)
def test_create_organization_name_not_unique(self):
organization = OrganizationFactory()
user = UserFactory()
with self.assertRaises(OrganizationAlreadyExistsException):
_ = OrganizationService().create_organization(
owner_id=user.id,
name=organization.name,
)
def test_create_user_email_not_unique(self):
UserFactory(email='*****@*****.**')
with self.assertRaises(UserAlreadyExistsException):
_, _ = UserService.create_user(
username='******',
first_name='fn',
last_name='ln',
email='*****@*****.**',
password='******',
)
def test_send_invite(self):
organization = OrganizationFactory()
user = UserFactory()
invite = OrganizationInviteService.create_organization_invite(
organization_id=organization.id,
email=user.email,
message='message',
)
self.assertIsNotNone(invite)
self.assertEqual(invite.organization.id, organization.id)
self.assertEqual(invite.user.id, user.id)
self.assertEqual(invite.message, 'message')
def test_add_member(self):
organization = OrganizationFactory()
user = UserFactory()
membership = OrganizationMembershipService.create_organization_membership(
organization_id=organization.id,
user_id=user.id,
role=OrganizationMemberRole.OWNER,
)
self.assertIsNotNone(membership)
self.assertEqual(membership.organization_id, organization.id)
self.assertEqual(membership.user_id, user.id)
self.assertEqual(membership.role, OrganizationMemberRole.OWNER)
def test_update_ticket(self):
api_client = APIClient()
user = UserFactory()
payload = {
'title': 'Some Title',
'body': 'Some Body',
'due_date': '2021-01-01',
}
api_client.force_authenticate(user=user)
ticket = TicketFactory()
with \
patch.object(
PermissionsService,
'get_ticket_permissions',
return_value=Permissions.with_mutate_permissions(),
) as mocked_get_ticket_permissions, \
patch.object(TicketService, 'update_ticket', return_value=ticket) as mocked_update_ticket:
response = api_client.patch('/api/v1/tickets/1',
data=payload,
format='json')
self.assertEqual(response.status_code, 200)
mocked_get_ticket_permissions.assert_called_with(
user_id=user.id,
ticket_id=1,
)
mocked_update_ticket.assert_called_with(ticket_id=1,
validated_data={
'title':
payload['title'],
'body':
payload['body'],
'due_date':
date.fromisoformat(
payload['due_date']),
})
expected_response = {
'id': str(ticket.id),
'title': ticket.title,
'body': ticket.body,
'due_date': ticket.due_date.isoformat(),
'priority': ticket.priority,
'category_id': str(ticket.category_id),
}
self.assertDictEqual(response.data, expected_response)
def test_update_ticket_ticket_not_found(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
payload = {
'title': 'Some Title',
'body': 'Some Body',
'due_date': '2021-01-01',
}
with \
patch.object(
PermissionsService,
'get_ticket_permissions',
return_value=Permissions.with_mutate_permissions(),
) as mocked_get_ticket_permissions, \
patch.object(
TicketService,
'update_ticket',
side_effect=TicketNotFoundException
) as mocked_update_ticket:
response = api_client.patch('/api/v1/tickets/1',
data=payload,
format='json')
self.assertEqual(response.status_code, 400)
expected_response = {
'error_code': TicketNotFoundException.code,
'error_message': TicketNotFoundException.message,
}
mocked_get_ticket_permissions.assert_called_with(
user_id=user.id,
ticket_id=1,
)
mocked_update_ticket.assert_called_with(ticket_id=1,
validated_data={
'title':
payload['title'],
'body':
payload['body'],
'due_date':
date.fromisoformat(
payload['due_date']),
})
self.assertDictEqual(response.data, expected_response)
def test_create_organization(self):
user = UserFactory()
with patch.object(
OrganizationMembershipService,
'create_organization_membership') as mocked_add_member:
organization = OrganizationService().create_organization(
owner_id=user.id,
name='organization',
)
self.assertIsNotNone(organization)
self.assertEqual(organization.name, 'organization')
mocked_add_member.assert_called_with(
organization_id=organization.id,
user_id=user.id,
role=OrganizationMemberRole.OWNER,
)
def test_create_board(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
board = BoardFactory()
payload = {
'name': 'Main Board',
'organization_id': board.organization_id,
}
with \
patch.object(
PermissionsService,
'get_organization_permissions',
return_value=Permissions.with_all_permissions()
) as mocked_get_permissions, \
patch.object(BoardService, 'create_board', return_value=board) as mocked_create_board, \
patch.object(CategoryService, 'create_category') as mocked_create_category:
response = api_client.post('/api/v1/boards',
data=payload,
format='json')
self.assertEqual(response.status_code, 201)
mocked_get_permissions.assert_called_with(
organization_id=board.organization_id,
user_id=user.id,
)
mocked_create_board.assert_called_with(
name=payload['name'],
organization_id=payload['organization_id'],
)
mocked_create_category.assert_called_with(
name=CategoryService.NOT_SORTED,
board_id=board.id,
)
self.assertDictEqual(
response.data,
{
'id': str(board.id),
'name': board.name,
'organization_id': str(board.organization_id)
},
)
def test_create_board_membership(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
board_membership = BoardMembershipFactory()
payload = {
'board_id': board_membership.board_id,
'organization_id': 56,
'organization_membership_id': 42,
}
with \
patch.object(
PermissionsService,
'get_board_permissions',
return_value=Permissions.with_mutate_permissions(),
) as mocked_get_permissions, \
patch.object(
BoardMembershipService,
'create_board_membership',
return_value=board_membership,
) as mocked_add_member:
response = api_client.post('/api/v1/board-memberships', data=payload, format='json')
self.assertEqual(response.status_code, 201)
mocked_get_permissions.assert_called_with(
board_id=payload['board_id'],
user_id=user.id,
)
mocked_add_member.assert_called_with(
board_id=payload['board_id'],
organization_membership_id=payload['organization_membership_id'],
)
self.assertDictEqual(
response.data,
{
'id': str(board_membership.id),
'board_id': str(board_membership.board_id),
'organization_membership_id': str(board_membership.organization_membership_id),
},
)
def test_delete_board_membership(self):
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
with \
patch.object(
PermissionsService,
'get_board_membership_permissions',
return_value=Permissions.with_all_permissions(),
) as mocked_get_permissions, \
patch.object(BoardMembershipService, 'delete_board_membership') as mocked_delete_member:
response = api_client.delete('/api/v1/board-memberships/42')
self.assertEqual(response.status_code, 204)
mocked_get_permissions.assert_called_with(
board_membership_id=42,
user_id=user.id,
)
mocked_delete_member.assert_called_with(board_membership_id=42)
def test_create_organization(self):
payload = {
'name': 'GITrello',
}
user = UserFactory()
api_client = APIClient()
api_client.force_authenticate(user=user)
organization = OrganizationFactory()
with patch.object(
OrganizationService, 'create_organization', return_value=organization) as mocked_create_organization:
response = api_client.post('/api/v1/organizations', data=payload, format='json')
self.assertEqual(response.status_code, 201)
mocked_create_organization.assert_called_with(
owner_id=user.id,
name=payload['name'],
)
self.assertDictEqual(response.data, {'id': str(organization.id), 'name': organization.name})
