551 lines
16 KiB
Go
551 lines
16 KiB
Go
package adapter_test
|
|
|
|
import (
|
|
"cmp"
|
|
"context"
|
|
"math"
|
|
"slices"
|
|
"testing"
|
|
|
|
"gitea.dwysokinski.me/twhelp/corev3/internal/domain"
|
|
"gitea.dwysokinski.me/twhelp/corev3/internal/domain/domaintest"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func testVillageRepository(t *testing.T, newRepos func(t *testing.T) repositories) {
|
|
t.Helper()
|
|
|
|
ctx := context.Background()
|
|
|
|
t.Run("CreateOrUpdate", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
repos := newRepos(t)
|
|
|
|
assertCreatedUpdated := func(t *testing.T, params []domain.CreateVillageParams) {
|
|
t.Helper()
|
|
|
|
require.NotEmpty(t, params)
|
|
|
|
ids := make([]int, 0, len(params))
|
|
for _, p := range params {
|
|
ids = append(ids, p.Base().ID())
|
|
}
|
|
|
|
listParams := domain.NewListVillagesParams()
|
|
require.NoError(t, listParams.SetIDs(ids))
|
|
require.NoError(t, listParams.SetServerKeys([]string{params[0].ServerKey()}))
|
|
|
|
res, err := repos.village.List(ctx, listParams)
|
|
require.NoError(t, err)
|
|
villages := res.Villages()
|
|
assert.Len(t, villages, len(params))
|
|
for i, p := range params {
|
|
idx := slices.IndexFunc(villages, func(village domain.Village) bool {
|
|
return village.ID() == p.Base().ID() && village.ServerKey() == p.ServerKey()
|
|
})
|
|
require.GreaterOrEqualf(t, idx, 0, "params[%d]", i)
|
|
village := villages[idx]
|
|
|
|
assert.Equalf(t, p.Base(), village.Base(), "params[%d]", i)
|
|
assert.Equalf(t, p.ServerKey(), village.ServerKey(), "params[%d]", i)
|
|
}
|
|
}
|
|
|
|
t.Run("OK", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
listServersRes, err := repos.server.List(ctx, domain.NewListServersParams())
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, listServersRes)
|
|
server := listServersRes.Servers()[0]
|
|
|
|
villagesToCreate := domain.BaseVillages{
|
|
domaintest.NewBaseVillage(t),
|
|
domaintest.NewBaseVillage(t),
|
|
}
|
|
|
|
createParams, err := domain.NewCreateVillageParams(server.Key(), villagesToCreate)
|
|
require.NoError(t, err)
|
|
|
|
require.NoError(t, repos.village.CreateOrUpdate(ctx, createParams...))
|
|
assertCreatedUpdated(t, createParams)
|
|
|
|
villagesToUpdate := domain.BaseVillages{
|
|
domaintest.NewBaseVillage(t, func(cfg *domaintest.BaseVillageConfig) {
|
|
cfg.ID = villagesToCreate[0].ID()
|
|
}),
|
|
}
|
|
|
|
updateParams, err := domain.NewCreateVillageParams(server.Key(), villagesToUpdate)
|
|
require.NoError(t, err)
|
|
|
|
require.NoError(t, repos.village.CreateOrUpdate(ctx, updateParams...))
|
|
assertCreatedUpdated(t, updateParams)
|
|
})
|
|
|
|
t.Run("OK: len(params) == 0", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
require.NoError(t, repos.village.CreateOrUpdate(ctx))
|
|
})
|
|
})
|
|
|
|
t.Run("List & ListWithRelations", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
repos := newRepos(t)
|
|
|
|
tests := []struct {
|
|
name string
|
|
params func(t *testing.T) domain.ListVillagesParams
|
|
assertResult func(t *testing.T, params domain.ListVillagesParams, res domain.ListVillagesResult)
|
|
// assertResultWithRelations is optional
|
|
assertResultWithRelations func(
|
|
t *testing.T,
|
|
params domain.ListVillagesParams,
|
|
res domain.ListVillagesWithRelationsResult,
|
|
)
|
|
assertError func(t *testing.T, err error)
|
|
}{
|
|
{
|
|
name: "OK: default params",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
return domain.NewListVillagesParams()
|
|
},
|
|
assertResult: func(t *testing.T, _ domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
villages := res.Villages()
|
|
assert.NotEmpty(t, len(villages))
|
|
assert.True(t, slices.IsSortedFunc(villages, func(a, b domain.Village) int {
|
|
return cmp.Or(
|
|
cmp.Compare(a.ServerKey(), b.ServerKey()),
|
|
cmp.Compare(a.ID(), b.ID()),
|
|
)
|
|
}))
|
|
assert.False(t, res.Self().IsZero())
|
|
assert.True(t, res.Next().IsZero())
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: sort=[serverKey DESC, id DESC]",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
params := domain.NewListVillagesParams()
|
|
require.NoError(t, params.SetSort([]domain.VillageSort{domain.VillageSortServerKeyDESC, domain.VillageSortIDDESC}))
|
|
return params
|
|
},
|
|
assertResult: func(t *testing.T, _ domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
villages := res.Villages()
|
|
assert.NotEmpty(t, len(villages))
|
|
assert.True(t, slices.IsSortedFunc(villages, func(a, b domain.Village) int {
|
|
return cmp.Or(
|
|
cmp.Compare(a.ServerKey(), b.ServerKey()),
|
|
cmp.Compare(a.ID(), b.ID()),
|
|
) * -1
|
|
}))
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: ids serverKeys",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
|
|
params := domain.NewListVillagesParams()
|
|
|
|
res, err := repos.village.List(ctx, params)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, res.Villages())
|
|
randVillage := res.Villages()[0]
|
|
|
|
require.NoError(t, params.SetIDs([]int{randVillage.ID()}))
|
|
require.NoError(t, params.SetServerKeys([]string{randVillage.ServerKey()}))
|
|
|
|
return params
|
|
},
|
|
assertResult: func(t *testing.T, params domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
|
|
ids := params.IDs()
|
|
serverKeys := params.ServerKeys()
|
|
|
|
villages := res.Villages()
|
|
assert.Len(t, villages, len(ids))
|
|
for _, v := range villages {
|
|
assert.True(t, slices.Contains(ids, v.ID()))
|
|
assert.True(t, slices.Contains(serverKeys, v.ServerKey()))
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: coords serverKeys",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
|
|
params := domain.NewListVillagesParams()
|
|
|
|
res, err := repos.village.List(ctx, params)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, res.Villages())
|
|
randVillage := res.Villages()[0]
|
|
|
|
require.NoError(t, params.SetCoords([]domain.Coords{randVillage.Coords()}))
|
|
require.NoError(t, params.SetServerKeys([]string{randVillage.ServerKey()}))
|
|
|
|
return params
|
|
},
|
|
assertResult: func(t *testing.T, params domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
|
|
coords := params.Coords()
|
|
serverKeys := params.ServerKeys()
|
|
|
|
villages := res.Villages()
|
|
assert.Len(t, villages, len(coords))
|
|
for _, v := range villages {
|
|
assert.True(t, slices.Contains(coords, v.Coords()))
|
|
assert.True(t, slices.Contains(serverKeys, v.ServerKey()))
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: playerIDs serverKeys",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
|
|
params := domain.NewListVillagesParams()
|
|
|
|
res, err := repos.village.List(ctx, params)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, res.Villages())
|
|
|
|
var randVillage domain.Village
|
|
for _, v := range res.Villages() {
|
|
if v.PlayerID() > 0 {
|
|
randVillage = v
|
|
break
|
|
}
|
|
}
|
|
|
|
require.NoError(t, params.SetPlayerIDs([]int{randVillage.PlayerID()}))
|
|
require.NoError(t, params.SetServerKeys([]string{randVillage.ServerKey()}))
|
|
|
|
return params
|
|
},
|
|
assertResult: func(t *testing.T, params domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
|
|
playerIDs := params.PlayerIDs()
|
|
serverKeys := params.ServerKeys()
|
|
|
|
villages := res.Villages()
|
|
assert.NotEmpty(t, villages)
|
|
for _, v := range villages {
|
|
assert.True(t, slices.Contains(playerIDs, v.PlayerID()))
|
|
assert.True(t, slices.Contains(serverKeys, v.ServerKey()))
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: tribeIDs serverKeys",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
|
|
params := domain.NewListVillagesParams()
|
|
|
|
res, err := repos.village.ListWithRelations(ctx, params)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, res.Villages())
|
|
|
|
var randVillage domain.VillageWithRelations
|
|
for _, v := range res.Villages() {
|
|
if v.Player().V.Tribe().V.ID() > 0 {
|
|
randVillage = v
|
|
}
|
|
}
|
|
|
|
require.NoError(t, params.SetTribeIDs([]int{randVillage.Player().V.Tribe().V.ID()}))
|
|
require.NoError(t, params.SetServerKeys([]string{randVillage.Village().ServerKey()}))
|
|
|
|
return params
|
|
},
|
|
assertResult: func(t *testing.T, _ domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, res.Villages())
|
|
},
|
|
assertResultWithRelations: func(
|
|
t *testing.T,
|
|
params domain.ListVillagesParams,
|
|
res domain.ListVillagesWithRelationsResult,
|
|
) {
|
|
t.Helper()
|
|
|
|
tribeIDs := params.TribeIDs()
|
|
serverKeys := params.ServerKeys()
|
|
|
|
villages := res.Villages()
|
|
assert.NotEmpty(t, villages)
|
|
for _, v := range villages {
|
|
assert.True(t, slices.Contains(tribeIDs, v.Player().V.Tribe().V.ID()))
|
|
assert.True(t, slices.Contains(serverKeys, v.Village().ServerKey()))
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: cursor serverKeys sort=[id ASC]",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
|
|
params := domain.NewListVillagesParams()
|
|
|
|
res, err := repos.village.List(ctx, params)
|
|
require.NoError(t, err)
|
|
require.Greater(t, len(res.Villages()), 2)
|
|
|
|
require.NoError(t, params.SetSort([]domain.VillageSort{domain.VillageSortIDASC}))
|
|
require.NoError(t, params.SetServerKeys([]string{res.Villages()[1].ServerKey()}))
|
|
require.NoError(t, params.SetCursor(domaintest.NewVillageCursor(t, func(cfg *domaintest.VillageCursorConfig) {
|
|
cfg.ID = res.Villages()[1].ID()
|
|
})))
|
|
|
|
return params
|
|
},
|
|
assertResult: func(t *testing.T, params domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
|
|
serverKeys := params.ServerKeys()
|
|
|
|
villages := res.Villages()
|
|
assert.NotEmpty(t, len(villages))
|
|
for _, v := range villages {
|
|
assert.GreaterOrEqual(t, v.ID(), params.Cursor().ID())
|
|
assert.True(t, slices.Contains(serverKeys, v.ServerKey()))
|
|
}
|
|
assert.True(t, slices.IsSortedFunc(villages, func(a, b domain.Village) int {
|
|
return cmp.Compare(a.ID(), b.ID())
|
|
}))
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: cursor sort=[serverKey ASC, id ASC]",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
|
|
params := domain.NewListVillagesParams()
|
|
require.NoError(t, params.SetSort([]domain.VillageSort{
|
|
domain.VillageSortServerKeyASC,
|
|
domain.VillageSortIDASC,
|
|
}))
|
|
|
|
res, err := repos.village.List(ctx, params)
|
|
require.NoError(t, err)
|
|
require.Greater(t, len(res.Villages()), 2)
|
|
|
|
require.NoError(t, params.SetCursor(domaintest.NewVillageCursor(t, func(cfg *domaintest.VillageCursorConfig) {
|
|
cfg.ID = res.Villages()[1].ID()
|
|
cfg.ServerKey = res.Villages()[1].ServerKey()
|
|
})))
|
|
|
|
return params
|
|
},
|
|
assertResult: func(t *testing.T, params domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
villages := res.Villages()
|
|
assert.NotEmpty(t, len(villages))
|
|
assert.True(t, slices.IsSortedFunc(villages, func(a, b domain.Village) int {
|
|
return cmp.Or(
|
|
cmp.Compare(a.ServerKey(), b.ServerKey()),
|
|
cmp.Compare(a.ID(), b.ID()),
|
|
)
|
|
}))
|
|
assert.GreaterOrEqual(t, villages[0].ID(), params.Cursor().ID())
|
|
for _, v := range villages {
|
|
assert.GreaterOrEqual(t, v.ServerKey(), params.Cursor().ServerKey())
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: cursor sort=[serverKey DESC, id DESC]",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
|
|
params := domain.NewListVillagesParams()
|
|
require.NoError(t, params.SetSort([]domain.VillageSort{
|
|
domain.VillageSortServerKeyDESC,
|
|
domain.VillageSortIDDESC,
|
|
}))
|
|
|
|
res, err := repos.village.List(ctx, params)
|
|
require.NoError(t, err)
|
|
require.Greater(t, len(res.Villages()), 2)
|
|
|
|
require.NoError(t, params.SetCursor(domaintest.NewVillageCursor(t, func(cfg *domaintest.VillageCursorConfig) {
|
|
cfg.ID = res.Villages()[1].ID()
|
|
cfg.ServerKey = res.Villages()[1].ServerKey()
|
|
})))
|
|
|
|
return params
|
|
},
|
|
assertResult: func(t *testing.T, params domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
villages := res.Villages()
|
|
assert.NotEmpty(t, len(villages))
|
|
assert.True(t, slices.IsSortedFunc(villages, func(a, b domain.Village) int {
|
|
return cmp.Or(
|
|
cmp.Compare(a.ServerKey(), b.ServerKey()),
|
|
cmp.Compare(a.ID(), b.ID()),
|
|
) * -1
|
|
}))
|
|
assert.LessOrEqual(t, villages[0].ID(), params.Cursor().ID())
|
|
for _, v := range villages {
|
|
assert.LessOrEqual(t, v.ServerKey(), params.Cursor().ServerKey())
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: limit=2",
|
|
params: func(t *testing.T) domain.ListVillagesParams {
|
|
t.Helper()
|
|
params := domain.NewListVillagesParams()
|
|
require.NoError(t, params.SetLimit(2))
|
|
return params
|
|
},
|
|
assertResult: func(t *testing.T, params domain.ListVillagesParams, res domain.ListVillagesResult) {
|
|
t.Helper()
|
|
assert.Len(t, res.Villages(), params.Limit())
|
|
assert.False(t, res.Self().IsZero())
|
|
assert.False(t, res.Next().IsZero())
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
params := tt.params(t)
|
|
|
|
res, err := repos.village.List(ctx, params)
|
|
tt.assertError(t, err)
|
|
tt.assertResult(t, params, res)
|
|
|
|
resWithRelations, err := repos.village.ListWithRelations(ctx, params)
|
|
tt.assertError(t, err)
|
|
require.Len(t, resWithRelations.Villages(), len(res.Villages()))
|
|
for i, v := range resWithRelations.Villages() {
|
|
assert.Equal(t, res.Villages()[i], v.Village())
|
|
assert.Equal(t, v.Village().PlayerID(), v.Player().V.Player().ID())
|
|
assert.Equal(t, v.Village().PlayerID() != 0, v.Player().Valid)
|
|
}
|
|
if tt.assertResultWithRelations != nil {
|
|
tt.assertResultWithRelations(t, params, resWithRelations)
|
|
}
|
|
})
|
|
}
|
|
})
|
|
|
|
t.Run("Delete", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
repos := newRepos(t)
|
|
|
|
listServersParams := domain.NewListServersParams()
|
|
require.NoError(t, listServersParams.SetSpecial(domain.NullBool{V: false, Valid: true}))
|
|
listServersRes, listServersErr := repos.server.List(ctx, listServersParams)
|
|
require.NoError(t, listServersErr)
|
|
require.NotEmpty(t, listServersRes)
|
|
|
|
t.Run("OK", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
serverKeys := make([]string, 0, len(listServersRes.Servers()))
|
|
for _, s := range listServersRes.Servers() {
|
|
serverKeys = append(serverKeys, s.Key())
|
|
}
|
|
|
|
listVillagesParams := domain.NewListVillagesParams()
|
|
require.NoError(t, listVillagesParams.SetServerKeys(serverKeys))
|
|
|
|
res, err := repos.village.List(ctx, listVillagesParams)
|
|
require.NoError(t, err)
|
|
villagesBeforeDelete := res.Villages()
|
|
|
|
var serverKey string
|
|
var ids []int
|
|
|
|
for _, v := range villagesBeforeDelete {
|
|
if serverKey == "" {
|
|
serverKey = v.ServerKey()
|
|
}
|
|
|
|
if v.ServerKey() == serverKey {
|
|
ids = append(ids, v.ID())
|
|
}
|
|
}
|
|
|
|
idsToDelete := ids[:int(math.Ceil(float64(len(ids))/2))]
|
|
|
|
require.NoError(t, repos.village.Delete(ctx, serverKey, idsToDelete...))
|
|
|
|
res, err = repos.village.List(ctx, listVillagesParams)
|
|
require.NoError(t, err)
|
|
villagesAfterDelete := res.Villages()
|
|
assert.Len(t, villagesAfterDelete, len(villagesBeforeDelete)-len(idsToDelete))
|
|
for _, v := range villagesAfterDelete {
|
|
if v.ServerKey() == serverKey && slices.Contains(ids, v.ID()) {
|
|
assert.False(t, slices.Contains(idsToDelete, v.ID()))
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("OK: len(ids) == 0", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
require.NoError(t, repos.village.Delete(ctx, listServersRes.Servers()[0].Key()))
|
|
})
|
|
})
|
|
}
|