mirror of
https://github.com/Team254/cheesy-arena-lite.git
synced 2026-03-09 21:56:50 -04:00
797 lines
30 KiB
Go
797 lines
30 KiB
Go
// Copyright 2014 Team 254. All Rights Reserved.
|
|
// Author: pat@patfairbank.com (Patrick Fairbank)
|
|
|
|
package tournament
|
|
|
|
import (
|
|
"github.com/Team254/cheesy-arena/model"
|
|
"github.com/stretchr/testify/assert"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestEliminationScheduleInitial(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
CreateTestAlliances(database, 2)
|
|
_, err := UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err := database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 3, len(matches)) {
|
|
assertMatch(t, matches[0], "F-1", 1, 2)
|
|
assertMatch(t, matches[1], "F-2", 1, 2)
|
|
assertMatch(t, matches[2], "F-3", 1, 2)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 3)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 6, len(matches)) {
|
|
assertMatch(t, matches[0], "SF2-1", 2, 3)
|
|
assertMatch(t, matches[1], "SF2-2", 2, 3)
|
|
assertMatch(t, matches[2], "SF2-3", 2, 3)
|
|
assertMatch(t, matches[3], "F-1", 1, 0)
|
|
assertMatch(t, matches[4], "F-2", 1, 0)
|
|
assertMatch(t, matches[5], "F-3", 1, 0)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 4)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 6, len(matches)) {
|
|
assertMatch(t, matches[0], "SF1-1", 1, 4)
|
|
assertMatch(t, matches[1], "SF2-1", 2, 3)
|
|
assertMatch(t, matches[2], "SF1-2", 1, 4)
|
|
assertMatch(t, matches[3], "SF2-2", 2, 3)
|
|
assertMatch(t, matches[4], "SF1-3", 1, 4)
|
|
assertMatch(t, matches[5], "SF2-3", 2, 3)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 5)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 9, len(matches)) {
|
|
assertMatch(t, matches[0], "QF2-1", 4, 5)
|
|
assertMatch(t, matches[1], "QF2-2", 4, 5)
|
|
assertMatch(t, matches[2], "QF2-3", 4, 5)
|
|
assertMatch(t, matches[3], "SF1-1", 1, 0)
|
|
assertMatch(t, matches[4], "SF2-1", 2, 3)
|
|
assertMatch(t, matches[5], "SF1-2", 1, 0)
|
|
assertMatch(t, matches[6], "SF2-2", 2, 3)
|
|
assertMatch(t, matches[7], "SF1-3", 1, 0)
|
|
assertMatch(t, matches[8], "SF2-3", 2, 3)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 6)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 12, len(matches)) {
|
|
assertMatch(t, matches[0], "QF2-1", 4, 5)
|
|
assertMatch(t, matches[1], "QF4-1", 3, 6)
|
|
assertMatch(t, matches[2], "QF2-2", 4, 5)
|
|
assertMatch(t, matches[3], "QF4-2", 3, 6)
|
|
assertMatch(t, matches[4], "QF2-3", 4, 5)
|
|
assertMatch(t, matches[5], "QF4-3", 3, 6)
|
|
assertMatch(t, matches[6], "SF1-1", 1, 0)
|
|
assertMatch(t, matches[7], "SF2-1", 2, 0)
|
|
assertMatch(t, matches[8], "SF1-2", 1, 0)
|
|
assertMatch(t, matches[9], "SF2-2", 2, 0)
|
|
assertMatch(t, matches[10], "SF1-3", 1, 0)
|
|
assertMatch(t, matches[11], "SF2-3", 2, 0)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 7)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 12, len(matches)) {
|
|
assertMatch(t, matches[0], "QF2-1", 4, 5)
|
|
assertMatch(t, matches[1], "QF3-1", 2, 7)
|
|
assertMatch(t, matches[2], "QF4-1", 3, 6)
|
|
assertMatch(t, matches[3], "QF2-2", 4, 5)
|
|
assertMatch(t, matches[4], "QF3-2", 2, 7)
|
|
assertMatch(t, matches[5], "QF4-2", 3, 6)
|
|
assertMatch(t, matches[6], "QF2-3", 4, 5)
|
|
assertMatch(t, matches[7], "QF3-3", 2, 7)
|
|
assertMatch(t, matches[8], "QF4-3", 3, 6)
|
|
assertMatch(t, matches[9], "SF1-1", 1, 0)
|
|
assertMatch(t, matches[10], "SF1-2", 1, 0)
|
|
assertMatch(t, matches[11], "SF1-3", 1, 0)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 8)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 12, len(matches)) {
|
|
assertMatch(t, matches[0], "QF1-1", 1, 8)
|
|
assertMatch(t, matches[1], "QF2-1", 4, 5)
|
|
assertMatch(t, matches[2], "QF3-1", 2, 7)
|
|
assertMatch(t, matches[3], "QF4-1", 3, 6)
|
|
assertMatch(t, matches[4], "QF1-2", 1, 8)
|
|
assertMatch(t, matches[5], "QF2-2", 4, 5)
|
|
assertMatch(t, matches[6], "QF3-2", 2, 7)
|
|
assertMatch(t, matches[7], "QF4-2", 3, 6)
|
|
assertMatch(t, matches[8], "QF1-3", 1, 8)
|
|
assertMatch(t, matches[9], "QF2-3", 4, 5)
|
|
assertMatch(t, matches[10], "QF3-3", 2, 7)
|
|
assertMatch(t, matches[11], "QF4-3", 3, 6)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 9)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 15, len(matches)) {
|
|
assertMatch(t, matches[0], "EF2-1", 8, 9)
|
|
assertMatch(t, matches[1], "EF2-2", 8, 9)
|
|
assertMatch(t, matches[2], "EF2-3", 8, 9)
|
|
assertMatch(t, matches[3], "QF1-1", 1, 0)
|
|
assertMatch(t, matches[4], "QF2-1", 4, 5)
|
|
assertMatch(t, matches[5], "QF3-1", 2, 7)
|
|
assertMatch(t, matches[6], "QF4-1", 3, 6)
|
|
assertMatch(t, matches[7], "QF1-2", 1, 0)
|
|
assertMatch(t, matches[8], "QF2-2", 4, 5)
|
|
assertMatch(t, matches[9], "QF3-2", 2, 7)
|
|
assertMatch(t, matches[10], "QF4-2", 3, 6)
|
|
assertMatch(t, matches[11], "QF1-3", 1, 0)
|
|
assertMatch(t, matches[12], "QF2-3", 4, 5)
|
|
assertMatch(t, matches[13], "QF3-3", 2, 7)
|
|
assertMatch(t, matches[14], "QF4-3", 3, 6)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 10)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 18, len(matches)) {
|
|
assertMatch(t, matches[0], "EF2-1", 8, 9)
|
|
assertMatch(t, matches[1], "EF6-1", 7, 10)
|
|
assertMatch(t, matches[2], "EF2-2", 8, 9)
|
|
assertMatch(t, matches[3], "EF6-2", 7, 10)
|
|
assertMatch(t, matches[4], "EF2-3", 8, 9)
|
|
assertMatch(t, matches[5], "EF6-3", 7, 10)
|
|
assertMatch(t, matches[6], "QF1-1", 1, 0)
|
|
assertMatch(t, matches[7], "QF2-1", 4, 5)
|
|
assertMatch(t, matches[8], "QF3-1", 2, 0)
|
|
assertMatch(t, matches[9], "QF4-1", 3, 6)
|
|
assertMatch(t, matches[10], "QF1-2", 1, 0)
|
|
assertMatch(t, matches[11], "QF2-2", 4, 5)
|
|
assertMatch(t, matches[12], "QF3-2", 2, 0)
|
|
assertMatch(t, matches[13], "QF4-2", 3, 6)
|
|
assertMatch(t, matches[14], "QF1-3", 1, 0)
|
|
assertMatch(t, matches[15], "QF2-3", 4, 5)
|
|
assertMatch(t, matches[16], "QF3-3", 2, 0)
|
|
assertMatch(t, matches[17], "QF4-3", 3, 6)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 11)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 21, len(matches)) {
|
|
assertMatch(t, matches[0], "EF2-1", 8, 9)
|
|
assertMatch(t, matches[1], "EF6-1", 7, 10)
|
|
assertMatch(t, matches[2], "EF8-1", 6, 11)
|
|
assertMatch(t, matches[3], "EF2-2", 8, 9)
|
|
assertMatch(t, matches[4], "EF6-2", 7, 10)
|
|
assertMatch(t, matches[5], "EF8-2", 6, 11)
|
|
assertMatch(t, matches[6], "EF2-3", 8, 9)
|
|
assertMatch(t, matches[7], "EF6-3", 7, 10)
|
|
assertMatch(t, matches[8], "EF8-3", 6, 11)
|
|
assertMatch(t, matches[9], "QF1-1", 1, 0)
|
|
assertMatch(t, matches[10], "QF2-1", 4, 5)
|
|
assertMatch(t, matches[11], "QF3-1", 2, 0)
|
|
assertMatch(t, matches[12], "QF4-1", 3, 0)
|
|
assertMatch(t, matches[13], "QF1-2", 1, 0)
|
|
assertMatch(t, matches[14], "QF2-2", 4, 5)
|
|
assertMatch(t, matches[15], "QF3-2", 2, 0)
|
|
assertMatch(t, matches[16], "QF4-2", 3, 0)
|
|
assertMatch(t, matches[17], "QF1-3", 1, 0)
|
|
assertMatch(t, matches[18], "QF2-3", 4, 5)
|
|
assertMatch(t, matches[19], "QF3-3", 2, 0)
|
|
assertMatch(t, matches[20], "QF4-3", 3, 0)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 12)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 24, len(matches)) {
|
|
assertMatch(t, matches[0], "EF2-1", 8, 9)
|
|
assertMatch(t, matches[1], "EF4-1", 5, 12)
|
|
assertMatch(t, matches[2], "EF6-1", 7, 10)
|
|
assertMatch(t, matches[3], "EF8-1", 6, 11)
|
|
assertMatch(t, matches[4], "EF2-2", 8, 9)
|
|
assertMatch(t, matches[5], "EF4-2", 5, 12)
|
|
assertMatch(t, matches[6], "EF6-2", 7, 10)
|
|
assertMatch(t, matches[7], "EF8-2", 6, 11)
|
|
assertMatch(t, matches[8], "EF2-3", 8, 9)
|
|
assertMatch(t, matches[9], "EF4-3", 5, 12)
|
|
assertMatch(t, matches[10], "EF6-3", 7, 10)
|
|
assertMatch(t, matches[11], "EF8-3", 6, 11)
|
|
assertMatch(t, matches[12], "QF1-1", 1, 0)
|
|
assertMatch(t, matches[13], "QF2-1", 4, 0)
|
|
assertMatch(t, matches[14], "QF3-1", 2, 0)
|
|
assertMatch(t, matches[15], "QF4-1", 3, 0)
|
|
assertMatch(t, matches[16], "QF1-2", 1, 0)
|
|
assertMatch(t, matches[17], "QF2-2", 4, 0)
|
|
assertMatch(t, matches[18], "QF3-2", 2, 0)
|
|
assertMatch(t, matches[19], "QF4-2", 3, 0)
|
|
assertMatch(t, matches[20], "QF1-3", 1, 0)
|
|
assertMatch(t, matches[21], "QF2-3", 4, 0)
|
|
assertMatch(t, matches[22], "QF3-3", 2, 0)
|
|
assertMatch(t, matches[23], "QF4-3", 3, 0)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 13)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 24, len(matches)) {
|
|
assertMatch(t, matches[0], "EF2-1", 8, 9)
|
|
assertMatch(t, matches[1], "EF3-1", 4, 13)
|
|
assertMatch(t, matches[2], "EF4-1", 5, 12)
|
|
assertMatch(t, matches[3], "EF6-1", 7, 10)
|
|
assertMatch(t, matches[4], "EF8-1", 6, 11)
|
|
assertMatch(t, matches[5], "EF2-2", 8, 9)
|
|
assertMatch(t, matches[6], "EF3-2", 4, 13)
|
|
assertMatch(t, matches[7], "EF4-2", 5, 12)
|
|
assertMatch(t, matches[8], "EF6-2", 7, 10)
|
|
assertMatch(t, matches[9], "EF8-2", 6, 11)
|
|
assertMatch(t, matches[10], "EF2-3", 8, 9)
|
|
assertMatch(t, matches[11], "EF3-3", 4, 13)
|
|
assertMatch(t, matches[12], "EF4-3", 5, 12)
|
|
assertMatch(t, matches[13], "EF6-3", 7, 10)
|
|
assertMatch(t, matches[14], "EF8-3", 6, 11)
|
|
assertMatch(t, matches[15], "QF1-1", 1, 0)
|
|
assertMatch(t, matches[16], "QF3-1", 2, 0)
|
|
assertMatch(t, matches[17], "QF4-1", 3, 0)
|
|
assertMatch(t, matches[18], "QF1-2", 1, 0)
|
|
assertMatch(t, matches[19], "QF3-2", 2, 0)
|
|
assertMatch(t, matches[20], "QF4-2", 3, 0)
|
|
assertMatch(t, matches[21], "QF1-3", 1, 0)
|
|
assertMatch(t, matches[22], "QF3-3", 2, 0)
|
|
assertMatch(t, matches[23], "QF4-3", 3, 0)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 14)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 24, len(matches)) {
|
|
assertMatch(t, matches[0], "EF2-1", 8, 9)
|
|
assertMatch(t, matches[1], "EF3-1", 4, 13)
|
|
assertMatch(t, matches[2], "EF4-1", 5, 12)
|
|
assertMatch(t, matches[3], "EF6-1", 7, 10)
|
|
assertMatch(t, matches[4], "EF7-1", 3, 14)
|
|
assertMatch(t, matches[5], "EF8-1", 6, 11)
|
|
assertMatch(t, matches[6], "EF2-2", 8, 9)
|
|
assertMatch(t, matches[7], "EF3-2", 4, 13)
|
|
assertMatch(t, matches[8], "EF4-2", 5, 12)
|
|
assertMatch(t, matches[9], "EF6-2", 7, 10)
|
|
assertMatch(t, matches[10], "EF7-2", 3, 14)
|
|
assertMatch(t, matches[11], "EF8-2", 6, 11)
|
|
assertMatch(t, matches[12], "EF2-3", 8, 9)
|
|
assertMatch(t, matches[13], "EF3-3", 4, 13)
|
|
assertMatch(t, matches[14], "EF4-3", 5, 12)
|
|
assertMatch(t, matches[15], "EF6-3", 7, 10)
|
|
assertMatch(t, matches[16], "EF7-3", 3, 14)
|
|
assertMatch(t, matches[17], "EF8-3", 6, 11)
|
|
assertMatch(t, matches[18], "QF1-1", 1, 0)
|
|
assertMatch(t, matches[19], "QF3-1", 2, 0)
|
|
assertMatch(t, matches[20], "QF1-2", 1, 0)
|
|
assertMatch(t, matches[21], "QF3-2", 2, 0)
|
|
assertMatch(t, matches[22], "QF1-3", 1, 0)
|
|
assertMatch(t, matches[23], "QF3-3", 2, 0)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 15)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 24, len(matches)) {
|
|
assertMatch(t, matches[0], "EF2-1", 8, 9)
|
|
assertMatch(t, matches[1], "EF3-1", 4, 13)
|
|
assertMatch(t, matches[2], "EF4-1", 5, 12)
|
|
assertMatch(t, matches[3], "EF5-1", 2, 15)
|
|
assertMatch(t, matches[4], "EF6-1", 7, 10)
|
|
assertMatch(t, matches[5], "EF7-1", 3, 14)
|
|
assertMatch(t, matches[6], "EF8-1", 6, 11)
|
|
assertMatch(t, matches[7], "EF2-2", 8, 9)
|
|
assertMatch(t, matches[8], "EF3-2", 4, 13)
|
|
assertMatch(t, matches[9], "EF4-2", 5, 12)
|
|
assertMatch(t, matches[10], "EF5-2", 2, 15)
|
|
assertMatch(t, matches[11], "EF6-2", 7, 10)
|
|
assertMatch(t, matches[12], "EF7-2", 3, 14)
|
|
assertMatch(t, matches[13], "EF8-2", 6, 11)
|
|
assertMatch(t, matches[14], "EF2-3", 8, 9)
|
|
assertMatch(t, matches[15], "EF3-3", 4, 13)
|
|
assertMatch(t, matches[16], "EF4-3", 5, 12)
|
|
assertMatch(t, matches[17], "EF5-3", 2, 15)
|
|
assertMatch(t, matches[18], "EF6-3", 7, 10)
|
|
assertMatch(t, matches[19], "EF7-3", 3, 14)
|
|
assertMatch(t, matches[20], "EF8-3", 6, 11)
|
|
assertMatch(t, matches[21], "QF1-1", 1, 0)
|
|
assertMatch(t, matches[22], "QF1-2", 1, 0)
|
|
assertMatch(t, matches[23], "QF1-3", 1, 0)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
|
|
CreateTestAlliances(database, 16)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 24, len(matches)) {
|
|
assertMatch(t, matches[0], "EF1-1", 1, 16)
|
|
assertMatch(t, matches[1], "EF2-1", 8, 9)
|
|
assertMatch(t, matches[2], "EF3-1", 4, 13)
|
|
assertMatch(t, matches[3], "EF4-1", 5, 12)
|
|
assertMatch(t, matches[4], "EF5-1", 2, 15)
|
|
assertMatch(t, matches[5], "EF6-1", 7, 10)
|
|
assertMatch(t, matches[6], "EF7-1", 3, 14)
|
|
assertMatch(t, matches[7], "EF8-1", 6, 11)
|
|
assertMatch(t, matches[8], "EF1-2", 1, 16)
|
|
assertMatch(t, matches[9], "EF2-2", 8, 9)
|
|
assertMatch(t, matches[10], "EF3-2", 4, 13)
|
|
assertMatch(t, matches[11], "EF4-2", 5, 12)
|
|
assertMatch(t, matches[12], "EF5-2", 2, 15)
|
|
assertMatch(t, matches[13], "EF6-2", 7, 10)
|
|
assertMatch(t, matches[14], "EF7-2", 3, 14)
|
|
assertMatch(t, matches[15], "EF8-2", 6, 11)
|
|
assertMatch(t, matches[16], "EF1-3", 1, 16)
|
|
assertMatch(t, matches[17], "EF2-3", 8, 9)
|
|
assertMatch(t, matches[18], "EF3-3", 4, 13)
|
|
assertMatch(t, matches[19], "EF4-3", 5, 12)
|
|
assertMatch(t, matches[20], "EF5-3", 2, 15)
|
|
assertMatch(t, matches[21], "EF6-3", 7, 10)
|
|
assertMatch(t, matches[22], "EF7-3", 3, 14)
|
|
assertMatch(t, matches[23], "EF8-3", 6, 11)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
}
|
|
|
|
func TestEliminationScheduleErrors(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
CreateTestAlliances(database, 1)
|
|
_, err := UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
if assert.NotNil(t, err) {
|
|
assert.Equal(t, "Must have at least 2 alliances", err.Error())
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
|
|
CreateTestAlliances(database, 17)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
if assert.NotNil(t, err) {
|
|
assert.Equal(t, "Round of depth 32 is not supported", err.Error())
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
|
|
database.CreateAllianceTeam(&model.AllianceTeam{0, 1, 0, 1})
|
|
database.CreateAllianceTeam(&model.AllianceTeam{0, 1, 1, 2})
|
|
database.CreateAllianceTeam(&model.AllianceTeam{0, 2, 0, 3})
|
|
database.CreateAllianceTeam(&model.AllianceTeam{0, 2, 1, 4})
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
if assert.NotNil(t, err) {
|
|
assert.Equal(t, "Alliances must consist of at least 3 teams", err.Error())
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
}
|
|
|
|
func TestEliminationSchedulePopulatePartialMatch(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
// Final should be updated after semifinal is concluded.
|
|
CreateTestAlliances(database, 3)
|
|
UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "SF2-1", model.BlueWonMatch)
|
|
scoreMatch(database, "SF2-2", model.BlueWonMatch)
|
|
_, err := UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err := database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 5, len(matches)) {
|
|
assertMatch(t, matches[2], "F-1", 1, 3)
|
|
assertMatch(t, matches[3], "F-2", 1, 3)
|
|
assertMatch(t, matches[4], "F-3", 1, 3)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
database.TruncateMatchResults()
|
|
|
|
// Final should be generated and populated as both semifinals conclude.
|
|
CreateTestAlliances(database, 4)
|
|
UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "SF2-1", model.RedWonMatch)
|
|
scoreMatch(database, "SF2-2", model.RedWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 8, len(matches)) {
|
|
assertMatch(t, matches[5], "F-1", 0, 2)
|
|
assertMatch(t, matches[6], "F-2", 0, 2)
|
|
assertMatch(t, matches[7], "F-3", 0, 2)
|
|
}
|
|
scoreMatch(database, "SF1-1", model.RedWonMatch)
|
|
scoreMatch(database, "SF1-2", model.RedWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 7, len(matches)) {
|
|
assertMatch(t, matches[4], "F-1", 1, 2)
|
|
assertMatch(t, matches[5], "F-2", 1, 2)
|
|
assertMatch(t, matches[6], "F-3", 1, 2)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
database.TruncateMatchResults()
|
|
}
|
|
|
|
func TestEliminationScheduleCreateNextRound(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
CreateTestAlliances(database, 4)
|
|
UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "SF1-1", model.BlueWonMatch)
|
|
_, err := UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, _ := database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 6, len(matches))
|
|
scoreMatch(database, "SF2-1", model.BlueWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 6, len(matches))
|
|
scoreMatch(database, "SF1-2", model.BlueWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 8, len(matches))
|
|
scoreMatch(database, "SF2-2", model.BlueWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
if assert.Equal(t, 7, len(matches)) {
|
|
assertMatch(t, matches[4], "F-1", 4, 3)
|
|
assertMatch(t, matches[5], "F-2", 4, 3)
|
|
assertMatch(t, matches[6], "F-3", 4, 3)
|
|
}
|
|
}
|
|
|
|
func TestEliminationScheduleDetermineWinner(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
// Round with one tie and a sweep.
|
|
CreateTestAlliances(database, 2)
|
|
UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "F-1", model.TieMatch)
|
|
won, err := UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
assert.False(t, won)
|
|
matches, _ := database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 3, len(matches))
|
|
scoreMatch(database, "F-2", model.BlueWonMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
assert.False(t, won)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 3, len(matches))
|
|
scoreMatch(database, "F-3", model.BlueWonMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
if assert.Nil(t, err) {
|
|
assert.True(t, won)
|
|
}
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 3, len(matches))
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
database.TruncateMatchResults()
|
|
|
|
// Round with one tie and a split.
|
|
CreateTestAlliances(database, 2)
|
|
UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "F-1", model.RedWonMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
assert.False(t, won)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 3, len(matches))
|
|
scoreMatch(database, "F-2", model.TieMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
assert.False(t, won)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 3, len(matches))
|
|
scoreMatch(database, "F-3", model.BlueWonMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
assert.False(t, won)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 4, len(matches))
|
|
assert.Equal(t, "F-4", matches[3].DisplayName)
|
|
scoreMatch(database, "F-4", model.TieMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
assert.False(t, won)
|
|
scoreMatch(database, "F-5", model.RedWonMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
if assert.Nil(t, err) {
|
|
assert.True(t, won)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
database.TruncateMatchResults()
|
|
|
|
// Round with two ties.
|
|
CreateTestAlliances(database, 2)
|
|
UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "F-1", model.TieMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
assert.False(t, won)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 3, len(matches))
|
|
scoreMatch(database, "F-2", model.BlueWonMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
assert.False(t, won)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 3, len(matches))
|
|
scoreMatch(database, "F-3", model.TieMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
assert.False(t, won)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 5, len(matches))
|
|
assert.Equal(t, "F-4", matches[3].DisplayName)
|
|
assert.Equal(t, "F-5", matches[4].DisplayName)
|
|
scoreMatch(database, "F-4", model.BlueWonMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
if assert.Nil(t, err) {
|
|
assert.True(t, won)
|
|
}
|
|
database.TruncateAllianceTeams()
|
|
database.TruncateMatches()
|
|
database.TruncateMatchResults()
|
|
|
|
// Round with repeated ties.
|
|
CreateTestAlliances(database, 2)
|
|
UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "F-1", model.TieMatch)
|
|
scoreMatch(database, "F-2", model.TieMatch)
|
|
scoreMatch(database, "F-3", model.TieMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "F-4", model.TieMatch)
|
|
scoreMatch(database, "F-5", model.TieMatch)
|
|
scoreMatch(database, "F-6", model.TieMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "F-7", model.RedWonMatch)
|
|
scoreMatch(database, "F-8", model.BlueWonMatch)
|
|
scoreMatch(database, "F-9", model.RedWonMatch)
|
|
won, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
if assert.Nil(t, err) {
|
|
assert.True(t, won)
|
|
}
|
|
}
|
|
|
|
func TestEliminationScheduleRemoveUnneededMatches(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
CreateTestAlliances(database, 2)
|
|
UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "F-1", model.RedWonMatch)
|
|
scoreMatch(database, "F-2", model.RedWonMatch)
|
|
_, err := UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, _ := database.GetMatchesByType("elimination")
|
|
assert.Equal(t, 2, len(matches))
|
|
|
|
// Check that the deleted match is recreated if the score is changed.
|
|
scoreMatch(database, "F-2", model.BlueWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
if assert.Equal(t, 3, len(matches)) {
|
|
assert.Equal(t, "F-3", matches[2].DisplayName)
|
|
}
|
|
}
|
|
|
|
func TestEliminationScheduleChangePreviousRoundResult(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
CreateTestAlliances(database, 4)
|
|
_, err := UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
scoreMatch(database, "SF2-1", model.RedWonMatch)
|
|
scoreMatch(database, "SF2-2", model.BlueWonMatch)
|
|
scoreMatch(database, "SF2-3", model.RedWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
scoreMatch(database, "SF2-3", model.BlueWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err := database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 9, len(matches)) {
|
|
assertMatch(t, matches[6], "F-1", 0, 3)
|
|
assertMatch(t, matches[7], "F-2", 0, 3)
|
|
assertMatch(t, matches[8], "F-3", 0, 3)
|
|
}
|
|
|
|
scoreMatch(database, "SF1-1", model.RedWonMatch)
|
|
scoreMatch(database, "SF1-2", model.RedWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
scoreMatch(database, "SF1-2", model.BlueWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
scoreMatch(database, "SF1-3", model.BlueWonMatch)
|
|
_, err = UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
assert.Nil(t, err)
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 9, len(matches)) {
|
|
assertMatch(t, matches[6], "F-1", 4, 3)
|
|
assertMatch(t, matches[7], "F-2", 4, 3)
|
|
assertMatch(t, matches[8], "F-3", 4, 3)
|
|
}
|
|
}
|
|
|
|
func TestEliminationScheduleUnscoredMatch(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
CreateTestAlliances(database, 2)
|
|
UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
scoreMatch(database, "F-1", "blorpy")
|
|
_, err := UpdateEliminationSchedule(database, time.Unix(0, 0))
|
|
if assert.NotNil(t, err) {
|
|
assert.Equal(t, "Completed match 1 has invalid winner 'blorpy'", err.Error())
|
|
}
|
|
}
|
|
|
|
func TestEliminationScheduleTiming(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
CreateTestAlliances(database, 4)
|
|
UpdateEliminationSchedule(database, time.Unix(1000, 0))
|
|
matches, err := database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 6, len(matches)) {
|
|
assert.True(t, time.Unix(1000, 0).Equal(matches[0].Time))
|
|
assert.True(t, time.Unix(1600, 0).Equal(matches[1].Time))
|
|
assert.True(t, time.Unix(2200, 0).Equal(matches[2].Time))
|
|
assert.True(t, time.Unix(2800, 0).Equal(matches[3].Time))
|
|
assert.True(t, time.Unix(3400, 0).Equal(matches[4].Time))
|
|
assert.True(t, time.Unix(4000, 0).Equal(matches[5].Time))
|
|
}
|
|
scoreMatch(database, "SF1-1", model.RedWonMatch)
|
|
scoreMatch(database, "SF1-3", model.BlueWonMatch)
|
|
UpdateEliminationSchedule(database, time.Unix(5000, 0))
|
|
matches, err = database.GetMatchesByType("elimination")
|
|
assert.Nil(t, err)
|
|
if assert.Equal(t, 6, len(matches)) {
|
|
assert.True(t, time.Unix(1000, 0).Equal(matches[0].Time))
|
|
assert.True(t, time.Unix(5000, 0).Equal(matches[1].Time))
|
|
assert.True(t, time.Unix(5600, 0).Equal(matches[2].Time))
|
|
assert.True(t, time.Unix(6200, 0).Equal(matches[3].Time))
|
|
assert.True(t, time.Unix(3400, 0).Equal(matches[4].Time))
|
|
assert.True(t, time.Unix(6800, 0).Equal(matches[5].Time))
|
|
}
|
|
}
|
|
|
|
func TestEliminationScheduleTeamPositions(t *testing.T) {
|
|
database := setupTestDb(t)
|
|
|
|
CreateTestAlliances(database, 4)
|
|
UpdateEliminationSchedule(database, time.Unix(1000, 0))
|
|
matches, _ := database.GetMatchesByType("elimination")
|
|
match1 := matches[0]
|
|
match2 := matches[1]
|
|
assert.Equal(t, 10, match1.Red1)
|
|
assert.Equal(t, 1, match1.Red2)
|
|
assert.Equal(t, 100, match1.Red3)
|
|
assert.Equal(t, 30, match2.Blue1)
|
|
assert.Equal(t, 3, match2.Blue2)
|
|
assert.Equal(t, 300, match2.Blue3)
|
|
|
|
// Shuffle the team positions and check that the subsequent matches in the same round have the same ones.
|
|
match1.Red1, match1.Red2 = match1.Red2, match1.Red1
|
|
match2.Blue1, match2.Blue3 = match2.Blue3, match2.Blue1
|
|
database.SaveMatch(&match1)
|
|
database.SaveMatch(&match2)
|
|
scoreMatch(database, "SF1-1", model.RedWonMatch)
|
|
scoreMatch(database, "SF2-1", model.BlueWonMatch)
|
|
UpdateEliminationSchedule(database, time.Unix(1000, 0))
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
if assert.Equal(t, 6, len(matches)) {
|
|
for i := 0; i < 3; i++ {
|
|
assert.Equal(t, match1.Red1, matches[2*i].Red1)
|
|
assert.Equal(t, match1.Red2, matches[2*i].Red2)
|
|
assert.Equal(t, match1.Red3, matches[2*i].Red3)
|
|
assert.Equal(t, match2.Blue1, matches[2*i+1].Blue1)
|
|
assert.Equal(t, match2.Blue2, matches[2*i+1].Blue2)
|
|
assert.Equal(t, match2.Blue3, matches[2*i+1].Blue3)
|
|
}
|
|
}
|
|
|
|
// Advance them to the finals and verify that the team position updates have been propagated.
|
|
scoreMatch(database, "SF1-2", model.RedWonMatch)
|
|
scoreMatch(database, "SF2-2", model.BlueWonMatch)
|
|
UpdateEliminationSchedule(database, time.Unix(5000, 0))
|
|
matches, _ = database.GetMatchesByType("elimination")
|
|
if assert.Equal(t, 7, len(matches)) {
|
|
for i := 4; i < 7; i++ {
|
|
assert.Equal(t, match1.Red1, matches[i].Red1)
|
|
assert.Equal(t, match1.Red2, matches[i].Red2)
|
|
assert.Equal(t, match1.Red3, matches[i].Red3)
|
|
assert.Equal(t, match2.Blue1, matches[i].Blue1)
|
|
assert.Equal(t, match2.Blue2, matches[i].Blue2)
|
|
assert.Equal(t, match2.Blue3, matches[i].Blue3)
|
|
}
|
|
}
|
|
}
|
|
|
|
func assertMatch(t *testing.T, match model.Match, displayName string, redAlliance int, blueAlliance int) {
|
|
assert.Equal(t, displayName, match.DisplayName)
|
|
assert.Equal(t, redAlliance, match.Red2)
|
|
assert.Equal(t, redAlliance, match.ElimRedAlliance)
|
|
assert.Equal(t, blueAlliance, match.Blue2)
|
|
assert.Equal(t, blueAlliance, match.ElimBlueAlliance)
|
|
}
|
|
|
|
func scoreMatch(database *model.Database, displayName string, winner model.MatchStatus) {
|
|
match, _ := database.GetMatchByName("elimination", displayName)
|
|
match.Status = winner
|
|
database.SaveMatch(match)
|
|
}
|