def test_get_token_from_request():
test_token = 'asdf-jkl'
test_request = request.create_mock_request('', token=test_token)
returned_token = token.get_token_from_request(test_request)
assert test_token == returned_token
def assert_function_returns_user_not_valid(function, mock_service_function_validation, mock_token, mock_retro):
mock_service_function_validation.return_value.get_retro.return_value = mock_retro
mock_token.token_is_valid.return_value = False
response = function(request.create_mock_request(retro_id='whatever', api_version=mock_retro.version))
assert_user_not_valid(response)
def test_post_create_new_retro(self, mock_service_validation,
mock_service_view, mock_token):
request_body = {'retroName': 'Sprint 26', 'adminName': 'halprin'}
a_request = request.create_mock_request(request_body)
new_retro_id = 'awesome_retro_id'
new_admin_id = 'sweet_user_id'
mock_new_retro = retro.create_mock_retro(
id=new_retro_id,
name=request_body['retroName'],
participants=[
retro.create_mock_participant(token=new_admin_id,
name=request_body['adminName'],
admin=True)
])
mock_service_view.create_retro.return_value = mock_new_retro
object_under_test = RetroView()
response = object_under_test.post(a_request)
assert response.status_code == 201
assert response.headers[
validators.content_type] == content_type_application_json
assert json.loads(response.body) == {
'retroId': new_retro_id,
'token': new_admin_id
}
def test__get_service_version_non_1():
api_version = '26'
mock_request = request.create_mock_request(api_version=api_version)
actual_service_version = validation._get_service_version(mock_request)
assert 'V' + api_version == actual_service_version
def assert_function_returns_retro_not_on_step(function, mock_service_function_validation, mock_token, mock_retro,
expected_error_message):
mock_service_function_validation.return_value.get_retro.return_value = mock_retro
mock_token.token_is_valid.return_value = True
response = function(request.create_mock_request(retro_id='whatever', api_version=mock_retro.version))
assert_retro_not_on_step(response, expected_error_message)
def test_user_is_valid_negative(mock_token):
mock_token.token_is_valid.return_value = False
object_under_test = validation.user_is_valid(original_function)
response = object_under_test(None,
request.create_mock_request(),
retro=retro.create_mock_retro())
validators.assert_user_not_valid(response)
def assert_function_returns_group_not_found(function, mock_service_function_validation, mock_token, mock_retro):
mock_service_function_validation.return_value.get_retro.return_value = mock_retro
mock_token.token_is_valid.return_value = True
mock_retro.groups.append(retro.create_mock_group(id='a_group'))
non_existing_group_id = 'non-existing_group_id'
response = function(request.create_mock_request(retro_id='whatever', group_id=non_existing_group_id,
api_version=mock_retro.version))
assert_group_not_found(response, non_existing_group_id)
def test_retrospective_api_is_incorrect():
api_version = '26'
mock_request = request.create_mock_request(api_version=api_version)
mock_retro = retro.create_mock_retroV2()
object_under_test = validation.retrospective_api_is_correct(
original_function)
response = object_under_test(None, mock_request, retro=mock_retro)
validators.assert_api_mismatch(response, api_version, '2')
def test_user_owns_issue(mock_token):
mock_token.issue_owned_by_participant.return_value = True
mock_request = request.create_mock_request()
mock_issue = retro.create_mock_issue()
object_under_test = validation.issue_owned_by_user(original_function)
passed_args = object_under_test(None, mock_request, issue=mock_issue)
assert mock_request == passed_args['args'][1]
assert mock_issue == passed_args['kwargs']['issue']
def test_retrospective_api_is_correct():
api_version = '2'
mock_request = request.create_mock_request(api_version=api_version)
mock_retro = retro.create_mock_retroV2()
object_under_test = validation.retrospective_api_is_correct(
original_function)
passed_args = object_under_test(None, mock_request, retro=mock_retro)
assert mock_request == passed_args['args'][1]
def test_user_doesnt_own_issue(mock_token):
issue_id = 'issue_id'
mock_token.issue_owned_by_participant.return_value = False
object_under_test = validation.issue_owned_by_user(original_function)
response = object_under_test(None,
request.create_mock_request(),
issue=retro.create_mock_issue(id=issue_id))
validators.assert_user_not_owner_of_issue(response, issue_id)
def test_user_is_valid_positive(mock_token):
mock_token.token_is_valid.return_value = True
mock_retro = retro.create_mock_retro()
mock_request = request.create_mock_request()
object_under_test = validation.user_is_valid(original_function)
passed_args = object_under_test(None, mock_request, retro=mock_retro)
assert mock_request == passed_args['args'][1]
assert mock_retro == passed_args['kwargs']['retro']
def test_issue_exists_positive():
issue_id = 'some_issue_id'
mock_request = request.create_mock_request(issue_id=issue_id)
mock_issue = retro.create_mock_issue(id=issue_id)
mock_retro = retro.create_mock_retro(issues=[mock_issue])
object_under_test = validation.issue_exists(original_function)
passed_args = object_under_test(mock_request, retro=mock_retro)
assert mock_retro == passed_args['kwargs']['retro']
assert mock_issue == passed_args['kwargs']['issue']
def test_issue_exists_negative():
issue_id = 'non-existent_issue_id'
mock_request = request.create_mock_request(issue_id=issue_id)
object_under_test = validation.issue_exists(original_function)
response = object_under_test(
mock_request,
retro=retro.create_mock_retro(
issues=[retro.create_mock_issue(id='some_other_id')]))
validators.assert_issue_not_found(response, issue_id)
def assert_function_returns_api_mismatch(function, mock_service_function_validation, mock_retro: Retrospective):
request_body = {
'does': 'nothing'
}
mock_service_function_validation.return_value.get_retro.return_value = mock_retro
mock_api_version = 'incorrect_version'
mock_request = request.create_mock_request(request_body, retro_id='whatever', api_version=mock_api_version)
response = function(mock_request)
assert_api_mismatch(response, mock_api_version, mock_retro.version)
def test_retrospective_exists_negative(mock_service_function):
mock_self_class = MagicMock()
retro_id = 'non-existent_retro_id'
mock_request = request.create_mock_request(retro_id=retro_id)
mock_service_function.return_value.get_retro.side_effect = Retrospective.DoesNotExist
object_under_test = validation.retrospective_exists(original_function)
response = object_under_test(mock_self_class,
mock_request,
retro_id=retro_id)
validators.assert_retro_not_found(response, retro_id)
def test_put_user_isnt_admin(self, mock_service_function_validation,
mock_service_view, mock_token):
request_body = {'direction': 'next'}
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
id='moof')
mock_token.token_is_admin.return_value = False
object_under_test = RetroView()
response = object_under_test.put(
request.create_mock_request(request_body, retro_id='whatever'))
validators.assert_user_not_admin(response)
def assert_function_returns_retrospective_does_not_exist(function, mock_service_function_validation):
mock_service_function_validation.return_value.get_retro.side_effect = Model.DoesNotExist
request_body = {
'does': 'nothing'
}
retro_id = 'non-existent_retro_id'
response = function(request.create_mock_request(request_body, retro_id=retro_id))
assert_retro_not_found(response, retro_id)
def test_delete_issue_doesnt_exist(self, mock_service_function_validation,
mock_service_view, mock_token):
issue_id = 'non-existing_id'
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
current_step=RetroStep.ADDING_ISSUES.value,
issues=[retro.create_mock_issue(id='some_other_id')])
mock_token.token_is_valid.return_value = True
object_under_test = RetroIssueView()
response = object_under_test.delete(
request.create_mock_request(retro_id='whatever',
issue_id=issue_id))
validators.assert_issue_not_found(response, issue_id)
def test_retrospective_exists_positive(mock_service_function):
mock_retro = retro.create_mock_retro()
mock_self_class = MagicMock()
passed_in_retro_id = 'some_retro_id'
mock_request = request.create_mock_request(retro_id=passed_in_retro_id)
mock_service_function.return_value.get_retro.return_value = mock_retro
object_under_test = validation.retrospective_exists(original_function)
passed_args = object_under_test(mock_self_class,
mock_request,
retro_id=passed_in_retro_id)
assert mock_retro == passed_args['kwargs']['retro']
assert passed_in_retro_id == passed_args['kwargs']['retro_id']
def test_get_retro_success(self, mock_service_function_validation,
mock_service_view, mock_token):
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
)
mock_token.token_is_valid.return_value = True
mock_response = {'mockResponseBody': 'one awesome response body'}
mock_service_view.sanitize_retro_for_user_and_step.return_value = mock_response
object_under_test = RetroView()
response = object_under_test.get(
request.create_mock_request(retro_id='whatever'))
assert response.status_code == 200
assert response.headers[
validators.content_type] == content_type_application_json
assert json.loads(response.body) == mock_response
def test__group_put_group_does_not_exist_real_uuid(
self, mock_service_function_validation, mock_token):
non_existing_group_id = '0f3c2792-fc6c-41d5-a451-bebc3072fcc2'
mock_group = retro.create_mock_group(id='cool_id')
mock_issue = retro.create_mock_issueV2()
mock_retro = retro.create_mock_retroV2(
current_step=RetroStepV2.GROUPING.value,
issues=[mock_issue],
groups=[mock_group])
object_under_test = RetroIssueViewV2()
response = object_under_test._group_put(
request.create_mock_request(group_id=non_existing_group_id),
retro=mock_retro)
validators.assert_group_not_found(response, non_existing_group_id)
def test_delete_issue_not_owned_by_user(self,
mock_service_function_validation,
mock_service_view, mock_token):
issue_id = 'issue_id'
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
current_step=RetroStep.ADDING_ISSUES.value,
issues=[retro.create_mock_issue(id=issue_id)])
mock_token.token_is_valid.return_value = True
mock_token.issue_owned_by_participant.return_value = False
object_under_test = RetroIssueView()
response = object_under_test.delete(
request.create_mock_request(retro_id='whatever',
issue_id=issue_id))
validators.assert_user_not_owner_of_issue(response, issue_id)
def test_put_user_ready_success_true(self,
mock_service_function_validation,
mock_service_view, mock_token):
request_body = {'ready': True}
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
)
mock_token.token_is_valid.return_value = True
object_under_test = RetroUserView()
response = object_under_test.put(
request.create_mock_request(request_body, retro_id='whatever'))
assert response.status_code == 200
assert response.headers[
validators.content_type] == views.content_type_text_plain
assert response.body == ''
def test_put_move_success(self, mock_service_function_validation,
mock_service_view, mock_token):
request_body = {'direction': 'next'}
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
)
mock_token.token_is_admin.return_value = True
new_stage = 'Voting'
mock_service_view.move_retro.return_value = new_stage
object_under_test = RetroView()
response = object_under_test.put(
request.create_mock_request(request_body, retro_id='whatever'))
assert response.status_code == 200
assert response.headers[
validators.content_type] == content_type_application_json
assert json.loads(response.body) == {'newStep': new_stage}
def test_put_move_isnt_allowed(self, mock_service_function_validation,
mock_service_view, mock_token):
request_body = {'direction': 'next'}
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
)
mock_token.token_is_admin.return_value = True
value_error_text = "Can't move that direction"
mock_service_view.move_retro.side_effect = ValueError(value_error_text)
object_under_test = RetroView()
response = object_under_test.put(
request.create_mock_request(request_body, retro_id='whatever'))
assert response.status_code == 422
assert response.headers[
validators.content_type] == views.content_type_text_plain
assert response.body == value_error_text
def test_post_new_user_success(self, mock_service_function_validation,
mock_service_view, mock_token):
request_body = {'name': 'new_user'}
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
)
new_user_token = 'a-special-new-token'
mock_service_view.add_participant.return_value = new_user_token
object_under_test = RetroUserView()
retro_id = 'whatever_retro_id'
response = object_under_test.post(
request.create_mock_request(request_body, retro_id=retro_id))
assert response.status_code == 201
assert response.headers[
validators.content_type] == content_type_application_json
assert json.loads(response.body) == {'token': new_user_token}
def test_put_group_issue(self, mock_group_put_function,
mock_service_function_validation, mock_token):
request_body = {
'group': '0f3c2792-fc6c-41d5-a451-bebc3072fcc2',
}
mock_issue_id = 'whatever_issue_id'
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
current_step=RetroStepV2.VOTING.value,
issues=[retro.create_mock_issueV2(id=mock_issue_id)])
mock_token.token_is_valid.return_value = True
object_under_test = RetroIssueViewV2()
object_under_test.put(
request.create_mock_request(request_body,
retro_id='whatever',
issue_id=mock_issue_id))
assert mock_group_put_function.called is True
def test_delete_success(self, mock_service_function_validation,
mock_service_view, mock_token):
issue_id = 'issue_id'
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
current_step=RetroStep.ADDING_ISSUES.value,
issues=[retro.create_mock_issue(id=issue_id)])
mock_token.token_is_valid.return_value = True
mock_token.issue_owned_by_participant.return_value = True
object_under_test = RetroIssueView()
response = object_under_test.delete(
request.create_mock_request(retro_id='whatever',
issue_id=issue_id))
assert 204 == response.status_code
assert views.content_type_text_plain == response.headers[
validators.content_type]
assert '' == response.body
def test_put_vote_for_issue(self, mock_super_put,
mock_service_function_validation, mock_token):
request_body = {
'vote': True,
}
mock_issue_id = 'whatever_issue_id'
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
current_step=RetroStepV2.VOTING.value,
issues=[retro.create_mock_issueV2(id=mock_issue_id)])
mock_token.token_is_valid.return_value = True
object_under_test = RetroIssueViewV2()
object_under_test.put(
request.create_mock_request(request_body,
retro_id='whatever',
issue_id=mock_issue_id))
assert mock_super_put.called is True
