615 lines
23 KiB
Ruby
615 lines
23 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require 'rails_helper'
|
|
|
|
def test_get_index_with_filter(filter_state)
|
|
get :index, params: { state: filter_state, tournament_id: @tournament.to_param }
|
|
deserialize_response(response).each do |match|
|
|
expect(match[:state]).to eq(filter_state)
|
|
end
|
|
end
|
|
|
|
RSpec.describe MatchesController, type: :controller do
|
|
before do
|
|
@match = create(:match, state: :not_started)
|
|
@amount_of_stages = 2
|
|
@tournament = create(:stage_tournament, stage_count: @amount_of_stages)
|
|
@running_playoff_match = @tournament.stages.find_by(level: @amount_of_stages).matches.first
|
|
@not_ready_playoff_match = create(:running_playoff_match, state: :not_ready)
|
|
@match.match_scores = create_pair(:match_score)
|
|
end
|
|
|
|
describe 'GET #index' do
|
|
context 'on a running group stage' do
|
|
before do
|
|
@tournament = create(:group_stage_tournament, match_factory: :running_group_match)
|
|
@tournament.matches.each_with_index do |m, i|
|
|
m.state = :not_started if i.even?
|
|
m.save!
|
|
end
|
|
end
|
|
|
|
it 'filters running matches when told to do so' do
|
|
test_get_index_with_filter('running')
|
|
end
|
|
|
|
it 'filters not_started matches when told to do so' do
|
|
test_get_index_with_filter('not_started')
|
|
end
|
|
|
|
it 'doesn\'t break if the filter contains rubbish' do
|
|
get :index, params: { state: 'saftladen', tournament_id: @tournament.to_param }
|
|
body = deserialize_response response
|
|
expect(body.empty?).to be true
|
|
end
|
|
|
|
it 'returns only live match fields' do
|
|
get :index, params: { tournament_id: @tournament.to_param }
|
|
match = deserialize_response(response).first
|
|
|
|
expect(match.keys).to match_array(%i[id position state location start_time notes teams match_scores group stage])
|
|
expect(match[:teams]).to all(include(:id, :name))
|
|
end
|
|
|
|
it 'filters group stage matches by position across groups' do
|
|
get :index, params: { tournament_id: @tournament.to_param, group_stage_position: 0 }
|
|
body = deserialize_response(response)
|
|
|
|
expect(body).not_to be_empty
|
|
expect(body).to all(include(position: 0))
|
|
expect(body.map { |match| match.dig(:stage, :level) }.uniq).to eq([-1])
|
|
end
|
|
end
|
|
|
|
context 'on a playoff tournament' do
|
|
it 'filters matches by stage level' do
|
|
stage = @tournament.stages.find_by!(level: 1)
|
|
|
|
get :index, params: { tournament_id: @tournament.to_param, stage_level: stage.level }
|
|
body = deserialize_response(response)
|
|
|
|
expect(body.map { |match| match.dig(:stage, :level) }.uniq).to eq([stage.level])
|
|
expect(body.map { |match| match[:id] }).to match_array(stage.matches.map(&:id))
|
|
end
|
|
end
|
|
# TODO add test for upcoming once there is test data for a "valid" group stage
|
|
end
|
|
|
|
describe 'GET #show' do
|
|
it 'should return success' do
|
|
get :show, params: { id: @match.to_param }
|
|
expect(response).to be_successful
|
|
expect(response.media_type).to eq('application/json')
|
|
end
|
|
|
|
it 'should return the correct state' do
|
|
get :show, params: { id: @match.to_param }
|
|
body = deserialize_response response
|
|
expect(body[:state]).to eq(@match.state)
|
|
expect(body[:match_scores].map { |ms| ms[:id] }).to eq(@match.match_scores.map(&:id))
|
|
end
|
|
end
|
|
|
|
describe 'POST #create' do
|
|
let(:group_stage_tournament) { create(:group_stage_tournament, group_count: 1, match_factory: :finished_group_match) }
|
|
let(:group) { group_stage_tournament.stages.find_by(level: -1).groups.first }
|
|
let(:team_ids) { group.teams.first(2).map(&:id) }
|
|
|
|
context 'as owner' do
|
|
before do
|
|
apply_authentication_headers_for group.owner
|
|
end
|
|
|
|
it 'creates a decider match at the end of the group' do
|
|
log_count = group_stage_tournament.transaction_log_entries.count
|
|
|
|
expect do
|
|
post :create, params: { group_id: group.to_param, team_ids: team_ids }
|
|
end.to change { group.matches.reload.count }.by(1)
|
|
|
|
expect(response).to have_http_status(:created)
|
|
created_match = group.matches.reload.max_by(&:position)
|
|
expect(created_match.decider?).to eq(true)
|
|
expect(created_match.state).to eq('not_started')
|
|
expect(created_match.teams.map(&:id)).to match_array(team_ids)
|
|
expect(group_stage_tournament.transaction_log_entries.count).to eq(log_count + 1)
|
|
expect(group_stage_tournament.transaction_log_entries.last.action).to eq('decider_match.created')
|
|
end
|
|
end
|
|
|
|
context 'with invalid teams' do
|
|
before do
|
|
apply_authentication_headers_for group.owner
|
|
end
|
|
|
|
it 'rejects the request' do
|
|
post :create, params: { group_id: group.to_param, team_ids: [group.teams.first.id] }
|
|
expect(response).to have_http_status(:unprocessable_content)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'PATCH #swap' do
|
|
let(:group_stage_tournament) { create(:group_stage_tournament, group_count: 2, match_factory: :filled_group_match) }
|
|
let(:group_stage) { group_stage_tournament.stages.find_by(level: -1) }
|
|
let(:first_group) { group_stage.groups.order(:id).first }
|
|
let(:second_group) { group_stage.groups.order(:id).second }
|
|
let(:first_match) do
|
|
first_group.matches.order(:id).first.tap do |match|
|
|
match.update!(position: 0)
|
|
end
|
|
end
|
|
let(:last_match) do
|
|
first_group.matches.order(:id).last.tap do |match|
|
|
match.update!(position: 3)
|
|
end
|
|
end
|
|
|
|
context 'as owner' do
|
|
before do
|
|
apply_authentication_headers_for group_stage_tournament.owner
|
|
end
|
|
|
|
it 'swaps positions of two matches from same group' do
|
|
original_first_position = first_match.position
|
|
original_last_position = last_match.position
|
|
|
|
expect(TournamentLiveBroadcast).to receive(:call).with(group_stage_tournament.id)
|
|
patch :swap, params: { id: first_match.to_param, other_match_id: last_match.to_param }
|
|
|
|
expect(response).to be_successful
|
|
expect(first_match.reload.position).to eq(original_last_position)
|
|
expect(last_match.reload.position).to eq(original_first_position)
|
|
|
|
body = deserialize_response(response)
|
|
expect(body.map { |match| match[:id] }).to match_array([first_match.id, last_match.id])
|
|
expect(body.map { |match| match[:position] }).to match_array([original_first_position, original_last_position])
|
|
end
|
|
|
|
it 'rejects matches from different groups' do
|
|
foreign_match = second_group.matches.order(:id).first
|
|
|
|
patch :swap, params: { id: first_match.to_param, other_match_id: foreign_match.to_param }
|
|
|
|
expect(response).to have_http_status(:unprocessable_content)
|
|
expect(deserialize_response(response)[:error]).to eq('Matches must be different group matches from the same group')
|
|
end
|
|
|
|
it 'rejects missing swap target' do
|
|
patch :swap, params: { id: first_match.to_param, other_match_id: Match.maximum(:id).to_i + 1 }
|
|
|
|
expect(response).to have_http_status(:not_found)
|
|
expect(deserialize_response(response)[:error]).to eq('Match not found')
|
|
end
|
|
end
|
|
|
|
context 'as another user' do
|
|
before do
|
|
apply_authentication_headers_for create(:user)
|
|
end
|
|
|
|
it 'renders a forbidden error response' do
|
|
patch :swap, params: { id: first_match.to_param, other_match_id: last_match.to_param }
|
|
|
|
expect(response).to have_http_status(:forbidden)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'PATCH #metadata' do
|
|
let(:group_stage_tournament) { create(:group_stage_tournament, group_count: 2, match_factory: :filled_group_match) }
|
|
|
|
context 'as owner' do
|
|
before do
|
|
apply_authentication_headers_for group_stage_tournament.owner
|
|
allow(TournamentSyncEnqueue).to receive(:call)
|
|
allow(TournamentLiveBroadcast).to receive(:call)
|
|
end
|
|
|
|
it 'updates selected matches by explicit ids' do
|
|
selected_matches = group_stage_tournament.matches.first(2)
|
|
|
|
patch :metadata, params: {
|
|
tournament_id: group_stage_tournament.to_param,
|
|
match_ids: selected_matches.map(&:id),
|
|
location: 'Court A',
|
|
start_time: '17:00',
|
|
notes: 'Bring player cards'
|
|
}
|
|
|
|
expect(response).to be_successful
|
|
expect(selected_matches.map { |match| match.reload.location }).to all(eq('Court A'))
|
|
expect(selected_matches.map { |match| match.reload.start_time }).to all(eq('17:00'))
|
|
expect(selected_matches.map { |match| match.reload.notes }).to all(eq('Bring player cards'))
|
|
expect(deserialize_response(response).map { |match| match[:id] }).to eq(selected_matches.map(&:id))
|
|
expect(TournamentSyncEnqueue).to have_received(:call).with(group_stage_tournament)
|
|
expect(TournamentLiveBroadcast).to have_received(:call).with(group_stage_tournament.id)
|
|
end
|
|
|
|
it 'updates group stage matches by position filter' do
|
|
patch :metadata, params: {
|
|
tournament_id: group_stage_tournament.to_param,
|
|
group_stage_position: 1,
|
|
start_time: '18:00'
|
|
}
|
|
|
|
expect(response).to be_successful
|
|
group_stage_tournament.matches.each do |match|
|
|
expected_start_time = match.group_match? && match.position == 1 ? '18:00' : nil
|
|
expect(match.reload.start_time).to eq(expected_start_time)
|
|
end
|
|
end
|
|
|
|
it 'updates playoff matches by stage level filter' do
|
|
playoff_tournament = create(:stage_tournament, stage_count: 3, user: group_stage_tournament.owner)
|
|
target_stage = playoff_tournament.stages.find_by!(level: 3)
|
|
|
|
patch :metadata, params: {
|
|
tournament_id: playoff_tournament.to_param,
|
|
stage_level: target_stage.level,
|
|
start_time: '21:00'
|
|
}
|
|
|
|
expect(response).to be_successful
|
|
playoff_tournament.matches.each do |match|
|
|
expected_start_time = match.stage == target_stage ? '21:00' : nil
|
|
expect(match.reload.start_time).to eq(expected_start_time)
|
|
end
|
|
end
|
|
|
|
it 'requires a selector' do
|
|
patch :metadata, params: { tournament_id: group_stage_tournament.to_param, start_time: '17:00' }
|
|
|
|
expect(response).to have_http_status(:bad_request)
|
|
expect(deserialize_response(response)[:error]).to eq('Select matches with match_ids, filters, or all=true')
|
|
end
|
|
|
|
it 'rejects matches outside the tournament' do
|
|
other_match = create(:match)
|
|
|
|
patch :metadata, params: {
|
|
tournament_id: group_stage_tournament.to_param,
|
|
match_ids: [other_match.id],
|
|
start_time: '17:00'
|
|
}
|
|
|
|
expect(response).to have_http_status(:not_found)
|
|
expect(deserialize_response(response)[:error]).to eq("Matches not found in tournament: #{other_match.id}")
|
|
end
|
|
|
|
it 'rejects read only follower tournaments' do
|
|
group_stage_tournament.update!(read_only_mode: true, sync_auth_token: 'shared-secret')
|
|
|
|
patch :metadata, params: {
|
|
tournament_id: group_stage_tournament.to_param,
|
|
match_ids: [group_stage_tournament.matches.first.id],
|
|
start_time: '17:00'
|
|
}
|
|
|
|
expect(response).to have_http_status(:locked)
|
|
expect(deserialize_response(response)[:error]).to eq('Tournament is in read only follower mode')
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'POST #update' do
|
|
context 'on a running playoff match' do
|
|
let(:valid_update) do
|
|
{
|
|
state: 'in_progress'
|
|
}
|
|
end
|
|
|
|
let(:invalid_update) do
|
|
{
|
|
state: 'finished'
|
|
}
|
|
end
|
|
|
|
let(:senseless_update) do
|
|
{
|
|
state: 'not_ready'
|
|
}
|
|
end
|
|
|
|
context 'as owner' do
|
|
before(:each) do
|
|
apply_authentication_headers_for @match.owner
|
|
end
|
|
|
|
context 'with valid params' do
|
|
it 'updates the match' do
|
|
expect(TournamentLiveBroadcast).to receive(:call).with(@match.tournament.id)
|
|
put :update, params: { id: @match.to_param }.merge(valid_update)
|
|
@match.reload
|
|
expect(response).to be_successful
|
|
expect(@match.state).to eq(valid_update[:state])
|
|
end
|
|
|
|
it 'renders a response with the updated match' do
|
|
put :update, params: { id: @match.to_param }.merge(valid_update)
|
|
expect(response).to be_successful
|
|
body = deserialize_response response
|
|
expect(body[:state]).to eq(valid_update[:state])
|
|
end
|
|
|
|
it 'updates metadata without changing match state' do
|
|
expect(TournamentLiveBroadcast).to receive(:call).with(@match.tournament.id)
|
|
|
|
put :update, params: {
|
|
id: @match.to_param,
|
|
location: 'Main Hall',
|
|
start_time: '17:00',
|
|
notes: 'Stream setup needed'
|
|
}
|
|
|
|
expect(response).to be_successful
|
|
@match.reload
|
|
expect(@match.state).to eq('not_started')
|
|
expect(@match.location).to eq('Main Hall')
|
|
expect(@match.start_time).to eq('17:00')
|
|
expect(@match.notes).to eq('Stream setup needed')
|
|
expect(deserialize_response(response)).to include(
|
|
location: 'Main Hall',
|
|
start_time: '17:00',
|
|
notes: 'Stream setup needed'
|
|
)
|
|
end
|
|
|
|
it 'writes a transaction log entry for the state change' do
|
|
expect(TournamentLiveBroadcast).to receive(:call).with(@match.tournament.id)
|
|
|
|
expect do
|
|
put :update, params: { id: @match.to_param }.merge(valid_update)
|
|
end.to change { @match.tournament.transaction_log_entries.count }.by(1)
|
|
|
|
entry = @match.tournament.transaction_log_entries.last
|
|
expect(entry.action).to eq('match.state_changed')
|
|
expect(entry.sequence).to eq(1)
|
|
expect(entry.message).to include("changed match #{@match.id}")
|
|
expect(entry.message).to include('running')
|
|
expect(entry.metadata['new_state']).to eq('in_progress')
|
|
end
|
|
|
|
it 'stops an in-progress match and resets its scores' do
|
|
@match.update!(state: :in_progress)
|
|
@match.match_scores.each do |match_score|
|
|
match_score.update!(points: 7, hidden_points: 5)
|
|
end
|
|
|
|
expect(TournamentLiveBroadcast).to receive(:call).with(@match.tournament.id)
|
|
put :update, params: { id: @match.to_param, state: 'not_started' }
|
|
|
|
expect(response).to be_successful
|
|
expect(@match.reload.state).to eq('not_started')
|
|
expect(@match.match_scores.reload.map(&:points)).to all(eq(0))
|
|
expect(@match.match_scores.reload.map(&:hidden_points)).to all(eq(0))
|
|
end
|
|
|
|
context 'on a running playoff match' do
|
|
let(:finished) do
|
|
{
|
|
state: 'finished'
|
|
}
|
|
end
|
|
|
|
before(:each) do
|
|
apply_authentication_headers_for @running_playoff_match.owner
|
|
end
|
|
|
|
context 'match update succeeds' do
|
|
context 'on a decided match' do
|
|
before do
|
|
@running_playoff_match.match_scores.each_with_index do |ms, i|
|
|
ms.points = i
|
|
ms.save!
|
|
end
|
|
put :update, params: { id: @running_playoff_match.to_param }.merge(finished)
|
|
@running_playoff_match.reload
|
|
end
|
|
|
|
it 'updates the matches status' do
|
|
expect(response).to be_successful
|
|
expect(@running_playoff_match.state).to eq(finished[:state])
|
|
end
|
|
|
|
describe 'updates the match below' do
|
|
before do
|
|
@match_below = @tournament.stages.find_by(level: @amount_of_stages - 1).matches
|
|
.find_by(position: @running_playoff_match.position / 2).reload
|
|
end
|
|
|
|
it 'with the right teams' do
|
|
expect(@running_playoff_match.winner).to be_a(Team)
|
|
expect(@match_below.teams).to include(@running_playoff_match.winner)
|
|
end
|
|
|
|
it 'with the right status' do
|
|
expect(@match_below.state).to eq('not_ready')
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'on an undecided match' do
|
|
before do
|
|
@running_playoff_match.match_scores.each do |ms|
|
|
ms.points = 42
|
|
ms.save!
|
|
end
|
|
put :update, params: { id: @running_playoff_match.to_param }.merge(finished)
|
|
@running_playoff_match.reload
|
|
end
|
|
|
|
it 'returns an unprocessable entity response' do
|
|
expect(response).to have_http_status(:unprocessable_content)
|
|
end
|
|
|
|
it 'doesn\'t change the matches status' do
|
|
expect(@running_playoff_match.state).to eq('in_progress')
|
|
end
|
|
|
|
describe 'doesn\'t update the match below' do
|
|
before do
|
|
@match_below = @tournament.stages.find_by(level: @amount_of_stages - 1).matches
|
|
.find_by(position: @running_playoff_match.position / 2).reload
|
|
end
|
|
|
|
it 'teams' do
|
|
expect(@match_below.teams.empty?).to be(true)
|
|
end
|
|
|
|
it 'status' do
|
|
expect(@match_below.state).to eq('not_ready')
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'match update fails' do
|
|
before do
|
|
allow_any_instance_of(Match)
|
|
.to receive(:update)
|
|
.and_return(false)
|
|
end
|
|
|
|
it 'returns unprocessable entity' do
|
|
put :update, params: { id: @running_playoff_match.to_param }.merge(finished)
|
|
expect(response).to have_http_status(:unprocessable_content)
|
|
end
|
|
end
|
|
|
|
context 'PopulateMatchBelowAndSave fails' do
|
|
before do
|
|
expect(PopulateMatchBelowAndSave).to receive(:call).once.with(
|
|
match: have_attributes(id: @running_playoff_match.id)
|
|
)
|
|
.and_return(context)
|
|
end
|
|
|
|
context 'when unsuccessful' do
|
|
let(:context) { double(:context, success?: false) }
|
|
|
|
it 'returns unprocessable entity' do
|
|
# mock match.winner to be the first team of the match to skip winner check here
|
|
allow_any_instance_of(Match).to receive(:winner).and_return(@running_playoff_match.match_scores.first.team)
|
|
|
|
put :update, params: { id: @running_playoff_match.to_param }.merge(finished)
|
|
expect(response).to have_http_status(:unprocessable_content)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'on the last match in the tournament' do
|
|
let(:updated_finale) do
|
|
only_final_tournament = create(:stage_tournament, stage_count: 1)
|
|
finale = only_final_tournament.stages.first.matches.first
|
|
|
|
finale.match_scores.each_with_index do |ms, i|
|
|
ms.points = i
|
|
ms.save!
|
|
end
|
|
|
|
apply_authentication_headers_for finale.owner
|
|
put :update, params: { id: finale.to_param }.merge(finished)
|
|
finale.reload
|
|
end
|
|
|
|
it 'response is successful' do
|
|
expect(response).to be_successful
|
|
end
|
|
|
|
it 'updates the matches status' do
|
|
expect(updated_finale.state).to eq(finished[:state])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'with invalid params' do
|
|
it 'renders an unprocessable entity response' do
|
|
put :update, params: { id: @match.to_param }.merge(invalid_update)
|
|
expect(response).to have_http_status(:unprocessable_content)
|
|
end
|
|
end
|
|
|
|
context 'with senseless params' do
|
|
it 'renders an unprocessable entity response' do
|
|
put :update, params: { id: @match.to_param }.merge(senseless_update)
|
|
expect(response).to have_http_status(:unprocessable_content)
|
|
end
|
|
end
|
|
|
|
context 'with stop params on a not-started match' do
|
|
it 'renders an unprocessable entity response' do
|
|
put :update, params: { id: @match.to_param, state: 'not_started' }
|
|
expect(response).to have_http_status(:unprocessable_content)
|
|
expect(deserialize_response(response)[:error]).to eq("Match can't stop in this state")
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'as another user' do
|
|
context 'with valid params' do
|
|
before(:each) do
|
|
apply_authentication_headers_for create(:user)
|
|
end
|
|
|
|
it 'renders a forbidden error response' do
|
|
put :update, params: { id: @match.to_param }.merge(valid_update)
|
|
expect(response).to have_http_status(:forbidden)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'on a running group match' do
|
|
let(:tournament) { create(:group_stage_tournament, group_count: 1, match_factory: :filled_group_match) }
|
|
let(:group) { tournament.stages.find_by(level: -1).groups.first }
|
|
let(:group_match) { group.matches.first }
|
|
|
|
before do
|
|
apply_authentication_headers_for tournament.owner
|
|
group_match.update!(state: :in_progress)
|
|
group_match.match_scores.order(:id).each_with_index do |match_score, index|
|
|
match_score.update!(points: index.zero? ? 9 : 2, hidden_points: index.zero? ? 4 : 1)
|
|
end
|
|
UpdateGroupsGroupScoresAndSave.call(group: group)
|
|
end
|
|
|
|
it 'stops the match, clears scores, and recalculates group scores' do
|
|
put :update, params: { id: group_match.to_param, state: 'not_started' }
|
|
|
|
expect(response).to be_successful
|
|
expect(group_match.reload.state).to eq('not_started')
|
|
expect(group_match.match_scores.reload.map(&:points)).to all(eq(0))
|
|
expect(group_match.match_scores.reload.map(&:hidden_points)).to all(eq(0))
|
|
involved_group_scores = group.group_scores.reload.select { |score| group_match.teams.include?(score.team) }
|
|
expect(involved_group_scores.map(&:group_points)).to all(eq(0))
|
|
expect(involved_group_scores.map(&:scored_points)).to all(eq(0))
|
|
expect(involved_group_scores.map(&:received_points)).to all(eq(0))
|
|
end
|
|
end
|
|
|
|
context 'on a playoff match that isn\'t ready yet' do
|
|
let(:invalid_update) do
|
|
{
|
|
state: 'in_progress'
|
|
}
|
|
end
|
|
|
|
context 'as owner' do
|
|
before(:each) do
|
|
apply_authentication_headers_for @not_ready_playoff_match.owner
|
|
end
|
|
|
|
context 'with invalid params' do
|
|
it 'renders an unprocessable entity response' do
|
|
put :update, params: { id: @not_ready_playoff_match.to_param }.merge(invalid_update)
|
|
expect(response).to have_http_status(:unprocessable_content)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|