refactor: speed up tests a bit (#28)

Reviewed-on: twhelp/corev3#28

.woodpecker/test.yml

@@ -25,6 +25,7 @@ steps:
     image: *go_image
     pull: true
     commands:
+      - go mod vendor
       - make generate
 
   test:

internal/port/consumer_data_sync_test.go

@@ -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()
+			wg.Add(1)
-				require.NoError(collect, listParams.SetSort([]domain.ServerSort{
+			go func() {
-					domain.ServerSortKeyASC,
+				defer wg.Done()
-				}))
-				require.NoError(collect, listParams.SetSpecial(domain.NullBool{
-					V:     false,
-					Valid: true,
-				}))
-				require.NoError(collect, listParams.SetLimit(domain.ServerListMaxLimit))
 
-				allServers := make(domain.Servers, 0, len(expectedServers))
+				assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
+					require.NoError(collect, ctx.Err())
 
-				for {
+					listParams := domain.NewListServersParams()
-					res, err := serverRepo.List(ctx, listParams)
+					require.NoError(collect, listParams.SetSort([]domain.ServerSort{
-					require.NoError(collect, err)
+						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() {
+					for {
-						break
+						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)) {
+						assert.Equal(collect, expected["Key"], actual.Key(), msg)
-					return
+						assert.Equal(collect, expected["URL"], actual.URL().String(), msg)
-				}
+						assert.Equal(collect, expected["Open"], actual.Open(), msg)
-				for i, expected := range expectedServers {
+						assert.Equal(collect, expected["VersionCode"], actual.VersionCode(), msg)
-					actual := allServers[i]
+						assert.EqualValues(collect, expected["NumPlayers"], actual.NumPlayers(), msg)
-					msg := fmt.Sprintf("Key=%s", expected["Key"])
+						assert.EqualValues(collect, expected["NumTribes"], actual.NumTribes(), msg)
-
+						assert.EqualValues(collect, expected["NumVillages"], actual.NumVillages(), msg)
-					assert.Equal(collect, expected["Key"], actual.Key(), msg)
+						assert.EqualValues(collect, expected["NumPlayerVillages"], actual.NumPlayerVillages(), msg)
-					assert.Equal(collect, expected["URL"], actual.URL().String(), msg)
+						assert.EqualValues(collect, expected["NumBonusVillages"], actual.NumBonusVillages(), msg)
-					assert.Equal(collect, expected["Open"], actual.Open(), msg)
+						assert.EqualValues(
-					assert.Equal(collect, expected["VersionCode"], actual.VersionCode(), msg)
+							collect,
-					assert.EqualValues(collect, expected["NumPlayers"], actual.NumPlayers(), msg)
+							expected["NumBarbarianVillages"],
-					assert.EqualValues(collect, expected["NumTribes"], actual.NumTribes(), msg)
+							actual.NumBarbarianVillages(),
-					assert.EqualValues(collect, expected["NumVillages"], actual.NumVillages(), msg)
+							"Key=%s",
-					assert.EqualValues(collect, expected["NumPlayerVillages"], actual.NumPlayerVillages(), msg)
+							expected["Key"],
-					assert.EqualValues(collect, expected["NumBonusVillages"], actual.NumBonusVillages(), msg)
+						)
-					assert.EqualValues(
+						assert.WithinDuration(collect, time.Now(), actual.PlayerDataSyncedAt(), time.Minute, msg)
-						collect,
+						assert.WithinDuration(collect, time.Now(), actual.TribeDataSyncedAt(), time.Minute, msg)
-						expected["NumBarbarianVillages"],
+						assert.WithinDuration(collect, time.Now(), actual.VillageDataSyncedAt(), time.Minute, msg)
-						actual.NumBarbarianVillages(),
+						assert.JSONEqf(
-						"Key=%s",
+							collect,
-						expected["Key"],
+							string(marshalJSON(collect, expected["Config"])),
-					)
+							string(marshalJSON(collect, serverConfigToMap(actual.Config()))),
-					assert.WithinDuration(collect, time.Now(), actual.PlayerDataSyncedAt(), time.Minute, msg)
+							"Key=%s",
-					assert.WithinDuration(collect, time.Now(), actual.TribeDataSyncedAt(), time.Minute, msg)
+							expected["Key"],
-					assert.WithinDuration(collect, time.Now(), actual.VillageDataSyncedAt(), time.Minute, msg)
+						)
-					assert.JSONEqf(
+						assert.JSONEq(
-						collect,
+							collect,
-						string(marshalJSON(collect, expected["Config"])),
+							string(marshalJSON(collect, expected["BuildingInfo"])),
-						string(marshalJSON(collect, serverConfigToMap(actual.Config()))),
+							string(marshalJSON(collect, buildingInfoToMap(actual.BuildingInfo()))),
-						"Key=%s",
+							msg,
-						expected["Key"],
+						)
-					)
+						assert.JSONEq(
-					assert.JSONEq(
+							collect,
-						collect,
+							string(marshalJSON(collect, expected["UnitInfo"])),
-						string(marshalJSON(collect, expected["BuildingInfo"])),
+							string(marshalJSON(collect, unitInfoToMap(actual.UnitInfo()))),
-						string(marshalJSON(collect, buildingInfoToMap(actual.BuildingInfo()))),
+							msg,
-						msg,
+						)
-					)
+					}
-					assert.JSONEq(
+				}, 60*time.Second, time.Second, "servers")
-						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()
+			wg.Add(1)
-				require.NoError(collect, listParams.SetSort([]domain.TribeSort{
+			go func() {
-					domain.TribeSortServerKeyASC,
+				defer wg.Done()
-					domain.TribeSortIDASC,
-				}))
-				require.NoError(collect, listParams.SetLimit(domain.TribeListMaxLimit))
 
-				allTribes := make(domain.Tribes, 0, len(expectedTribes))
+				assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+					require.NoError(collect, ctx.Err())
 
-				for {
+					listParams := domain.NewListTribesParams()
-					res, err := tribeRepo.List(ctx, listParams)
+					require.NoError(collect, listParams.SetSort([]domain.TribeSort{
-					require.NoError(collect, err)
+						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() {
+					for {
-						break
+						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
-
-				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)
 					}
-				}
+					for i, expected := range expectedTribes {
-			}, 60*time.Second, time.Second, "tribes")
+						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()
+			wg.Add(1)
-				require.NoError(collect, listParams.SetSort([]domain.PlayerSort{
+			go func() {
-					domain.PlayerSortServerKeyASC,
+				defer wg.Done()
-					domain.PlayerSortIDASC,
-				}))
-				require.NoError(collect, listParams.SetLimit(domain.PlayerListMaxLimit))
 
-				allPlayers := make(domain.Players, 0, len(expectedPlayers))
+				assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+					require.NoError(collect, ctx.Err())
 
-				for {
+					listParams := domain.NewListPlayersParams()
-					res, err := playerRepo.List(ctx, listParams)
+					require.NoError(collect, listParams.SetSort([]domain.PlayerSort{
-					require.NoError(collect, err)
+						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() {
+					for {
-						break
+						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
-
-				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)
 					}
-				}
+					for i, expected := range expectedPlayers {
-			}, 60*time.Second, time.Second, "players")
+						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()
+			wg.Add(1)
-				require.NoError(collect, listParams.SetSort([]domain.VillageSort{
+			go func() {
-					domain.VillageSortServerKeyASC,
+				defer wg.Done()
-					domain.VillageSortIDASC,
-				}))
-				require.NoError(collect, listParams.SetLimit(domain.VillageListMaxLimit))
 
-				allVillages := make(domain.Villages, 0, len(expectedVillages))
+				assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+					require.NoError(collect, ctx.Err())
 
-				for {
+					listParams := domain.NewListVillagesParams()
-					res, err := villageRepo.List(ctx, listParams)
+					require.NoError(collect, listParams.SetSort([]domain.VillageSort{
-					require.NoError(collect, err)
+						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() {
+					for {
-						break
+						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)) {
+						assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
-					return
+						assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
-				}
+						assert.Equal(collect, expected["Name"], actual.Name(), msg)
-				for i, expected := range expectedVillages {
+						assert.EqualValues(collect, expected["Points"], actual.Points(), msg)
-					actual := allVillages[i]
+						assert.EqualValues(collect, expected["X"], actual.X(), msg)
-					msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
+						assert.EqualValues(collect, expected["Y"], actual.Y(), msg)
-
+						assert.Equal(collect, expected["Continent"], actual.Continent(), msg)
-					assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
+						assert.EqualValues(collect, expected["Bonus"], actual.Bonus(), msg)
-					assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
+						assert.EqualValues(collect, expected["PlayerID"], actual.PlayerID(), msg)
-					assert.Equal(collect, expected["Name"], actual.Name(), msg)
+						assert.Equal(collect, expected["ProfileURL"], actual.ProfileURL().String(), msg)
-					assert.EqualValues(collect, expected["Points"], actual.Points(), msg)
+					}
-					assert.EqualValues(collect, expected["X"], actual.X(), msg)
+				}, 60*time.Second, time.Second, "villages")
-					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()
+			wg.Add(1)
-				require.NoError(collect, listParams.SetSort([]domain.TribeChangeSort{
+			go func() {
-					domain.TribeChangeSortIDASC,
+				defer wg.Done()
-				}))
-				require.NoError(collect, listParams.SetLimit(domain.TribeChangeListMaxLimit))
 
-				allTribeChanges := make(domain.TribeChanges, 0, len(expectedTribeChanges))
+				assert.EventuallyWithT(t, func(collect *assert.CollectT) {
+					require.NoError(collect, ctx.Err())
 
-				for {
+					listParams := domain.NewListTribeChangesParams()
-					res, err := tribeChangeRepo.List(ctx, listParams)
+					require.NoError(collect, listParams.SetSort([]domain.TribeChangeSort{
-					require.NoError(collect, err)
+						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() {
+					for {
-						break
+						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)) {
+						assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
-					return
+						assert.Equal(collect, expected["ServerKey"], actual.ServerKey(), msg)
-				}
+						assert.EqualValues(collect, expected["PlayerID"], actual.PlayerID(), msg)
-				for i, expected := range expectedTribeChanges {
+						assert.EqualValues(collect, expected["OldTribeID"], actual.OldTribeID(), msg)
-					actual := allTribeChanges[i]
+						assert.EqualValues(collect, expected["NewTribeID"], actual.NewTribeID(), msg)
-					msg := fmt.Sprintf("ID=%.0f,ServerKey=%s", expected["ID"], expected["ServerKey"])
+					}
+				}, 60*time.Second, time.Second, "tribe changes")
+			}()
 
-					assert.EqualValues(collect, expected["ID"], actual.ID(), msg)
+			wg.Wait()
-					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")
 		})
 	}
 }

internal/port/consumer_snapshot_creation_test.go

@@ -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) {
+	var wg sync.WaitGroup
-		require.NoError(collect, ctx.Err())
 
-		listParams := domain.NewListServersParams()
+	wg.Add(1)
-		require.NoError(collect, listParams.SetSort([]domain.ServerSort{
+	go func() {
-			domain.ServerSortKeyASC,
+		defer wg.Done()
-		}))
-		require.NoError(collect, listParams.SetSpecial(domain.NullBool{
-			V:     false,
-			Valid: true,
-		}))
-		require.NoError(collect, listParams.SetLimit(domain.ServerListMaxLimit))
 
-		for {
+		assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
-			res, err := serverRepo.List(ctx, listParams)
+			require.NoError(collect, ctx.Err())
-			require.NoError(collect, err)
 
-			for _, s := range res.Servers() {
+			listParams := domain.NewListServersParams()
-				assert.WithinDuration(collect, time.Now(), s.PlayerSnapshotsCreatedAt(), time.Minute, s.Key())
+			require.NoError(collect, listParams.SetSort([]domain.ServerSort{
-				assert.WithinDuration(collect, time.Now(), s.TribeSnapshotsCreatedAt(), time.Minute, s.Key())
+				domain.ServerSortKeyASC,
-			}
+			}))
+			require.NoError(collect, listParams.SetSpecial(domain.NullBool{
+				V:     false,
+				Valid: true,
+			}))
+			require.NoError(collect, listParams.SetLimit(domain.ServerListMaxLimit))
 
-			if res.Next().IsZero() {
+			for {
-				return
+				res, err := serverRepo.List(ctx, listParams)
-			}
+				require.NoError(collect, err)
 
-			require.NoError(collect, listParams.SetCursor(res.Next()))
+				for _, s := range res.Servers() {
-		}
+					assert.WithinDuration(collect, time.Now(), s.PlayerSnapshotsCreatedAt(), time.Minute, s.Key())
-	}, 30*time.Second, 500*time.Millisecond, "servers")
+					assert.WithinDuration(collect, time.Now(), s.TribeSnapshotsCreatedAt(), time.Minute, s.Key())
-
-	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
 				}
 
-				tribe := allTribes[idx]
+				if res.Next().IsZero() {
-
+					return
-				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
 				}
 
-				player := allPlayers[idx]
+				require.NoError(collect, listParams.SetCursor(res.Next()))
+			}
+		}, 30*time.Second, 500*time.Millisecond, "servers")
+	}()
 
-				assert.NotZero(collect, ps.ID(), msg)
+	wg.Add(1)
-				assert.Equal(collect, player.ID(), ps.PlayerID(), msg)
+	go func() {
-				assert.Equal(collect, player.ServerKey(), ps.ServerKey(), msg)
+		defer wg.Done()
-				assert.Equal(collect, player.NumVillages(), ps.NumVillages(), msg)
+
-				assert.Equal(collect, player.Points(), ps.Points(), msg)
+		assert.EventuallyWithTf(t, func(collect *assert.CollectT) {
-				assert.Equal(collect, player.Rank(), ps.Rank(), msg)
+			require.NoError(collect, ctx.Err())
-				assert.Equal(collect, player.TribeID(), ps.TribeID(), msg)
+
-				assert.Equal(collect, player.OD(), ps.OD(), msg)
+			listTribesParams := domain.NewListTribesParams()
-				assert.WithinDuration(collect, time.Now(), ps.CreatedAt(), time.Minute, msg)
+			require.NoError(collect, listTribesParams.SetSort([]domain.TribeSort{
-				assert.WithinDuration(collect, time.Now(), ps.Date(), 24*time.Hour, msg)
+				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
+			cnt := 0
-		assert.Equal(collect, len(allPlayers), cnt)
+
-	}, 30*time.Second, 500*time.Millisecond, "players")
+			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()
 }

internal/watermill/watermillamqptest/watermillamqptest.go

@@ -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,