66 lines
3.8 KiB
Ruby
66 lines
3.8 KiB
Ruby
#!/usr/bin/env ruby
|
|
# frozen_string_literal: true
|
|
|
|
require_relative '../e2e/lib/scenario_runner'
|
|
|
|
def assert_equal(expected, actual, label)
|
|
return if expected == actual
|
|
|
|
raise "#{label}: expected #{expected.inspect}, got #{actual.inspect}"
|
|
end
|
|
|
|
def assert(condition, label)
|
|
return if condition
|
|
|
|
raise label
|
|
end
|
|
|
|
runner = TurniereE2E::ScenarioRunner.new(
|
|
base_url: ENV.fetch('TURNIERE_E2E_BASE_URL', 'http://127.0.0.1:3000'),
|
|
email: ENV.fetch('TURNIERE_E2E_EMAIL'),
|
|
password: ENV.fetch('TURNIERE_E2E_PASSWORD'),
|
|
username: ENV['TURNIERE_E2E_USERNAME']
|
|
)
|
|
|
|
puts 'Verifying main 4x4 group-stage lifecycle...'
|
|
main_result = runner.run_group_stage_main_usecase
|
|
assert_equal(8, main_result.dig(:checkpoints, :created, :playoff_teams_amount), 'main playoff_teams_amount')
|
|
assert_equal(8, main_result.dig(:checkpoints, :created, :instant_finalists_amount), 'main instant_finalists_amount')
|
|
assert_equal(0, main_result.dig(:checkpoints, :created, :intermediate_round_participants_amount), 'main intermediate_round_participants_amount')
|
|
assert_equal(4, main_result.dig(:checkpoints, :upcoming_group_matches, :match_ids).count, 'main upcoming_group_matches count')
|
|
assert_equal(16, main_result.dig(:checkpoints, :statistics, :group_scores_count), 'main group_scores_count')
|
|
main_playoff_entry_stage = main_result.dig(:checkpoints, :playoffs_created, :stage_summaries)
|
|
.select { |stage| stage[:level] != -1 }
|
|
.max_by { |stage| stage[:level] }
|
|
assert_equal(4, main_playoff_entry_stage[:match_states].count, 'main playoff entry match count')
|
|
main_final_attempt = main_result.dig(:checkpoints, :final_finish_attempted, :finish_attempt)
|
|
assert_equal(422, main_final_attempt[:status], 'main final finish status')
|
|
assert_equal('Moving Team one stage down failed', main_final_attempt.dig(:body, :error), 'main final finish error')
|
|
|
|
puts 'Verifying 3-group intermediate-round lifecycle...'
|
|
intermediate_result = runner.run_group_stage_intermediate_round
|
|
intermediate_created = intermediate_result.fetch(:checkpoints).fetch(:created)
|
|
assert_equal(4, intermediate_created[:playoff_teams_amount], 'intermediate playoff_teams_amount')
|
|
assert_equal(3, intermediate_created[:instant_finalists_amount], 'intermediate instant_finalists_amount')
|
|
assert_equal(2, intermediate_created[:intermediate_round_participants_amount], 'intermediate intermediate_round_participants_amount')
|
|
intermediate_playoff_entry_stage = intermediate_result.dig(:checkpoints, :playoffs_created, :stage_summaries)
|
|
.select { |stage| stage[:level] != -1 }
|
|
.max_by { |stage| stage[:level] }
|
|
assert_equal('intermediate_stage', intermediate_playoff_entry_stage[:state], 'intermediate stage state')
|
|
assert_equal(3, intermediate_playoff_entry_stage[:match_states].count('single_team'), 'intermediate single_team count')
|
|
assert_equal(1, intermediate_playoff_entry_stage[:match_states].count('not_started'), 'intermediate not_started count')
|
|
intermediate_final_attempt = intermediate_result.dig(:checkpoints, :final_finish_attempted, :finish_attempt)
|
|
assert_equal(422, intermediate_final_attempt[:status], 'intermediate final finish status')
|
|
assert_equal('Moving Team one stage down failed', intermediate_final_attempt.dig(:body, :error), 'intermediate final finish error')
|
|
|
|
[2, 3, 5, 8].each do |team_count|
|
|
puts "Verifying playoff-only lifecycle for #{team_count} teams..."
|
|
playoff_result = runner.run_playoff_only(team_count: team_count)
|
|
final_stage = playoff_result.dig(:checkpoints, :completed, :stage_summaries)
|
|
.find { |stage| stage[:level] == 0 }
|
|
assert(final_stage, "missing final stage for playoff-only #{team_count}")
|
|
assert_equal(['finished'], final_stage[:match_states], "playoff-only #{team_count} final stage")
|
|
end
|
|
|
|
puts 'Blackbox verification passed.'
|