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)
예제 #2
0
    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)
예제 #3
0
    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_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_invite(self):
        user = UserFactory()
        api_client = APIClient()
        api_client.force_authenticate(user)
        invite = OrganizationInviteFactory()

        payload = {
            'organization_id': 42,
            'email': invite.user.email,
            'message': 'message',
        }
        with \
                patch.object(
                    PermissionsService,
                    'get_organization_permissions',
                    return_value=Permissions.with_all_permissions(),
                ) as mocked_get_permissions, \
                patch.object(
                    OrganizationInviteService,
                    'create_organization_invite',
                    return_value=invite,
                ) as mocked_send_invite:
            response = api_client.post('/api/v1/organization-invites', data=payload, format='json')

        self.assertEqual(response.status_code, 201)
        mocked_get_permissions.assert_called_with(
            organization_id=payload['organization_id'],
            user_id=user.id,
        )
        mocked_send_invite.assert_called_with(
            organization_id=payload['organization_id'],
            email=payload['email'],
            message=payload['message']
        )
        expected_response = {
            'id': str(invite.id),
            'user_id': str(invite.user_id),
            'organization_id': str(invite.organization_id),
            'message': invite.message,
        }
        self.assertDictEqual(response.data, expected_response)
예제 #6
0
    def test_delete_ticket_assignment(self):
        api_client = APIClient()
        user = UserFactory()
        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') as mocked_unassign_member:
            response = api_client.delete('/api/v1/ticket-assignments/1',)

        self.assertEqual(response.status_code, 204)
        mocked_get_permissions.assert_called_with(
            user_id=user.id,
            ticket_assignment_id=1,
        )
        mocked_unassign_member.assert_called_with(
            ticket_assignment_id=1,
        )
    def test_create_invite_already_exists(self):
        user = UserFactory()
        api_client = APIClient()
        api_client.force_authenticate(user=user)

        payload = {
            'organization_id': 42,
            'email': user.email,
            'message': 'message',
        }
        with \
                patch.object(
                    PermissionsService,
                    'get_organization_permissions',
                    return_value=Permissions.with_all_permissions(),
                ) as mocked_get_permissions, \
                patch.object(
                    OrganizationInviteService,
                    'create_organization_invite',
                    side_effect=OrganizationInviteAlreadyExistsException,
                ) as mocked_send_invite:
            response = api_client.post('/api/v1/organization-invites', data=payload, format='json')

        self.assertEqual(response.status_code, 400)
        expected_response = {
            'error_code': OrganizationInviteAlreadyExistsException.code,
            'error_message': OrganizationInviteAlreadyExistsException.message,
        }
        mocked_get_permissions.assert_called_with(
            organization_id=payload['organization_id'],
            user_id=user.id,
        )
        mocked_send_invite.assert_called_with(
            organization_id=payload['organization_id'],
            email=payload['email'],
            message=payload['message'],
        )
        self.assertDictEqual(response.data, expected_response)
    def test_accept_or_decline_invite(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') 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, 204)
        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'],
        )
예제 #9
0
    def test_create_board_already_exists(self):
        user = UserFactory()
        api_client = APIClient()
        api_client.force_authenticate(user=user)
        payload = {
            'name': 'Main Board',
            'organization_id': 42,
        }

        with \
                patch.object(
                    PermissionsService,
                    'get_organization_permissions',
                    return_value=Permissions.with_all_permissions(),
                ) as mocked_get_permissions, \
                patch.object(
                    BoardService,
                    'create_board',
                    side_effect=BoardAlreadyExistsException,
                ) as mocked_create_board:
            response = api_client.post('/api/v1/boards',
                                       data=payload,
                                       format='json')

        self.assertEqual(response.status_code, 400)
        mocked_create_board.assert_called_with(
            name=payload['name'], organization_id=payload['organization_id'])
        mocked_get_permissions.assert_called_with(
            organization_id=payload['organization_id'],
            user_id=user.id,
        )
        expected_response = {
            'error_code': BoardAlreadyExistsException.code,
            'error_message': BoardAlreadyExistsException.message,
        }
        self.assertDictEqual(response.data, expected_response)