def test_ungroup_issue(mock_send_retro_update):
mock_group = retro.create_mock_group(id='a group')
mock_issue = retro.create_mock_issueV2(id='an issue', group=mock_group.id)
mock_retro = retro.create_mock_retroV2(id='a retro', issues=[mock_issue], groups=[mock_group])
ServiceV2.ungroup_issue(mock_issue, mock_retro)
assert mock_issue.group is None
def test_put_group_does_not_exist(self, mock_service_function_validation,
mock_token):
object_under_test = RetroGroupViewV2()
mock_retro = retro.create_mock_retroV2(
current_step=RetroStepV2.VOTING.value)
validators.assert_function_returns_group_not_found(
object_under_test.put, mock_service_function_validation,
mock_token, mock_retro)
def test_find_group_negative():
group_one = retro.create_mock_group(id='an_group_id')
group_two = retro.create_mock_group(id='another_group_id')
mock_retro = retro.create_mock_retroV2(groups=[group_one, group_two])
issue = validation._find_group('non-existing_issue_id', mock_retro)
assert issue is None
def test__get_group_by_id_not_found():
mock_id = 'a great id'
mock_retro = retro.create_mock_retroV2(groups=[retro.create_mock_group(id='whatever'), retro.create_mock_group(id='another whatever')])
found_group = ServiceV2._get_group_by_id(mock_id, mock_retro)
assert found_group is None
def test_find_group_positive():
existing_group_id = 'an_group_id'
group_one = retro.create_mock_group(id='some_issue_id')
expected_group = retro.create_mock_group(id=existing_group_id)
mock_retro = retro.create_mock_retroV2(groups=[group_one, expected_group])
actual_group = validation._find_group(existing_group_id, mock_retro)
assert expected_group == actual_group
def test__sanitize_group_list():
size = 4
groups = [retro.create_mock_group(id='id' + str(index)) for index in range(size)]
mock_retro = retro.create_mock_retroV2(groups=groups)
sanitized_groups = ServiceV2._sanitize_group_list(mock_retro, 'user-token')
assert size == len(sanitized_groups)
def test__get_group_by_id():
mock_id = 'a great id'
mock_retro = retro.create_mock_retroV2(groups=[retro.create_mock_group(id='whatever'), retro.create_mock_group(id=mock_id)])
found_group = ServiceV2._get_group_by_id(mock_id, mock_retro)
assert found_group is not None
assert mock_id == found_group.id
def test_vote_for_group(mock_send_retro_update):
voting_user = '******'
mock_group = retro.create_mock_group(id='a group')
mock_retro = retro.create_mock_retroV2(id='a retro', groups=[mock_group])
ServiceV2.vote_for_group(mock_group, voting_user, mock_retro)
assert voting_user in mock_group.votes
def test_get_retro(mock_retrospective_class):
retro_id = 'an_awesome_retro_id'
mock_retrospective_class.get.side_effect = lambda passed_in_retro_id: retro.create_mock_retroV2(
id=passed_in_retro_id)
returned_retro = ServiceV2.get_retro(retro_id)
mock_retrospective_class.get.assert_called_with(retro_id)
assert returned_retro.id == retro_id
def test_unvote_for_group(mock_send_retro_update):
voting_user = '******'
mock_group = retro.create_mock_group(id='a group', votes={voting_user})
mock_retro = retro.create_mock_retroV2(id='a retro', groups=[mock_group])
ServiceV2.unvote_for_group(mock_group, voting_user, mock_retro)
assert mock_group.votes is None or voting_user not in mock_group.votes
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_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_put_retro_step_not_valid(self, mock_service_function_validation,
mock_token):
object_under_test = RetroGroupViewV2()
mock_retro = retro.create_mock_retroV2(
current_step=RetroStepV2.GROUPING.value)
validators.assert_function_returns_retro_not_on_step(
object_under_test.put, mock_service_function_validation,
mock_token, mock_retro,
viewsV2.no_vote_group_retro_wrong_step.format(
mock_retro.current_step))
def test_unvote_for_issue_non_group(mock_send_retro_update):
voting_user = '******'
mock_group = retro.create_mock_group(id='a group')
mock_issue = retro.create_mock_issueV2(id='an issue', group='', votes={voting_user})
mock_retro = retro.create_mock_retroV2(id='a retro', issues=[mock_issue], groups=[mock_group])
ServiceV2.unvote_for_issue(mock_issue, voting_user, mock_retro)
assert mock_issue.votes is None or voting_user not in mock_issue.votes
assert mock_group.votes is None or voting_user not in mock_group.votes
def test_add_new_group(mock_send_retro_update):
mock_group_title = 'group_moof'
mock_group_section = 'a_section'
mock_retro = retro.create_mock_retroV2()
ServiceV2.add_new_group(mock_group_title, mock_group_section, mock_retro)
assert mock_retro.groups is not None
assert 1 == len(mock_retro.groups)
assert mock_group_title == mock_retro.groups[0].title
assert mock_group_section == mock_retro.groups[0].section
assert mock_retro.groups[0].votes is None or 0 == len(mock_retro.groups[0].votes)
assert mock_retro.groups[0].id is not None and 0 != len(mock_retro.groups[0].id)
def test__sanitize_group_list_order_by_vote():
size = 4
groups = [retro.create_mock_group(id='id' + str(index)) for index in range(size)]
groups[0].votes = ['1', '2']
groups[2].votes = ['1', '2', '3']
most_votes_id = groups[2].id
second_most_votes_id = groups[0].id
mock_retro = retro.create_mock_retroV2(groups=groups, current_step=RetroStepV2.RESULTS)
sanitized_groups = ServiceV2._sanitize_group_list(mock_retro, 'user-token')
assert most_votes_id == sanitized_groups[0]['id']
assert second_most_votes_id == sanitized_groups[1]['id']
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_create_retro(mock_retrospective_class):
retro_name = 'Sprint 26'
admin_name = 'DogCow'
mock_retrospective_class.side_effect = lambda retro_id: retro.create_mock_retroV2(id=retro_id)
new_retro = ServiceV2.create_retro(retro_name, admin_name)
assert new_retro.name == retro_name
assert new_retro.current_step == RetroStepV2.ADDING_ISSUES.value
assert len(new_retro.participants) == 1
assert new_retro.participants[0].name == admin_name
assert new_retro.participants[0].admin is True
assert len(new_retro.issues) == 0
assert len(new_retro.groups) == 0
assert new_retro.version == '2'
assert new_retro.id is not None
def test_delete_group(mock_send_retro_update):
mock_group1 = retro.create_mock_group(id='group1')
mock_group2 = retro.create_mock_group(id='group2')
mock_issue1 = retro.create_mock_issueV2(group=mock_group1.id)
mock_issue2 = retro.create_mock_issueV2()
mock_issue3 = retro.create_mock_issueV2(group=mock_group2.id)
mock_issue4 = retro.create_mock_issueV2(group=mock_group1.id)
mock_retro = retro.create_mock_retroV2(groups=[mock_group1, mock_group2], issues=[mock_issue1, mock_issue2, mock_issue3, mock_issue4])
before_group_number = len(mock_retro.groups)
ServiceV2.delete_group(mock_group1, mock_retro)
assert before_group_number - 1 == len(mock_retro.groups)
assert mock_issue1.group is None
assert mock_issue4.group is None
assert mock_group2.id == mock_issue3.group
def test__group_put_retro_not_on_step(self,
mock_service_function_validation,
mock_token):
mock_group = retro.create_mock_group()
mock_issue = retro.create_mock_issueV2()
retro_current_step = RetroStepV2.VOTING.value
mock_retro = retro.create_mock_retroV2(current_step=retro_current_step,
issues=[mock_issue],
groups=[mock_group])
object_under_test = RetroIssueViewV2()
response = object_under_test._group_put(mock_issue,
retro=mock_retro,
group_id=mock_group.id)
validators.assert_retro_not_on_step(
response,
viewsV2.no_group_issue_retro_wrong_step.format(retro_current_step))
def test_delete_success(self, mock_service_view,
mock_service_function_validation, mock_token):
existing_group_id = 'a_group_id'
mock_retro = retro.create_mock_retroV2(
current_step=RetroStepV2.GROUPING.value,
groups=[retro.create_mock_group(id=existing_group_id)])
mock_service_function_validation.return_value.get_retro.return_value = mock_retro
mock_token.token_is_valid.return_value = True
mock_request = request.create_mock_request(
api_version=mock_retro.version,
retro_id='whatever',
group_id=existing_group_id)
object_under_test = RetroGroupViewV2()
response = object_under_test.delete(mock_request)
assert mock_service_view.delete_group.called is True
assert response.status_code == 204
assert response.headers[
validators.content_type] == views.content_type_text_plain
def test_sanitize_retro_for_user_and_step():
size = 4
mock_user_token = 'user-token'
mock_id = 'crazy_id'
mock_name = 'Moof!'
groups = [retro.create_mock_group(id='id'+str(index))for index in range(size)]
mock_retro = retro.create_mock_retroV2(id=mock_id, name=mock_name, groups=groups,
issues=[retro.create_mock_issueV2()],
participants=[retro.create_mock_participant(token=mock_user_token)])
sanitized_retro = ServiceV2.sanitize_retro_for_user_and_step(mock_retro, mock_user_token)
assert mock_id == sanitized_retro['id']
assert mock_name == sanitized_retro['name']
assert len(mock_retro.participants) == len(sanitized_retro['participants'])
assert len(mock_retro.issues) == len(sanitized_retro['issues'])
assert size == len(sanitized_retro['groups'])
assert 'yourself' in sanitized_retro
def test__group_put_group_real_group_id(self, mock_service_module,
mock_service_function_validation,
mock_token):
group_id = '0f3c2792-fc6c-41d5-a451-bebc3072fcc2'
mock_group = retro.create_mock_group(id=group_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=group_id),
mock_issue,
retro=mock_retro)
assert mock_service_module.group_issue.called is True
assert 200 == response.status_code
assert views.content_type_text_plain == response.headers[
validators.content_type]
assert '' == response.body
def test__group_put_group_bool_for_group_id(
self, mock_service_view, mock_service_function_validation,
mock_token):
non_existing_group_id = False
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),
mock_issue,
retro=mock_retro)
assert mock_service_view.ungroup_issue.called is True
assert 200 == response.status_code
assert views.content_type_text_plain == response.headers[
validators.content_type]
assert '' == response.body
def test_post_success(self, mock_service_view,
mock_service_function_validation, mock_token):
existing_group_id = 'a_group_id'
mock_retro = retro.create_mock_retroV2(
current_step=RetroStepV2.GROUPING.value,
groups=[retro.create_mock_group(id=existing_group_id)])
mock_service_function_validation.return_value.get_retro.return_value = mock_retro
mock_token.token_is_valid.return_value = True
request_body = {'title': 'new title', 'section': 'Needs Improvement'}
mock_request = request.create_mock_request(
api_version=mock_retro.version,
request_body=request_body,
retro_id='whatever',
group_id=existing_group_id)
mock_service_view.add_new_group.return_value = existing_group_id
object_under_test = RetroGroupViewV2()
response = object_under_test.post(mock_request)
assert mock_service_view.add_new_group.called is True
assert response.status_code == 201
assert response.headers[
validators.content_type] == content_type_application_json
assert json.loads(response.body) == {'id': existing_group_id}
def test_put_api_mismatch(self, mock_service_function_validation,
mock_token):
object_under_test = RetroGroupViewV2()
validators.assert_function_returns_api_mismatch(
object_under_test.put, mock_service_function_validation,
retro.create_mock_retroV2())
def test_delete_user_not_valid(self, mock_service_function_validation,
mock_token):
object_under_test = RetroGroupViewV2()
validators.assert_function_returns_user_not_valid(
object_under_test.delete, mock_service_function_validation,
mock_token, retro.create_mock_retroV2())
