def test__sanitize_issue_list_shows_your_votes_during_voting():
your_token = 'a-token'
your_issue = retro.create_mock_issue(section='your_section',
creator_token=your_token,
votes={'another-different-token'})
another_issue = retro.create_mock_issue(
section='special_section',
creator_token='a-different-token',
votes={your_token, 'another-different-token'})
a_retro = retro.create_mock_retro(current_step=RetroStep.VOTING,
issues=[your_issue, another_issue])
sanitized_issues = Service._sanitize_issue_list(a_retro, your_token)
assert len(sanitized_issues) == 2
was_your_issue = sanitized_issues[0]
assert was_your_issue['id'] == your_issue.id
assert was_your_issue['title'] == your_issue.title
assert was_your_issue['section'] == your_issue.section
assert was_your_issue['votes'] == 0
was_another_issue = sanitized_issues[1]
assert was_another_issue['id'] == another_issue.id
assert was_another_issue['title'] == another_issue.title
assert was_another_issue['section'] == another_issue.section
assert was_another_issue['votes'] == 1
def test__sanitize_issue_list_shows_my_issues_and_other_sections_during_adding_issues(
):
user_token = 'a-token'
your_issue = retro.create_mock_issue(section='your_section',
creator_token=user_token,
votes={user_token})
another_issue = retro.create_mock_issue(section='special_section',
creator_token='a-different-token')
a_retro = retro.create_mock_retro(current_step=RetroStep.ADDING_ISSUES,
issues=[your_issue, another_issue])
sanitized_issues = Service._sanitize_issue_list(a_retro, user_token)
assert len(sanitized_issues) == 2
was_your_issue = sanitized_issues[0]
assert was_your_issue['id'] == your_issue.id
assert was_your_issue['title'] == your_issue.title
assert was_your_issue['section'] == your_issue.section
with pytest.raises(KeyError):
was_your_issue['votes']
was_another_issue = sanitized_issues[1]
assert was_another_issue['section'] == another_issue.section
with pytest.raises(KeyError):
was_another_issue['title']
with pytest.raises(KeyError):
was_another_issue['id']
with pytest.raises(KeyError):
was_another_issue['votes']
def test__sanitize_issue_list_doesnt_order_issues_when_not_results():
your_token = 'a-token'
the_issue_section = 'a-section'
another_issue_section = 'another-section'
first_issue = retro.create_mock_issue(id='1',
section=the_issue_section,
creator_token=your_token,
votes=set())
second_issue = retro.create_mock_issue(
id='3',
section=the_issue_section,
creator_token='a-different-token',
votes={your_token, 'another-different-token', 'yet-another-token'})
third_issue = retro.create_mock_issue(id='2',
section=another_issue_section,
creator_token='a-different-token',
votes={your_token})
a_retro = retro.create_mock_retro(
current_step=RetroStep.VOTING,
issues=[first_issue, second_issue, third_issue])
sanitized_issues = Service._sanitize_issue_list(a_retro, your_token)
assert sanitized_issues[0]['id'] == first_issue.id
assert sanitized_issues[1]['id'] == second_issue.id
assert sanitized_issues[2]['id'] == third_issue.id
def test__find_issue_negative():
issue_one = retro.create_mock_issue(id='an_issue_id')
issue_two = retro.create_mock_issue(id='another_issue_id')
mock_retro = retro.create_mock_retro(issues=[issue_one, issue_two])
issue = validation._find_issue('non-existing_issue_id', mock_retro)
assert issue is None
def test__find_issue_positive():
existing_issue_id = 'an_issue_id'
issue_one = retro.create_mock_issue(id='some_issue_id')
expected_issue = retro.create_mock_issue(id=existing_issue_id)
mock_retro = retro.create_mock_retro(issues=[issue_one, expected_issue])
actual_issue = validation._find_issue(existing_issue_id, mock_retro)
assert expected_issue == actual_issue
def test_delete_issue(mock_send_retro_update):
mock_issue = retro.create_mock_issue(id='some_issue')
another_mock_issue = retro.create_mock_issue(id='another_issue')
mock_retro = retro.create_mock_retro(
issues=[another_mock_issue, mock_issue])
Service.delete_issue(mock_issue, mock_retro)
assert mock_issue not in mock_retro.issues
mock_send_retro_update.assert_called_once()
def test_issue_owned_by_participant_positive():
creator_token = 'owner_token'
mock_issue = retro.create_mock_issue(creator_token=creator_token)
issue_owned = token.issue_owned_by_participant(mock_issue, creator_token)
assert issue_owned is True
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_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_unvote_for_issue_with_no_votes():
issue_id_str = 'issue_id'
user_token_str = 'voter_token'
a_issue = retro.create_mock_issue(id=issue_id_str)
a_retro = retro.create_mock_retro(issues=[a_issue])
Service.unvote_for_issue(a_issue, user_token_str, a_retro)
assert a_issue.votes is None or 0 == len(a_issue.votes)
assert a_issue.votes is None or user_token_str not in a_issue.votes
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 test_vote_for_issue(mock_send_retro_update):
issue_id_str = 'issue_id'
user_token_str = 'voter_token'
a_issue = retro.create_mock_issue(id=issue_id_str)
a_retro = retro.create_mock_retro(issues=[a_issue])
Service.vote_for_issue(a_issue, user_token_str, a_retro)
assert 1 == len(a_issue.votes)
assert user_token_str in a_issue.votes
mock_send_retro_update.assert_called_once()
def test_unvote_for_issue(mock_send_retro_update):
issue_id_str = 'issue_id'
user_token_str = 'voter_token'
a_issue = retro.create_mock_issue(id=issue_id_str, votes={user_token_str})
a_retro = retro.create_mock_retro(issues=[a_issue])
Service.unvote_for_issue(a_issue, user_token_str, a_retro)
assert a_issue.votes is None or 0 == len(a_issue.votes)
assert a_issue.votes is None or user_token_str not in a_issue.votes
mock_send_retro_update.assert_called_once()
def test_vote_for_issue_twice_results_in_one_vote(mock_send_retro_update):
issue_id_str = 'issue_id'
user_token_str = 'voter_token'
a_issue = retro.create_mock_issue(id=issue_id_str)
a_retro = retro.create_mock_retro(issues=[a_issue])
Service.vote_for_issue(a_issue, user_token_str, a_retro)
Service.vote_for_issue(a_issue, user_token_str, a_retro)
assert 1 == len(a_issue.votes)
assert user_token_str in a_issue.votes
assert 2 == mock_send_retro_update.call_count
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_unvote_for_issue_twice_results_in_zero_votes(mock_send_retro_update):
issue_id_str = 'issue_id'
user_token_str = 'voter_token'
initial_votes = {user_token_str, 'another_voter_token'}
initial_votes_length = len(initial_votes)
a_issue = retro.create_mock_issue(id=issue_id_str, votes=initial_votes)
a_retro = retro.create_mock_retro(issues=[a_issue])
Service.unvote_for_issue(a_issue, user_token_str, a_retro)
Service.unvote_for_issue(a_issue, user_token_str, a_retro)
assert initial_votes_length - 1 == len(a_issue.votes)
assert user_token_str not in a_issue.votes
assert 2 == mock_send_retro_update.call_count
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_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_issue_unvote_success(self, mock_service_function_validation,
mock_service_view, mock_token):
request_body = {
'vote': False,
}
mock_issue_id = 'some_issue_id'
mock_service_function_validation.return_value.get_retro.return_value = retro.create_mock_retro(
current_step=RetroStep.VOTING.value,
issues=[retro.create_mock_issue(id=mock_issue_id)])
mock_token.token_is_valid.return_value = True
object_under_test = RetroIssueView()
response = object_under_test.put(
request.create_mock_request(request_body,
retro_id='whatever',
issue_id=mock_issue_id))
assert mock_service_view.unvote_for_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_issue_owned_by_participant_negative():
mock_issue = retro.create_mock_issue(creator_token='owner_id')
issue_owned = token.issue_owned_by_participant(mock_issue, 'not_owner_id')
assert issue_owned is False