2023-12-21 06:28:53 +00:00
|
|
|
package domain_test
|
|
|
|
|
|
|
|
import (
|
2023-12-24 10:44:20 +00:00
|
|
|
"fmt"
|
2023-12-30 09:10:03 +00:00
|
|
|
"math"
|
2023-12-25 09:13:42 +00:00
|
|
|
"slices"
|
2023-12-21 06:28:53 +00:00
|
|
|
"testing"
|
|
|
|
|
2024-04-06 04:32:29 +00:00
|
|
|
"gitea.dwysokinski.me/twhelp/core/internal/domain"
|
|
|
|
"gitea.dwysokinski.me/twhelp/core/internal/domain/domaintest"
|
2024-03-01 07:15:06 +00:00
|
|
|
"github.com/brianvoe/gofakeit/v7"
|
2023-12-21 06:28:53 +00:00
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
)
|
|
|
|
|
2023-12-25 09:13:42 +00:00
|
|
|
func TestServers_Close(t *testing.T) {
|
2023-12-21 06:28:53 +00:00
|
|
|
t.Parallel()
|
|
|
|
|
2023-12-25 09:13:42 +00:00
|
|
|
open := domain.BaseServers{
|
|
|
|
domaintest.NewBaseServer(t),
|
|
|
|
domaintest.NewBaseServer(t),
|
|
|
|
domaintest.NewBaseServer(t),
|
2023-12-21 06:28:53 +00:00
|
|
|
}
|
|
|
|
|
2023-12-25 09:13:42 +00:00
|
|
|
servers := domain.Servers{
|
|
|
|
domaintest.NewServer(t, func(cfg *domaintest.ServerConfig) {
|
|
|
|
cfg.Key = open[0].Key()
|
|
|
|
}),
|
|
|
|
domaintest.NewServer(t, func(cfg *domaintest.ServerConfig) {
|
|
|
|
cfg.Key = open[2].Key()
|
|
|
|
}),
|
|
|
|
domaintest.NewServer(t),
|
|
|
|
domaintest.NewServer(t, func(cfg *domaintest.ServerConfig) {
|
|
|
|
cfg.Open = false
|
|
|
|
}),
|
2023-12-21 06:28:53 +00:00
|
|
|
}
|
|
|
|
|
2023-12-25 09:13:42 +00:00
|
|
|
res, err := servers.Close(open)
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.NotEmpty(t, res)
|
|
|
|
for _, s := range servers {
|
2023-12-28 10:56:59 +00:00
|
|
|
expected := domaintest.NewBaseServer(t, func(cfg *domaintest.BaseServerConfig) {
|
|
|
|
cfg.Key = s.Key()
|
|
|
|
cfg.URL = s.URL()
|
|
|
|
cfg.Open = false
|
|
|
|
})
|
|
|
|
|
2023-12-25 09:13:42 +00:00
|
|
|
if !s.Open() || slices.ContainsFunc(open, func(server domain.BaseServer) bool {
|
|
|
|
return server.Key() == s.Key()
|
|
|
|
}) {
|
2023-12-28 10:56:59 +00:00
|
|
|
assert.NotContains(t, res, expected)
|
2023-12-25 09:13:42 +00:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2023-12-28 10:56:59 +00:00
|
|
|
assert.Contains(t, res, expected)
|
2023-12-21 06:28:53 +00:00
|
|
|
}
|
|
|
|
}
|
2023-12-23 09:54:47 +00:00
|
|
|
|
2024-03-24 07:13:26 +00:00
|
|
|
func TestServers_CleanUpData(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
servers := domain.Servers{
|
|
|
|
domaintest.NewServer(t, func(cfg *domaintest.ServerConfig) {
|
|
|
|
cfg.Special = true
|
|
|
|
}),
|
|
|
|
domaintest.NewServer(t, func(cfg *domaintest.ServerConfig) {
|
|
|
|
cfg.Open = true
|
|
|
|
cfg.Special = false
|
|
|
|
}),
|
|
|
|
domaintest.NewServer(t, func(cfg *domaintest.ServerConfig) {
|
|
|
|
cfg.Open = false
|
|
|
|
cfg.Special = false
|
|
|
|
}),
|
|
|
|
}
|
|
|
|
|
|
|
|
expectedServers := domain.Servers{servers[2]}
|
|
|
|
|
|
|
|
res, err := servers.CleanUpData()
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Len(t, res, len(expectedServers))
|
|
|
|
for i, expected := range expectedServers {
|
|
|
|
idx := slices.IndexFunc(res, func(payload domain.CleanUpDataCmdPayload) bool {
|
|
|
|
return payload.Server().Key() == expected.Key()
|
|
|
|
})
|
|
|
|
require.GreaterOrEqualf(t, idx, 0, "expected[%d] not found", i)
|
|
|
|
|
|
|
|
assert.Equal(t, expected.Key(), res[idx].Server().Key())
|
|
|
|
assert.Equal(t, expected.VersionCode(), res[idx].Server().VersionCode())
|
|
|
|
assert.Equal(t, expected.Open(), res[idx].Server().Open())
|
|
|
|
assert.Equal(t, expected.Special(), res[idx].Server().Special())
|
|
|
|
assert.Equal(t, expected.PlayerDataSyncedAt(), res[idx].Server().PlayerDataSyncedAt())
|
|
|
|
assert.Equal(t, expected.PlayerSnapshotsCreatedAt(), res[idx].Server().PlayerSnapshotsCreatedAt())
|
|
|
|
assert.Equal(t, expected.TribeDataSyncedAt(), res[idx].Server().TribeDataSyncedAt())
|
|
|
|
assert.Equal(t, expected.TribeSnapshotsCreatedAt(), res[idx].Server().TribeSnapshotsCreatedAt())
|
|
|
|
assert.Equal(t, expected.VillageDataSyncedAt(), res[idx].Server().VillageDataSyncedAt())
|
|
|
|
assert.Equal(t, expected.EnnoblementDataSyncedAt(), res[idx].Server().EnnoblementDataSyncedAt())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-12-24 10:44:20 +00:00
|
|
|
func TestNewCreateServerParams(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
2023-12-25 09:13:42 +00:00
|
|
|
validVersion := domaintest.NewVersion(t)
|
|
|
|
validBaseServer := domaintest.NewBaseServer(t)
|
2023-12-24 10:44:20 +00:00
|
|
|
|
|
|
|
type args struct {
|
|
|
|
servers domain.BaseServers
|
|
|
|
versionCode string
|
|
|
|
}
|
|
|
|
|
|
|
|
type test struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []test{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
versionCode: validVersion.Code(),
|
|
|
|
servers: domain.BaseServers{
|
|
|
|
validBaseServer,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, versionCodeTest := range newVersionCodeValidationTests() {
|
|
|
|
tests = append(tests, test{
|
|
|
|
name: versionCodeTest.name,
|
|
|
|
args: args{
|
|
|
|
versionCode: versionCodeTest.code,
|
|
|
|
servers: domain.BaseServers{
|
|
|
|
validBaseServer,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
2023-12-27 08:07:40 +00:00
|
|
|
Model: "CreateServerParams",
|
2023-12-24 10:44:20 +00:00
|
|
|
Field: "versionCode",
|
2023-12-27 08:07:40 +00:00
|
|
|
Err: versionCodeTest.expectedErr,
|
2023-12-24 10:44:20 +00:00
|
|
|
},
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
res, err := domain.NewCreateServerParams(tt.args.servers, tt.args.versionCode)
|
|
|
|
require.ErrorIs(t, err, tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
require.Len(t, res, len(tt.args.servers))
|
|
|
|
for i, b := range tt.args.servers {
|
|
|
|
assert.Equal(t, b, res[i].Base())
|
|
|
|
assert.Equal(t, tt.args.versionCode, res[i].VersionCode())
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-12-30 09:10:03 +00:00
|
|
|
func TestUpdateServerParams_SetNumTribes(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
numTribes domain.NullInt
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
numTribes: domain.NullInt{
|
2024-02-28 06:59:10 +00:00
|
|
|
V: gofakeit.IntRange(0, math.MaxInt),
|
2023-12-30 09:10:03 +00:00
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: null value",
|
|
|
|
args: args{
|
|
|
|
numTribes: domain.NullInt{
|
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: numTribes < 0",
|
|
|
|
args: args{
|
|
|
|
numTribes: domain.NullInt{
|
2024-02-28 06:59:10 +00:00
|
|
|
V: -1,
|
2023-12-30 09:10:03 +00:00
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "UpdateServerParams",
|
|
|
|
Field: "numTribes",
|
|
|
|
Err: domain.MinGreaterEqualError{
|
|
|
|
Min: 0,
|
|
|
|
Current: -1,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var params domain.UpdateServerParams
|
|
|
|
|
|
|
|
require.ErrorIs(t, params.SetNumTribes(tt.args.numTribes), tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.numTribes, params.NumTribes())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-01 06:33:48 +00:00
|
|
|
func TestUpdateServerParams_SetNumPlayers(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
numPlayers domain.NullInt
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
numPlayers: domain.NullInt{
|
|
|
|
V: gofakeit.IntRange(0, math.MaxInt),
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: null value",
|
|
|
|
args: args{
|
|
|
|
numPlayers: domain.NullInt{
|
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: numPlayers < 0",
|
|
|
|
args: args{
|
|
|
|
numPlayers: domain.NullInt{
|
|
|
|
V: -1,
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "UpdateServerParams",
|
|
|
|
Field: "numPlayers",
|
|
|
|
Err: domain.MinGreaterEqualError{
|
|
|
|
Min: 0,
|
|
|
|
Current: -1,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var params domain.UpdateServerParams
|
|
|
|
|
|
|
|
require.ErrorIs(t, params.SetNumPlayers(tt.args.numPlayers), tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.numPlayers, params.NumPlayers())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestUpdateServerParams_SetNumVillages(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
numVillages domain.NullInt
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
numVillages: domain.NullInt{
|
|
|
|
V: gofakeit.IntRange(0, math.MaxInt),
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: null value",
|
|
|
|
args: args{
|
|
|
|
numVillages: domain.NullInt{
|
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: numVillages < 0",
|
|
|
|
args: args{
|
|
|
|
numVillages: domain.NullInt{
|
|
|
|
V: -1,
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "UpdateServerParams",
|
|
|
|
Field: "numVillages",
|
|
|
|
Err: domain.MinGreaterEqualError{
|
|
|
|
Min: 0,
|
|
|
|
Current: -1,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var params domain.UpdateServerParams
|
|
|
|
|
|
|
|
require.ErrorIs(t, params.SetNumVillages(tt.args.numVillages), tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.numVillages, params.NumVillages())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestUpdateServerParams_SetNumPlayerVillages(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
numPlayerVillages domain.NullInt
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
numPlayerVillages: domain.NullInt{
|
|
|
|
V: gofakeit.IntRange(0, math.MaxInt),
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: null value",
|
|
|
|
args: args{
|
|
|
|
numPlayerVillages: domain.NullInt{
|
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: numPlayerVillages < 0",
|
|
|
|
args: args{
|
|
|
|
numPlayerVillages: domain.NullInt{
|
|
|
|
V: -1,
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "UpdateServerParams",
|
|
|
|
Field: "numPlayerVillages",
|
|
|
|
Err: domain.MinGreaterEqualError{
|
|
|
|
Min: 0,
|
|
|
|
Current: -1,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var params domain.UpdateServerParams
|
|
|
|
|
|
|
|
require.ErrorIs(t, params.SetNumPlayerVillages(tt.args.numPlayerVillages), tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.numPlayerVillages, params.NumPlayerVillages())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestUpdateServerParams_SetNumBarbarianVillages(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
numBarbarianVillages domain.NullInt
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
numBarbarianVillages: domain.NullInt{
|
|
|
|
V: gofakeit.IntRange(0, math.MaxInt),
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: null value",
|
|
|
|
args: args{
|
|
|
|
numBarbarianVillages: domain.NullInt{
|
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: numBarbarianVillages < 0",
|
|
|
|
args: args{
|
|
|
|
numBarbarianVillages: domain.NullInt{
|
|
|
|
V: -1,
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "UpdateServerParams",
|
|
|
|
Field: "numBarbarianVillages",
|
|
|
|
Err: domain.MinGreaterEqualError{
|
|
|
|
Min: 0,
|
|
|
|
Current: -1,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var params domain.UpdateServerParams
|
|
|
|
|
|
|
|
require.ErrorIs(t, params.SetNumBarbarianVillages(tt.args.numBarbarianVillages), tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.numBarbarianVillages, params.NumBarbarianVillages())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestUpdateServerParams_SetNumBonusVillages(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
numBonusVillages domain.NullInt
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
numBonusVillages: domain.NullInt{
|
|
|
|
V: gofakeit.IntRange(0, math.MaxInt),
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: null value",
|
|
|
|
args: args{
|
|
|
|
numBonusVillages: domain.NullInt{
|
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: numBonusVillages < 0",
|
|
|
|
args: args{
|
|
|
|
numBonusVillages: domain.NullInt{
|
|
|
|
V: -1,
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "UpdateServerParams",
|
|
|
|
Field: "numBonusVillages",
|
|
|
|
Err: domain.MinGreaterEqualError{
|
|
|
|
Min: 0,
|
|
|
|
Current: -1,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
var params domain.UpdateServerParams
|
|
|
|
|
|
|
|
require.ErrorIs(t, params.SetNumBonusVillages(tt.args.numBonusVillages), tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.numBonusVillages, params.NumBonusVillages())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-02 08:49:42 +00:00
|
|
|
func TestServerSort_IsInConflict(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
sorts [2]domain.ServerSort
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedRes bool
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK: key:ASC open:ASC",
|
|
|
|
args: args{
|
|
|
|
sorts: [2]domain.ServerSort{domain.ServerSortKeyASC, domain.ServerSortOpenASC},
|
|
|
|
},
|
|
|
|
expectedRes: false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: key:ASC open:DESC",
|
|
|
|
args: args{
|
|
|
|
sorts: [2]domain.ServerSort{domain.ServerSortKeyASC, domain.ServerSortOpenDESC},
|
|
|
|
},
|
|
|
|
expectedRes: false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: key:DESC open:ASC",
|
|
|
|
args: args{
|
|
|
|
sorts: [2]domain.ServerSort{domain.ServerSortKeyDESC, domain.ServerSortOpenASC},
|
|
|
|
},
|
|
|
|
expectedRes: false,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: key:ASC key:DESC",
|
|
|
|
args: args{
|
|
|
|
sorts: [2]domain.ServerSort{domain.ServerSortKeyASC, domain.ServerSortKeyDESC},
|
|
|
|
},
|
|
|
|
expectedRes: true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: open:DESC open:ASC",
|
|
|
|
args: args{
|
|
|
|
sorts: [2]domain.ServerSort{domain.ServerSortOpenDESC, domain.ServerSortOpenASC},
|
|
|
|
},
|
|
|
|
expectedRes: true,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: open:DESC open:DESC",
|
|
|
|
args: args{
|
|
|
|
sorts: [2]domain.ServerSort{domain.ServerSortOpenDESC, domain.ServerSortOpenDESC},
|
|
|
|
},
|
|
|
|
expectedRes: true,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
assert.Equal(t, tt.expectedRes, tt.args.sorts[0].IsInConflict(tt.args.sorts[1]))
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 07:17:47 +00:00
|
|
|
func TestNewServerCursor(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
validServerCursor := domaintest.NewServerCursor(t)
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
key string
|
|
|
|
open bool
|
|
|
|
}
|
|
|
|
|
|
|
|
type test struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []test{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
key: validServerCursor.Key(),
|
|
|
|
open: validServerCursor.Open(),
|
|
|
|
},
|
|
|
|
expectedErr: nil,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, serverKeyTest := range newServerKeyValidationTests() {
|
|
|
|
tests = append(tests, test{
|
|
|
|
name: serverKeyTest.name,
|
|
|
|
args: args{
|
|
|
|
key: serverKeyTest.key,
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "ServerCursor",
|
|
|
|
Field: "key",
|
|
|
|
Err: serverKeyTest.expectedErr,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
sc, err := domain.NewServerCursor(tt.args.key, tt.args.open)
|
|
|
|
require.ErrorIs(t, err, tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.key, sc.Key())
|
|
|
|
assert.Equal(t, tt.args.open, sc.Open())
|
|
|
|
assert.NotEmpty(t, sc.Encode())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-12-24 10:44:20 +00:00
|
|
|
func TestListServersParams_SetSort(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
sort []domain.ServerSort
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
sort: []domain.ServerSort{
|
|
|
|
domain.ServerSortKeyASC,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
2024-03-25 07:29:37 +00:00
|
|
|
name: "OK: empty slice",
|
2023-12-24 10:44:20 +00:00
|
|
|
args: args{
|
|
|
|
sort: nil,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: len(sort) > 2",
|
|
|
|
args: args{
|
|
|
|
sort: []domain.ServerSort{
|
|
|
|
domain.ServerSortKeyASC,
|
|
|
|
domain.ServerSortKeyDESC,
|
|
|
|
domain.ServerSortOpenASC,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
2023-12-27 08:07:40 +00:00
|
|
|
Model: "ListServersParams",
|
2023-12-24 10:44:20 +00:00
|
|
|
Field: "sort",
|
|
|
|
Err: domain.LenOutOfRangeError{
|
2024-03-25 07:29:37 +00:00
|
|
|
Min: 0,
|
2023-12-24 10:44:20 +00:00
|
|
|
Max: 2,
|
|
|
|
Current: 3,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2024-03-02 08:49:42 +00:00
|
|
|
{
|
|
|
|
name: "ERR: conflict",
|
|
|
|
args: args{
|
|
|
|
sort: []domain.ServerSort{
|
|
|
|
domain.ServerSortKeyASC,
|
|
|
|
domain.ServerSortKeyDESC,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "ListServersParams",
|
|
|
|
Field: "sort",
|
|
|
|
Err: domain.SortConflictError{
|
|
|
|
Sort: [2]string{domain.ServerSortKeyASC.String(), domain.ServerSortKeyDESC.String()},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2023-12-24 10:44:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
params := domain.NewListServersParams()
|
|
|
|
|
|
|
|
require.ErrorIs(t, params.SetSort(tt.args.sort), tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.sort, params.Sort())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 07:17:47 +00:00
|
|
|
func TestListServersParams_SetEncodedCursor(t *testing.T) {
|
2023-12-24 10:44:20 +00:00
|
|
|
t.Parallel()
|
|
|
|
|
2024-02-07 07:17:47 +00:00
|
|
|
validCursor := domaintest.NewServerCursor(t)
|
|
|
|
|
2023-12-24 10:44:20 +00:00
|
|
|
type args struct {
|
2024-02-07 07:17:47 +00:00
|
|
|
cursor string
|
2023-12-24 10:44:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
2024-02-07 07:17:47 +00:00
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedCursor domain.ServerCursor
|
|
|
|
expectedErr error
|
2023-12-24 10:44:20 +00:00
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
2024-02-07 07:17:47 +00:00
|
|
|
cursor: validCursor.Encode(),
|
2023-12-24 10:44:20 +00:00
|
|
|
},
|
2024-02-07 07:17:47 +00:00
|
|
|
expectedCursor: validCursor,
|
2023-12-24 10:44:20 +00:00
|
|
|
},
|
|
|
|
{
|
2024-02-07 07:17:47 +00:00
|
|
|
name: "ERR: len(cursor) < 1",
|
2023-12-24 10:44:20 +00:00
|
|
|
args: args{
|
2024-02-07 07:17:47 +00:00
|
|
|
cursor: "",
|
2023-12-24 10:44:20 +00:00
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
2023-12-27 08:07:40 +00:00
|
|
|
Model: "ListServersParams",
|
2024-02-07 07:17:47 +00:00
|
|
|
Field: "cursor",
|
|
|
|
Err: domain.LenOutOfRangeError{
|
2023-12-24 10:44:20 +00:00
|
|
|
Min: 1,
|
2024-02-07 07:17:47 +00:00
|
|
|
Max: 1000,
|
2023-12-24 10:44:20 +00:00
|
|
|
Current: 0,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
2024-02-07 07:17:47 +00:00
|
|
|
name: "ERR: len(cursor) > 1000",
|
2023-12-24 10:44:20 +00:00
|
|
|
args: args{
|
2024-02-07 07:17:47 +00:00
|
|
|
cursor: gofakeit.LetterN(1001),
|
2023-12-24 10:44:20 +00:00
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
2023-12-27 08:07:40 +00:00
|
|
|
Model: "ListServersParams",
|
2024-02-07 07:17:47 +00:00
|
|
|
Field: "cursor",
|
|
|
|
Err: domain.LenOutOfRangeError{
|
|
|
|
Min: 1,
|
|
|
|
Max: 1000,
|
|
|
|
Current: 1001,
|
2023-12-24 10:44:20 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
2024-02-07 07:17:47 +00:00
|
|
|
{
|
|
|
|
name: "ERR: malformed base64",
|
|
|
|
args: args{
|
|
|
|
cursor: "112345",
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "ListServersParams",
|
|
|
|
Field: "cursor",
|
|
|
|
Err: domain.ErrInvalidCursor,
|
|
|
|
},
|
|
|
|
},
|
2023-12-24 10:44:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
params := domain.NewListServersParams()
|
|
|
|
|
2024-02-07 07:17:47 +00:00
|
|
|
require.ErrorIs(t, params.SetEncodedCursor(tt.args.cursor), tt.expectedErr)
|
2023-12-24 10:44:20 +00:00
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
2024-02-07 07:17:47 +00:00
|
|
|
assert.Equal(t, tt.expectedCursor.Key(), params.Cursor().Key())
|
|
|
|
assert.Equal(t, tt.expectedCursor.Open(), params.Cursor().Open())
|
|
|
|
assert.Equal(t, tt.args.cursor, params.Cursor().Encode())
|
2023-12-24 10:44:20 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-03-01 06:33:48 +00:00
|
|
|
func TestListServersParams_SetKeys(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
keys []string
|
|
|
|
}
|
|
|
|
|
|
|
|
type test struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []test{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
keys: []string{
|
|
|
|
domaintest.RandServerKey(),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, serverKeyTest := range newServerKeyValidationTests() {
|
|
|
|
tests = append(tests, test{
|
|
|
|
name: serverKeyTest.name,
|
|
|
|
args: args{
|
|
|
|
keys: []string{serverKeyTest.key},
|
|
|
|
},
|
|
|
|
expectedErr: domain.SliceElementValidationError{
|
|
|
|
Model: "ListServersParams",
|
|
|
|
Field: "keys",
|
|
|
|
Index: 0,
|
|
|
|
Err: serverKeyTest.expectedErr,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
params := domain.NewListServersParams()
|
|
|
|
|
|
|
|
require.ErrorIs(t, params.SetKeys(tt.args.keys), tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.keys, params.Keys())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestListServersParams_SetVersionCodes(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
|
|
|
versionCodes []string
|
|
|
|
}
|
|
|
|
|
|
|
|
type test struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []test{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
|
|
|
versionCodes: []string{
|
|
|
|
domaintest.RandVersionCode(),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, versionCodeTest := range newVersionCodeValidationTests() {
|
|
|
|
tests = append(tests, test{
|
|
|
|
name: versionCodeTest.name,
|
|
|
|
args: args{
|
|
|
|
versionCodes: []string{versionCodeTest.code},
|
|
|
|
},
|
|
|
|
expectedErr: domain.SliceElementValidationError{
|
|
|
|
Model: "ListServersParams",
|
|
|
|
Field: "versionCodes",
|
|
|
|
Index: 0,
|
|
|
|
Err: versionCodeTest.expectedErr,
|
|
|
|
},
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
params := domain.NewListServersParams()
|
|
|
|
|
|
|
|
require.ErrorIs(t, params.SetVersionCodes(tt.args.versionCodes), tt.expectedErr)
|
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
assert.Equal(t, tt.args.versionCodes, params.VersionCodes())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 07:17:47 +00:00
|
|
|
func TestListServersParams_SetLimit(t *testing.T) {
|
2023-12-24 10:44:20 +00:00
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
type args struct {
|
2024-02-07 07:17:47 +00:00
|
|
|
limit int
|
2023-12-24 10:44:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
args args
|
|
|
|
expectedErr error
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
|
|
|
args: args{
|
2024-02-07 07:17:47 +00:00
|
|
|
limit: domain.ServerListMaxLimit,
|
2023-12-24 10:44:20 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
2024-02-07 07:17:47 +00:00
|
|
|
name: "ERR: limit < 1",
|
2023-12-24 10:44:20 +00:00
|
|
|
args: args{
|
2024-02-07 07:17:47 +00:00
|
|
|
limit: 0,
|
2023-12-24 10:44:20 +00:00
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
2023-12-27 08:07:40 +00:00
|
|
|
Model: "ListServersParams",
|
2024-02-07 07:17:47 +00:00
|
|
|
Field: "limit",
|
2023-12-24 10:44:20 +00:00
|
|
|
Err: domain.MinGreaterEqualError{
|
2024-02-07 07:17:47 +00:00
|
|
|
Min: 1,
|
|
|
|
Current: 0,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: fmt.Sprintf("ERR: limit > %d", domain.ServerListMaxLimit),
|
|
|
|
args: args{
|
|
|
|
limit: domain.ServerListMaxLimit + 1,
|
|
|
|
},
|
|
|
|
expectedErr: domain.ValidationError{
|
|
|
|
Model: "ListServersParams",
|
|
|
|
Field: "limit",
|
|
|
|
Err: domain.MaxLessEqualError{
|
|
|
|
Max: domain.ServerListMaxLimit,
|
|
|
|
Current: domain.ServerListMaxLimit + 1,
|
2023-12-24 10:44:20 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
params := domain.NewListServersParams()
|
|
|
|
|
2024-02-07 07:17:47 +00:00
|
|
|
require.ErrorIs(t, params.SetLimit(tt.args.limit), tt.expectedErr)
|
2023-12-24 10:44:20 +00:00
|
|
|
if tt.expectedErr != nil {
|
|
|
|
return
|
|
|
|
}
|
2024-02-07 07:17:47 +00:00
|
|
|
assert.Equal(t, tt.args.limit, params.Limit())
|
2023-12-24 10:44:20 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-02-07 07:17:47 +00:00
|
|
|
func TestNewListServersResult(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
servers := domain.Servers{
|
|
|
|
domaintest.NewServer(t),
|
|
|
|
domaintest.NewServer(t),
|
|
|
|
domaintest.NewServer(t),
|
|
|
|
}
|
|
|
|
next := domaintest.NewServer(t)
|
|
|
|
|
|
|
|
t.Run("OK: with next", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
res, err := domain.NewListServersResult(servers, next)
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, servers, res.Servers())
|
|
|
|
assert.Equal(t, servers[0].Key(), res.Self().Key())
|
|
|
|
assert.Equal(t, servers[0].Open(), res.Self().Open())
|
|
|
|
assert.Equal(t, next.Key(), res.Next().Key())
|
|
|
|
assert.Equal(t, next.Open(), res.Next().Open())
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("OK: without next", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
res, err := domain.NewListServersResult(servers, domain.Server{})
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, servers, res.Servers())
|
|
|
|
assert.Equal(t, servers[0].Key(), res.Self().Key())
|
|
|
|
assert.Equal(t, servers[0].Open(), res.Self().Open())
|
|
|
|
assert.True(t, res.Next().IsZero())
|
|
|
|
})
|
|
|
|
|
2024-02-26 06:44:39 +00:00
|
|
|
t.Run("OK: 0 servers", func(t *testing.T) {
|
2024-02-07 07:17:47 +00:00
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
res, err := domain.NewListServersResult(nil, domain.Server{})
|
|
|
|
require.NoError(t, err)
|
|
|
|
assert.Zero(t, res.Servers())
|
|
|
|
assert.True(t, res.Self().IsZero())
|
|
|
|
assert.True(t, res.Next().IsZero())
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2023-12-23 09:54:47 +00:00
|
|
|
type serverKeyValidationTest struct {
|
|
|
|
name string
|
|
|
|
key string
|
|
|
|
expectedErr error
|
|
|
|
}
|
|
|
|
|
|
|
|
func newServerKeyValidationTests() []serverKeyValidationTest {
|
|
|
|
return []serverKeyValidationTest{
|
|
|
|
{
|
|
|
|
name: "ERR: server key length < 1",
|
2023-12-24 10:44:20 +00:00
|
|
|
expectedErr: domain.LenOutOfRangeError{
|
2023-12-23 09:54:47 +00:00
|
|
|
Min: 1,
|
|
|
|
Max: 10,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: server key length > 10",
|
|
|
|
key: "keykeykeyke",
|
2023-12-24 10:44:20 +00:00
|
|
|
expectedErr: domain.LenOutOfRangeError{
|
2023-12-23 09:54:47 +00:00
|
|
|
Min: 1,
|
|
|
|
Max: 10,
|
|
|
|
Current: len("keykeykeyke"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
}
|