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_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_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__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_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_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_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__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__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 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_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__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__sanitize_group_results_step():
mock_id = 'DogCow'
mock_title = 'Moof'
mock_section = 'Some cool section'
mock_user_token = 'voter1_is_cool'
mock_votes = [mock_user_token, 'voter2']
mock_group = retro.create_mock_group(id=mock_id, title=mock_title, section=mock_section, votes=mock_votes)
actual_sanitized_group = ServiceV2._sanitize_group(mock_group, RetroStepV2.RESULTS, mock_user_token)
assert mock_id == actual_sanitized_group['id']
assert mock_title == actual_sanitized_group['title']
assert mock_section == actual_sanitized_group['section']
assert len(mock_votes) == actual_sanitized_group['votes']
def test__sanitize_group_grouping_step():
mock_id = 'DogCow'
mock_title = 'Moof'
mock_section = 'Some cool section'
mock_user_token = 'voter1_is_cool'
mock_votes = [mock_user_token, 'voter2']
mock_group = retro.create_mock_group(id=mock_id, title=mock_title, section=mock_section, votes=mock_votes)
actual_sanitized_group = ServiceV2._sanitize_group(mock_group, RetroStepV2.GROUPING, mock_user_token)
assert mock_id == actual_sanitized_group['id']
assert mock_title == actual_sanitized_group['title']
assert mock_section == actual_sanitized_group['section']
with pytest.raises(KeyError):
actual_sanitized_group['votes']
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__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_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__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_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}
