parent
096ca396db
commit
9bfbcf4ad7
|
|
@ -25,6 +25,7 @@ steps:
|
|||
image: *go_image
|
||||
pull: true
|
||||
commands:
|
||||
- go mod vendor
|
||||
- make generate
|
||||
|
||||
test:
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@ import (
|
|||
"os"
|
||||
"os/signal"
|
||||
"path"
|
||||
"sync"
|
||||
"syscall"
|
||||
"testing"
|
||||
"time"
|
||||
|
|
@ -197,302 +198,336 @@ func TestDataSync(t *testing.T) {
|
|||
|
||||
require.NoError(t, dataSyncSvc.Sync(ctx))
|
||||
|
||||
var wg sync.WaitGroup
|
||||
|
||||
var expectedServers []map[string]any
|
||||
readJSONFile(t, filesys, path.Join("expected", "servers.json"), &expectedServers)
|
||||
assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
listParams := domain.NewListServersParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.ServerSort{
|
||||
domain.ServerSortKeyASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetSpecial(domain.NullBool{
|
||||
V: false,
|
||||
Valid: true,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.ServerListMaxLimit))
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
|
||||
allServers := make(domain.Servers, 0, len(expectedServers))
|
||||
assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
for {
|
||||
res, err := serverRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
listParams := domain.NewListServersParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.ServerSort{
|
||||
domain.ServerSortKeyASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetSpecial(domain.NullBool{
|
||||
V: false,
|
||||
Valid: true,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.ServerListMaxLimit))
|
||||
|
||||
allServers = append(allServers, res.Servers()...)
|
||||
allServers := make(domain.Servers, 0, len(expectedServers))
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
for {
|
||||
res, err := serverRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
allServers = append(allServers, res.Servers()...)
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
if !assert.Len(collect, allServers, len(expectedServers)) {
|
||||
return
|
||||
}
|
||||
for i, expected := range expectedServers {
|
||||
actual := allServers[i]
|
||||
msg := fmt.Sprintf("Key=%s", expected["Key"])
|
||||
|
||||
if !assert.Len(collect, allServers, len(expectedServers)) {
|
||||
return
|
||||
}
|
||||
for i, expected := range expectedServers {
|
||||
actual := allServers[i]
|
||||
msg := fmt.Sprintf("Key=%s", expected["Key"])
|
||||
|
||||
assert.Equal(collect, expected["Key"], actual.Key(), msg)
|
||||
assert.Equal(collect, expected["URL"], actual.URL().String(), msg)
|
||||
assert.Equal(collect, expected["Open"], actual.Open(), msg)
|
||||
assert.Equal(collect, expected["VersionCode"], actual.VersionCode(), msg)
|
||||
assert.EqualValues(collect, expected["NumPlayers"], actual.NumPlayers(), msg)
|
||||
assert.EqualValues(collect, expected["NumTribes"], actual.NumTribes(), msg)
|
||||
assert.EqualValues(collect, expected["NumVillages"], actual.NumVillages(), msg)
|
||||
assert.EqualValues(collect, expected["NumPlayerVillages"], actual.NumPlayerVillages(), msg)
|
||||
assert.EqualValues(collect, expected["NumBonusVillages"], actual.NumBonusVillages(), msg)
|
||||
assert.EqualValues(
|
||||
collect,
|
||||
expected["NumBarbarianVillages"],
|
||||
actual.NumBarbarianVillages(),
|
||||
"Key=%s",
|
||||
expected["Key"],
|
||||
)
|
||||
assert.WithinDuration(collect, time.Now(), actual.PlayerDataSyncedAt(), time.Minute, msg)
|
||||
assert.WithinDuration(collect, time.Now(), actual.TribeDataSyncedAt(), time.Minute, msg)
|
||||
assert.WithinDuration(collect, time.Now(), actual.VillageDataSyncedAt(), time.Minute, msg)
|
||||
assert.JSONEqf(
|
||||
collect,
|
||||
string(marshalJSON(collect, expected["Config"])),
|
||||
string(marshalJSON(collect, serverConfigToMap(actual.Config()))),
|
||||
"Key=%s",
|
||||
expected["Key"],
|
||||
)
|
||||
assert.JSONEq(
|
||||
collect,
|
||||
string(marshalJSON(collect, expected["BuildingInfo"])),
|
||||
string(marshalJSON(collect, buildingInfoToMap(actual.BuildingInfo()))),
|
||||
msg,
|
||||
)
|
||||
assert.JSONEq(
|
||||
collect,
|
||||
string(marshalJSON(collect, expected["UnitInfo"])),
|
||||
string(marshalJSON(collect, unitInfoToMap(actual.UnitInfo()))),
|
||||
msg,
|
||||
)
|
||||
}
|
||||
}, 60*time.Second, time.Second, "servers")
|
||||
assert.Equal(collect, expected["Key"], actual.Key(), msg)
|
||||
assert.Equal(collect, expected["URL"], actual.URL().String(), msg)
|
||||
assert.Equal(collect, expected["Open"], actual.Open(), msg)
|
||||
assert.Equal(collect, expected["VersionCode"], actual.VersionCode(), msg)
|
||||
assert.EqualValues(collect, expected["NumPlayers"], actual.NumPlayers(), msg)
|
||||
assert.EqualValues(collect, expected["NumTribes"], actual.NumTribes(), msg)
|
||||
assert.EqualValues(collect, expected["NumVillages"], actual.NumVillages(), msg)
|
||||
assert.EqualValues(collect, expected["NumPlayerVillages"], actual.NumPlayerVillages(), msg)
|
||||
assert.EqualValues(collect, expected["NumBonusVillages"], actual.NumBonusVillages(), msg)
|
||||
assert.EqualValues(
|
||||
collect,
|
||||
expected["NumBarbarianVillages"],
|
||||
actual.NumBarbarianVillages(),
|
||||
"Key=%s",
|
||||
expected["Key"],
|
||||
)
|
||||
assert.WithinDuration(collect, time.Now(), actual.PlayerDataSyncedAt(), time.Minute, msg)
|
||||
assert.WithinDuration(collect, time.Now(), actual.TribeDataSyncedAt(), time.Minute, msg)
|
||||
assert.WithinDuration(collect, time.Now(), actual.VillageDataSyncedAt(), time.Minute, msg)
|
||||
assert.JSONEqf(
|
||||
collect,
|
||||
string(marshalJSON(collect, expected["Config"])),
|
||||
string(marshalJSON(collect, serverConfigToMap(actual.Config()))),
|
||||
"Key=%s",
|
||||
expected["Key"],
|
||||
)
|
||||
assert.JSONEq(
|
||||
collect,
|
||||
string(marshalJSON(collect, expected["BuildingInfo"])),
|
||||
string(marshalJSON(collect, buildingInfoToMap(actual.BuildingInfo()))),
|
||||
msg,
|
||||
)
|
||||
assert.JSONEq(
|
||||
collect,
|
||||
string(marshalJSON(collect, expected["UnitInfo"])),
|
||||
string(marshalJSON(collect, unitInfoToMap(actual.UnitInfo()))),
|
||||
msg,
|
||||
)
|
||||
}
|
||||
}, 60*time.Second, time.Second, "servers")
|
||||
}()
|
||||
|
||||
var expectedTribes []map[string]any
|
||||
readJSONFile(t, filesys, path.Join("expected", "tribes.json"), &expectedTribes)
|
||||
assert.EventuallyWithT(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
listParams := domain.NewListTribesParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.TribeSort{
|
||||
domain.TribeSortServerKeyASC,
|
||||
domain.TribeSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.TribeListMaxLimit))
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
|
||||
allTribes := make(domain.Tribes, 0, len(expectedTribes))
|
||||
assert.EventuallyWithT(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
for {
|
||||
res, err := tribeRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
listParams := domain.NewListTribesParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.TribeSort{
|
||||
domain.TribeSortServerKeyASC,
|
||||
domain.TribeSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.TribeListMaxLimit))
|
||||
|
||||
allTribes = append(allTribes, res.Tribes()...)
|
||||
allTribes := make(domain.Tribes, 0, len(expectedTribes))
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
for {
|
||||
res, err := tribeRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
allTribes = append(allTribes, res.Tribes()...)
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
if !assert.Len(collect, allTribes, len(expectedTribes)) {
|
||||
return
|
||||
}
|
||||
for i, expected := range expectedTribes {
|
||||
actual := allTribes[i]
|
||||
msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
|
||||
|
||||
assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
|
||||
assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
|
||||
assert.Equal(collect, expected["Name"], actual.Name(), msg)
|
||||
assert.Equal(collect, expected["Tag"], actual.Tag(), msg)
|
||||
assert.EqualValues(collect, expected["NumMembers"], actual.NumMembers(), msg)
|
||||
assert.EqualValues(collect, expected["NumVillages"], actual.NumVillages(), msg)
|
||||
assert.EqualValues(collect, expected["Points"], actual.Points(), msg)
|
||||
assert.EqualValues(collect, expected["AllPoints"], actual.AllPoints(), msg)
|
||||
assert.EqualValues(collect, expected["Rank"], actual.Rank(), msg)
|
||||
assert.EqualValues(collect, expected["RankAtt"], actual.OD().RankAtt(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreAtt"], actual.OD().ScoreAtt(), msg)
|
||||
assert.EqualValues(collect, expected["RankDef"], actual.OD().RankDef(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreDef"], actual.OD().ScoreDef(), msg)
|
||||
assert.EqualValues(collect, expected["RankSup"], actual.OD().RankSup(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreSup"], actual.OD().ScoreSup(), msg)
|
||||
assert.EqualValues(collect, expected["RankTotal"], actual.OD().RankTotal(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreTotal"], actual.OD().ScoreTotal(), msg)
|
||||
assert.Equal(collect, expected["ProfileURL"], actual.ProfileURL().String(), msg)
|
||||
assert.InDelta(collect, expected["Dominance"], actual.Dominance(), 0.01, msg)
|
||||
assert.EqualValues(collect, expected["BestRank"], actual.BestRank(), msg)
|
||||
assert.NotEmpty(collect, actual.BestRankAt(), msg)
|
||||
assert.EqualValues(collect, expected["MostPoints"], actual.MostPoints(), msg)
|
||||
assert.NotEmpty(collect, actual.MostPointsAt(), msg)
|
||||
assert.EqualValues(collect, expected["MostVillages"], actual.MostVillages(), msg)
|
||||
assert.NotEmpty(collect, actual.MostVillagesAt(), msg)
|
||||
if deletedAt, ok := expected["DeletedAt"].(string); ok && (time.Time{}).Format(time.RFC3339) != deletedAt {
|
||||
assert.NotEmpty(collect, actual.DeletedAt(), msg)
|
||||
} else {
|
||||
assert.Empty(collect, actual.DeletedAt(), msg)
|
||||
if !assert.Len(collect, allTribes, len(expectedTribes)) {
|
||||
return
|
||||
}
|
||||
}
|
||||
}, 60*time.Second, time.Second, "tribes")
|
||||
for i, expected := range expectedTribes {
|
||||
actual := allTribes[i]
|
||||
msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
|
||||
|
||||
assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
|
||||
assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
|
||||
assert.Equal(collect, expected["Name"], actual.Name(), msg)
|
||||
assert.Equal(collect, expected["Tag"], actual.Tag(), msg)
|
||||
assert.EqualValues(collect, expected["NumMembers"], actual.NumMembers(), msg)
|
||||
assert.EqualValues(collect, expected["NumVillages"], actual.NumVillages(), msg)
|
||||
assert.EqualValues(collect, expected["Points"], actual.Points(), msg)
|
||||
assert.EqualValues(collect, expected["AllPoints"], actual.AllPoints(), msg)
|
||||
assert.EqualValues(collect, expected["Rank"], actual.Rank(), msg)
|
||||
assert.EqualValues(collect, expected["RankAtt"], actual.OD().RankAtt(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreAtt"], actual.OD().ScoreAtt(), msg)
|
||||
assert.EqualValues(collect, expected["RankDef"], actual.OD().RankDef(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreDef"], actual.OD().ScoreDef(), msg)
|
||||
assert.EqualValues(collect, expected["RankSup"], actual.OD().RankSup(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreSup"], actual.OD().ScoreSup(), msg)
|
||||
assert.EqualValues(collect, expected["RankTotal"], actual.OD().RankTotal(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreTotal"], actual.OD().ScoreTotal(), msg)
|
||||
assert.Equal(collect, expected["ProfileURL"], actual.ProfileURL().String(), msg)
|
||||
assert.InDelta(collect, expected["Dominance"], actual.Dominance(), 0.01, msg)
|
||||
assert.EqualValues(collect, expected["BestRank"], actual.BestRank(), msg)
|
||||
assert.NotEmpty(collect, actual.BestRankAt(), msg)
|
||||
assert.EqualValues(collect, expected["MostPoints"], actual.MostPoints(), msg)
|
||||
assert.NotEmpty(collect, actual.MostPointsAt(), msg)
|
||||
assert.EqualValues(collect, expected["MostVillages"], actual.MostVillages(), msg)
|
||||
assert.NotEmpty(collect, actual.MostVillagesAt(), msg)
|
||||
if deletedAt, ok := expected["DeletedAt"].(string); ok && (time.Time{}).Format(time.RFC3339) != deletedAt {
|
||||
assert.NotEmpty(collect, actual.DeletedAt(), msg)
|
||||
} else {
|
||||
assert.Empty(collect, actual.DeletedAt(), msg)
|
||||
}
|
||||
}
|
||||
}, 60*time.Second, time.Second, "tribes")
|
||||
}()
|
||||
|
||||
var expectedPlayers []map[string]any
|
||||
readJSONFile(t, filesys, path.Join("expected", "players.json"), &expectedPlayers)
|
||||
assert.EventuallyWithT(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
listParams := domain.NewListPlayersParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.PlayerSort{
|
||||
domain.PlayerSortServerKeyASC,
|
||||
domain.PlayerSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.PlayerListMaxLimit))
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
|
||||
allPlayers := make(domain.Players, 0, len(expectedPlayers))
|
||||
assert.EventuallyWithT(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
for {
|
||||
res, err := playerRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
listParams := domain.NewListPlayersParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.PlayerSort{
|
||||
domain.PlayerSortServerKeyASC,
|
||||
domain.PlayerSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.PlayerListMaxLimit))
|
||||
|
||||
allPlayers = append(allPlayers, res.Players()...)
|
||||
allPlayers := make(domain.Players, 0, len(expectedPlayers))
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
for {
|
||||
res, err := playerRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
allPlayers = append(allPlayers, res.Players()...)
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
if !assert.Len(collect, allPlayers, len(expectedPlayers)) {
|
||||
return
|
||||
}
|
||||
for i, expected := range expectedPlayers {
|
||||
actual := allPlayers[i]
|
||||
msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
|
||||
|
||||
assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
|
||||
assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
|
||||
assert.Equal(collect, expected["Name"], actual.Name(), msg)
|
||||
assert.EqualValues(collect, expected["NumVillages"], actual.NumVillages(), msg)
|
||||
assert.EqualValues(collect, expected["Points"], actual.Points(), msg)
|
||||
assert.EqualValues(collect, expected["Rank"], actual.Rank(), msg)
|
||||
assert.EqualValues(collect, expected["TribeID"], actual.TribeID(), msg)
|
||||
assert.EqualValues(collect, expected["RankAtt"], actual.OD().RankAtt(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreAtt"], actual.OD().ScoreAtt(), msg)
|
||||
assert.EqualValues(collect, expected["RankDef"], actual.OD().RankDef(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreDef"], actual.OD().ScoreDef(), msg)
|
||||
assert.EqualValues(collect, expected["RankSup"], actual.OD().RankSup(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreSup"], actual.OD().ScoreSup(), msg)
|
||||
assert.EqualValues(collect, expected["RankTotal"], actual.OD().RankTotal(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreTotal"], actual.OD().ScoreTotal(), msg)
|
||||
assert.Equal(collect, expected["ProfileURL"], actual.ProfileURL().String(), msg)
|
||||
assert.EqualValues(collect, expected["BestRank"], actual.BestRank(), msg)
|
||||
assert.NotEmpty(collect, actual.BestRankAt(), msg)
|
||||
assert.EqualValues(collect, expected["MostPoints"], actual.MostPoints(), msg)
|
||||
assert.NotEmpty(collect, actual.MostPointsAt(), msg)
|
||||
assert.EqualValues(collect, expected["MostVillages"], actual.MostVillages(), msg)
|
||||
assert.NotEmpty(collect, actual.MostVillagesAt(), msg)
|
||||
if deletedAt, ok := expected["DeletedAt"].(string); ok && (time.Time{}).Format(time.RFC3339) != deletedAt {
|
||||
assert.NotEmpty(collect, actual.DeletedAt(), msg)
|
||||
} else {
|
||||
assert.Empty(collect, actual.DeletedAt(), msg)
|
||||
if !assert.Len(collect, allPlayers, len(expectedPlayers)) {
|
||||
return
|
||||
}
|
||||
}
|
||||
}, 60*time.Second, time.Second, "players")
|
||||
for i, expected := range expectedPlayers {
|
||||
actual := allPlayers[i]
|
||||
msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
|
||||
|
||||
assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
|
||||
assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
|
||||
assert.Equal(collect, expected["Name"], actual.Name(), msg)
|
||||
assert.EqualValues(collect, expected["NumVillages"], actual.NumVillages(), msg)
|
||||
assert.EqualValues(collect, expected["Points"], actual.Points(), msg)
|
||||
assert.EqualValues(collect, expected["Rank"], actual.Rank(), msg)
|
||||
assert.EqualValues(collect, expected["TribeID"], actual.TribeID(), msg)
|
||||
assert.EqualValues(collect, expected["RankAtt"], actual.OD().RankAtt(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreAtt"], actual.OD().ScoreAtt(), msg)
|
||||
assert.EqualValues(collect, expected["RankDef"], actual.OD().RankDef(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreDef"], actual.OD().ScoreDef(), msg)
|
||||
assert.EqualValues(collect, expected["RankSup"], actual.OD().RankSup(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreSup"], actual.OD().ScoreSup(), msg)
|
||||
assert.EqualValues(collect, expected["RankTotal"], actual.OD().RankTotal(), msg)
|
||||
assert.EqualValues(collect, expected["ScoreTotal"], actual.OD().ScoreTotal(), msg)
|
||||
assert.Equal(collect, expected["ProfileURL"], actual.ProfileURL().String(), msg)
|
||||
assert.EqualValues(collect, expected["BestRank"], actual.BestRank(), msg)
|
||||
assert.NotEmpty(collect, actual.BestRankAt(), msg)
|
||||
assert.EqualValues(collect, expected["MostPoints"], actual.MostPoints(), msg)
|
||||
assert.NotEmpty(collect, actual.MostPointsAt(), msg)
|
||||
assert.EqualValues(collect, expected["MostVillages"], actual.MostVillages(), msg)
|
||||
assert.NotEmpty(collect, actual.MostVillagesAt(), msg)
|
||||
if deletedAt, ok := expected["DeletedAt"].(string); ok && (time.Time{}).Format(time.RFC3339) != deletedAt {
|
||||
assert.NotEmpty(collect, actual.DeletedAt(), msg)
|
||||
} else {
|
||||
assert.Empty(collect, actual.DeletedAt(), msg)
|
||||
}
|
||||
}
|
||||
}, 60*time.Second, time.Second, "players")
|
||||
}()
|
||||
|
||||
var expectedVillages []map[string]any
|
||||
readJSONFile(t, filesys, path.Join("expected", "villages.json"), &expectedVillages)
|
||||
assert.EventuallyWithT(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
listParams := domain.NewListVillagesParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.VillageSort{
|
||||
domain.VillageSortServerKeyASC,
|
||||
domain.VillageSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.VillageListMaxLimit))
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
|
||||
allVillages := make(domain.Villages, 0, len(expectedVillages))
|
||||
assert.EventuallyWithT(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
for {
|
||||
res, err := villageRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
listParams := domain.NewListVillagesParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.VillageSort{
|
||||
domain.VillageSortServerKeyASC,
|
||||
domain.VillageSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.VillageListMaxLimit))
|
||||
|
||||
allVillages = append(allVillages, res.Villages()...)
|
||||
allVillages := make(domain.Villages, 0, len(expectedVillages))
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
for {
|
||||
res, err := villageRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
allVillages = append(allVillages, res.Villages()...)
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
if !assert.Len(collect, allVillages, len(expectedVillages)) {
|
||||
return
|
||||
}
|
||||
for i, expected := range expectedVillages {
|
||||
actual := allVillages[i]
|
||||
msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
|
||||
|
||||
if !assert.Len(collect, allVillages, len(expectedVillages)) {
|
||||
return
|
||||
}
|
||||
for i, expected := range expectedVillages {
|
||||
actual := allVillages[i]
|
||||
msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
|
||||
|
||||
assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
|
||||
assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
|
||||
assert.Equal(collect, expected["Name"], actual.Name(), msg)
|
||||
assert.EqualValues(collect, expected["Points"], actual.Points(), msg)
|
||||
assert.EqualValues(collect, expected["X"], actual.X(), msg)
|
||||
assert.EqualValues(collect, expected["Y"], actual.Y(), msg)
|
||||
assert.Equal(collect, expected["Continent"], actual.Continent(), msg)
|
||||
assert.EqualValues(collect, expected["Bonus"], actual.Bonus(), msg)
|
||||
assert.EqualValues(collect, expected["PlayerID"], actual.PlayerID(), msg)
|
||||
assert.Equal(collect, expected["ProfileURL"], actual.ProfileURL().String(), msg)
|
||||
}
|
||||
}, 60*time.Second, time.Second, "villages")
|
||||
assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
|
||||
assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
|
||||
assert.Equal(collect, expected["Name"], actual.Name(), msg)
|
||||
assert.EqualValues(collect, expected["Points"], actual.Points(), msg)
|
||||
assert.EqualValues(collect, expected["X"], actual.X(), msg)
|
||||
assert.EqualValues(collect, expected["Y"], actual.Y(), msg)
|
||||
assert.Equal(collect, expected["Continent"], actual.Continent(), msg)
|
||||
assert.EqualValues(collect, expected["Bonus"], actual.Bonus(), msg)
|
||||
assert.EqualValues(collect, expected["PlayerID"], actual.PlayerID(), msg)
|
||||
assert.Equal(collect, expected["ProfileURL"], actual.ProfileURL().String(), msg)
|
||||
}
|
||||
}, 60*time.Second, time.Second, "villages")
|
||||
}()
|
||||
|
||||
var expectedTribeChanges []map[string]any
|
||||
readJSONFile(t, filesys, path.Join("expected", "tribe-changes.json"), &expectedTribeChanges)
|
||||
assert.EventuallyWithT(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
listParams := domain.NewListTribeChangesParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.TribeChangeSort{
|
||||
domain.TribeChangeSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.TribeChangeListMaxLimit))
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
|
||||
allTribeChanges := make(domain.TribeChanges, 0, len(expectedTribeChanges))
|
||||
assert.EventuallyWithT(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
for {
|
||||
res, err := tribeChangeRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
listParams := domain.NewListTribeChangesParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.TribeChangeSort{
|
||||
domain.TribeChangeSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.TribeChangeListMaxLimit))
|
||||
|
||||
allTribeChanges = append(allTribeChanges, res.TribeChanges()...)
|
||||
allTribeChanges := make(domain.TribeChanges, 0, len(expectedTribeChanges))
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
for {
|
||||
res, err := tribeChangeRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
allTribeChanges = append(allTribeChanges, res.TribeChanges()...)
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
if !assert.Len(collect, allTribeChanges, len(expectedTribeChanges)) {
|
||||
return
|
||||
}
|
||||
for i, expected := range expectedTribeChanges {
|
||||
actual := allTribeChanges[i]
|
||||
msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
|
||||
|
||||
if !assert.Len(collect, allTribeChanges, len(expectedTribeChanges)) {
|
||||
return
|
||||
}
|
||||
for i, expected := range expectedTribeChanges {
|
||||
actual := allTribeChanges[i]
|
||||
msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
|
||||
assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
|
||||
assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
|
||||
assert.EqualValues(collect, expected["PlayerID"], actual.PlayerID(), msg)
|
||||
assert.EqualValues(collect, expected["OldTribeID"], actual.OldTribeID(), msg)
|
||||
assert.EqualValues(collect, expected["NewTribeID"], actual.NewTribeID(), msg)
|
||||
}
|
||||
}, 60*time.Second, time.Second, "tribe changes")
|
||||
}()
|
||||
|
||||
assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
|
||||
assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
|
||||
assert.EqualValues(collect, expected["PlayerID"], actual.PlayerID(), msg)
|
||||
assert.EqualValues(collect, expected["OldTribeID"], actual.OldTribeID(), msg)
|
||||
assert.EqualValues(collect, expected["NewTribeID"], actual.NewTribeID(), msg)
|
||||
}
|
||||
}, 60*time.Second, time.Second, "tribe changes")
|
||||
wg.Wait()
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ import (
|
|||
"os"
|
||||
"os/signal"
|
||||
"slices"
|
||||
"sync"
|
||||
"syscall"
|
||||
"testing"
|
||||
"time"
|
||||
|
|
@ -143,203 +144,222 @@ func TestSnapshotCreation(t *testing.T) {
|
|||
|
||||
require.NoError(t, snapshotSvc.Create(ctx))
|
||||
|
||||
assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
var wg sync.WaitGroup
|
||||
|
||||
listParams := domain.NewListServersParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.ServerSort{
|
||||
domain.ServerSortKeyASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetSpecial(domain.NullBool{
|
||||
V: false,
|
||||
Valid: true,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.ServerListMaxLimit))
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
|
||||
for {
|
||||
res, err := serverRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
for _, s := range res.Servers() {
|
||||
assert.WithinDuration(collect, time.Now(), s.PlayerSnapshotsCreatedAt(), time.Minute, s.Key())
|
||||
assert.WithinDuration(collect, time.Now(), s.TribeSnapshotsCreatedAt(), time.Minute, s.Key())
|
||||
}
|
||||
listParams := domain.NewListServersParams()
|
||||
require.NoError(collect, listParams.SetSort([]domain.ServerSort{
|
||||
domain.ServerSortKeyASC,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetSpecial(domain.NullBool{
|
||||
V: false,
|
||||
Valid: true,
|
||||
}))
|
||||
require.NoError(collect, listParams.SetLimit(domain.ServerListMaxLimit))
|
||||
|
||||
if res.Next().IsZero() {
|
||||
return
|
||||
}
|
||||
for {
|
||||
res, err := serverRepo.List(ctx, listParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
}, 30*time.Second, 500*time.Millisecond, "servers")
|
||||
|
||||
assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
listTribesParams := domain.NewListTribesParams()
|
||||
require.NoError(collect, listTribesParams.SetSort([]domain.TribeSort{
|
||||
domain.TribeSortServerKeyASC,
|
||||
domain.TribeSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listTribesParams.SetDeleted(domain.NullBool{
|
||||
V: false,
|
||||
Valid: true,
|
||||
}))
|
||||
require.NoError(collect, listTribesParams.SetLimit(domain.TribeListMaxLimit))
|
||||
|
||||
var allTribes domain.Tribes
|
||||
|
||||
for {
|
||||
res, err := tribeRepo.List(ctx, listTribesParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
allTribes = append(allTribes, res.Tribes()...)
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
}
|
||||
|
||||
require.NoError(collect, listTribesParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
listSnapshotsParams := domain.NewListTribeSnapshotsParams()
|
||||
require.NoError(collect, listSnapshotsParams.SetSort([]domain.TribeSnapshotSort{
|
||||
domain.TribeSnapshotSortServerKeyASC,
|
||||
domain.TribeSnapshotSortDateASC,
|
||||
domain.TribeSnapshotSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listSnapshotsParams.SetLimit(domain.TribeSnapshotListMaxLimit))
|
||||
|
||||
cnt := 0
|
||||
|
||||
for {
|
||||
snapshots, err := tribeSnapshotRepo.List(ctx, listSnapshotsParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
if len(snapshots) == 0 {
|
||||
break
|
||||
}
|
||||
|
||||
for _, ts := range snapshots {
|
||||
cnt++
|
||||
msg := fmt.Sprintf("TribeID=%d,ServerKey=%s", ts.TribeID(), ts.ServerKey())
|
||||
|
||||
idx := slices.IndexFunc(allTribes, func(t domain.Tribe) bool {
|
||||
return t.ID() == ts.TribeID() && t.ServerKey() == ts.ServerKey()
|
||||
})
|
||||
if !assert.GreaterOrEqual(
|
||||
collect,
|
||||
idx,
|
||||
0,
|
||||
msg,
|
||||
) {
|
||||
continue
|
||||
for _, s := range res.Servers() {
|
||||
assert.WithinDuration(collect, time.Now(), s.PlayerSnapshotsCreatedAt(), time.Minute, s.Key())
|
||||
assert.WithinDuration(collect, time.Now(), s.TribeSnapshotsCreatedAt(), time.Minute, s.Key())
|
||||
}
|
||||
|
||||
tribe := allTribes[idx]
|
||||
|
||||
assert.NotZero(collect, ts.ID(), msg)
|
||||
assert.Equal(collect, tribe.ID(), ts.TribeID(), msg)
|
||||
assert.Equal(collect, tribe.ServerKey(), ts.ServerKey(), msg)
|
||||
assert.Equal(collect, tribe.NumMembers(), ts.NumMembers(), msg)
|
||||
assert.Equal(collect, tribe.NumVillages(), ts.NumVillages(), msg)
|
||||
assert.Equal(collect, tribe.Points(), ts.Points(), msg)
|
||||
assert.Equal(collect, tribe.AllPoints(), ts.AllPoints(), msg)
|
||||
assert.Equal(collect, tribe.Rank(), ts.Rank(), msg)
|
||||
assert.Equal(collect, tribe.OD(), ts.OD(), msg)
|
||||
assert.InDelta(collect, tribe.Dominance(), ts.Dominance(), 0.001, msg)
|
||||
assert.WithinDuration(collect, time.Now(), ts.CreatedAt(), time.Minute, msg)
|
||||
assert.WithinDuration(collect, time.Now(), ts.Date(), 24*time.Hour, msg)
|
||||
}
|
||||
|
||||
require.NoError(collect, listSnapshotsParams.SetOffset(listSnapshotsParams.Offset()+listSnapshotsParams.Limit()))
|
||||
}
|
||||
|
||||
//nolint:testifylint
|
||||
assert.Equal(collect, len(allTribes), cnt)
|
||||
}, 30*time.Second, 500*time.Millisecond, "tribes")
|
||||
|
||||
assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
listPlayersParams := domain.NewListPlayersParams()
|
||||
require.NoError(collect, listPlayersParams.SetSort([]domain.PlayerSort{
|
||||
domain.PlayerSortServerKeyASC,
|
||||
domain.PlayerSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listPlayersParams.SetDeleted(domain.NullBool{
|
||||
V: false,
|
||||
Valid: true,
|
||||
}))
|
||||
require.NoError(collect, listPlayersParams.SetLimit(domain.PlayerListMaxLimit))
|
||||
|
||||
var allPlayers domain.Players
|
||||
|
||||
for {
|
||||
res, err := playerRepo.List(ctx, listPlayersParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
allPlayers = append(allPlayers, res.Players()...)
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
}
|
||||
|
||||
require.NoError(collect, listPlayersParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
listSnapshotsParams := domain.NewListPlayerSnapshotsParams()
|
||||
require.NoError(collect, listSnapshotsParams.SetSort([]domain.PlayerSnapshotSort{
|
||||
domain.PlayerSnapshotSortServerKeyASC,
|
||||
domain.PlayerSnapshotSortDateASC,
|
||||
domain.PlayerSnapshotSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listSnapshotsParams.SetLimit(domain.PlayerSnapshotListMaxLimit))
|
||||
|
||||
cnt := 0
|
||||
|
||||
for {
|
||||
snapshots, err := playerSnapshotRepo.List(ctx, listSnapshotsParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
if len(snapshots) == 0 {
|
||||
break
|
||||
}
|
||||
|
||||
for _, ps := range snapshots {
|
||||
cnt++
|
||||
msg := fmt.Sprintf("PlayerID=%d,ServerKey=%s", ps.PlayerID(), ps.ServerKey())
|
||||
|
||||
idx := slices.IndexFunc(allPlayers, func(p domain.Player) bool {
|
||||
return p.ID() == ps.PlayerID() && p.ServerKey() == ps.ServerKey()
|
||||
})
|
||||
if !assert.GreaterOrEqual(
|
||||
collect,
|
||||
idx,
|
||||
0,
|
||||
msg,
|
||||
) {
|
||||
continue
|
||||
if res.Next().IsZero() {
|
||||
return
|
||||
}
|
||||
|
||||
player := allPlayers[idx]
|
||||
require.NoError(collect, listParams.SetCursor(res.Next()))
|
||||
}
|
||||
}, 30*time.Second, 500*time.Millisecond, "servers")
|
||||
}()
|
||||
|
||||
assert.NotZero(collect, ps.ID(), msg)
|
||||
assert.Equal(collect, player.ID(), ps.PlayerID(), msg)
|
||||
assert.Equal(collect, player.ServerKey(), ps.ServerKey(), msg)
|
||||
assert.Equal(collect, player.NumVillages(), ps.NumVillages(), msg)
|
||||
assert.Equal(collect, player.Points(), ps.Points(), msg)
|
||||
assert.Equal(collect, player.Rank(), ps.Rank(), msg)
|
||||
assert.Equal(collect, player.TribeID(), ps.TribeID(), msg)
|
||||
assert.Equal(collect, player.OD(), ps.OD(), msg)
|
||||
assert.WithinDuration(collect, time.Now(), ps.CreatedAt(), time.Minute, msg)
|
||||
assert.WithinDuration(collect, time.Now(), ps.Date(), 24*time.Hour, msg)
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
|
||||
assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
listTribesParams := domain.NewListTribesParams()
|
||||
require.NoError(collect, listTribesParams.SetSort([]domain.TribeSort{
|
||||
domain.TribeSortServerKeyASC,
|
||||
domain.TribeSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listTribesParams.SetDeleted(domain.NullBool{
|
||||
V: false,
|
||||
Valid: true,
|
||||
}))
|
||||
require.NoError(collect, listTribesParams.SetLimit(domain.TribeListMaxLimit))
|
||||
|
||||
var allTribes domain.Tribes
|
||||
|
||||
for {
|
||||
res, err := tribeRepo.List(ctx, listTribesParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
allTribes = append(allTribes, res.Tribes()...)
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
}
|
||||
|
||||
require.NoError(collect, listTribesParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
require.NoError(collect, listSnapshotsParams.SetOffset(listSnapshotsParams.Offset()+listSnapshotsParams.Limit()))
|
||||
}
|
||||
listSnapshotsParams := domain.NewListTribeSnapshotsParams()
|
||||
require.NoError(collect, listSnapshotsParams.SetSort([]domain.TribeSnapshotSort{
|
||||
domain.TribeSnapshotSortServerKeyASC,
|
||||
domain.TribeSnapshotSortDateASC,
|
||||
domain.TribeSnapshotSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listSnapshotsParams.SetLimit(domain.TribeSnapshotListMaxLimit))
|
||||
|
||||
//nolint:testifylint
|
||||
assert.Equal(collect, len(allPlayers), cnt)
|
||||
}, 30*time.Second, 500*time.Millisecond, "players")
|
||||
cnt := 0
|
||||
|
||||
for {
|
||||
snapshots, err := tribeSnapshotRepo.List(ctx, listSnapshotsParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
if len(snapshots) == 0 {
|
||||
break
|
||||
}
|
||||
|
||||
for _, ts := range snapshots {
|
||||
cnt++
|
||||
msg := fmt.Sprintf("TribeID=%d,ServerKey=%s", ts.TribeID(), ts.ServerKey())
|
||||
|
||||
idx := slices.IndexFunc(allTribes, func(t domain.Tribe) bool {
|
||||
return t.ID() == ts.TribeID() && t.ServerKey() == ts.ServerKey()
|
||||
})
|
||||
if !assert.GreaterOrEqual(
|
||||
collect,
|
||||
idx,
|
||||
0,
|
||||
msg,
|
||||
) {
|
||||
continue
|
||||
}
|
||||
|
||||
tribe := allTribes[idx]
|
||||
|
||||
assert.NotZero(collect, ts.ID(), msg)
|
||||
assert.Equal(collect, tribe.ID(), ts.TribeID(), msg)
|
||||
assert.Equal(collect, tribe.ServerKey(), ts.ServerKey(), msg)
|
||||
assert.Equal(collect, tribe.NumMembers(), ts.NumMembers(), msg)
|
||||
assert.Equal(collect, tribe.NumVillages(), ts.NumVillages(), msg)
|
||||
assert.Equal(collect, tribe.Points(), ts.Points(), msg)
|
||||
assert.Equal(collect, tribe.AllPoints(), ts.AllPoints(), msg)
|
||||
assert.Equal(collect, tribe.Rank(), ts.Rank(), msg)
|
||||
assert.Equal(collect, tribe.OD(), ts.OD(), msg)
|
||||
assert.InDelta(collect, tribe.Dominance(), ts.Dominance(), 0.001, msg)
|
||||
assert.WithinDuration(collect, time.Now(), ts.CreatedAt(), time.Minute, msg)
|
||||
assert.WithinDuration(collect, time.Now(), ts.Date(), 24*time.Hour, msg)
|
||||
}
|
||||
|
||||
require.NoError(collect, listSnapshotsParams.SetOffset(listSnapshotsParams.Offset()+listSnapshotsParams.Limit()))
|
||||
}
|
||||
|
||||
//nolint:testifylint
|
||||
assert.Equal(collect, len(allTribes), cnt)
|
||||
}, 30*time.Second, 500*time.Millisecond, "tribes")
|
||||
}()
|
||||
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
|
||||
assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
|
||||
require.NoError(collect, ctx.Err())
|
||||
|
||||
listPlayersParams := domain.NewListPlayersParams()
|
||||
require.NoError(collect, listPlayersParams.SetSort([]domain.PlayerSort{
|
||||
domain.PlayerSortServerKeyASC,
|
||||
domain.PlayerSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listPlayersParams.SetDeleted(domain.NullBool{
|
||||
V: false,
|
||||
Valid: true,
|
||||
}))
|
||||
require.NoError(collect, listPlayersParams.SetLimit(domain.PlayerListMaxLimit))
|
||||
|
||||
var allPlayers domain.Players
|
||||
|
||||
for {
|
||||
res, err := playerRepo.List(ctx, listPlayersParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
allPlayers = append(allPlayers, res.Players()...)
|
||||
|
||||
if res.Next().IsZero() {
|
||||
break
|
||||
}
|
||||
|
||||
require.NoError(collect, listPlayersParams.SetCursor(res.Next()))
|
||||
}
|
||||
|
||||
listSnapshotsParams := domain.NewListPlayerSnapshotsParams()
|
||||
require.NoError(collect, listSnapshotsParams.SetSort([]domain.PlayerSnapshotSort{
|
||||
domain.PlayerSnapshotSortServerKeyASC,
|
||||
domain.PlayerSnapshotSortDateASC,
|
||||
domain.PlayerSnapshotSortIDASC,
|
||||
}))
|
||||
require.NoError(collect, listSnapshotsParams.SetLimit(domain.PlayerSnapshotListMaxLimit))
|
||||
|
||||
cnt := 0
|
||||
|
||||
for {
|
||||
snapshots, err := playerSnapshotRepo.List(ctx, listSnapshotsParams)
|
||||
require.NoError(collect, err)
|
||||
|
||||
if len(snapshots) == 0 {
|
||||
break
|
||||
}
|
||||
|
||||
for _, ps := range snapshots {
|
||||
cnt++
|
||||
msg := fmt.Sprintf("PlayerID=%d,ServerKey=%s", ps.PlayerID(), ps.ServerKey())
|
||||
|
||||
idx := slices.IndexFunc(allPlayers, func(p domain.Player) bool {
|
||||
return p.ID() == ps.PlayerID() && p.ServerKey() == ps.ServerKey()
|
||||
})
|
||||
if !assert.GreaterOrEqual(
|
||||
collect,
|
||||
idx,
|
||||
0,
|
||||
msg,
|
||||
) {
|
||||
continue
|
||||
}
|
||||
|
||||
player := allPlayers[idx]
|
||||
|
||||
assert.NotZero(collect, ps.ID(), msg)
|
||||
assert.Equal(collect, player.ID(), ps.PlayerID(), msg)
|
||||
assert.Equal(collect, player.ServerKey(), ps.ServerKey(), msg)
|
||||
assert.Equal(collect, player.NumVillages(), ps.NumVillages(), msg)
|
||||
assert.Equal(collect, player.Points(), ps.Points(), msg)
|
||||
assert.Equal(collect, player.Rank(), ps.Rank(), msg)
|
||||
assert.Equal(collect, player.TribeID(), ps.TribeID(), msg)
|
||||
assert.Equal(collect, player.OD(), ps.OD(), msg)
|
||||
assert.WithinDuration(collect, time.Now(), ps.CreatedAt(), time.Minute, msg)
|
||||
assert.WithinDuration(collect, time.Now(), ps.Date(), 24*time.Hour, msg)
|
||||
}
|
||||
|
||||
require.NoError(collect, listSnapshotsParams.SetOffset(listSnapshotsParams.Offset()+listSnapshotsParams.Limit()))
|
||||
}
|
||||
|
||||
//nolint:testifylint
|
||||
assert.Equal(collect, len(allPlayers), cnt)
|
||||
}, 30*time.Second, 500*time.Millisecond, "players")
|
||||
}()
|
||||
|
||||
wg.Wait()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -159,7 +159,7 @@ func (rmq *RabbitMQ) Close() error {
|
|||
return nil
|
||||
}
|
||||
|
||||
type TopicNameGenerator func(topic string) string
|
||||
type TopicNameGenerator amqp.QueueNameGenerator
|
||||
|
||||
func NewPubSub(
|
||||
tb watermilltest.TestingTB,
|
||||
|
|
|
|||
Loading…
Reference in New Issue