355 lines
10 KiB
Go
355 lines
10 KiB
Go
package adapter_test
|
|
|
|
import (
|
|
"cmp"
|
|
"context"
|
|
"net/url"
|
|
"slices"
|
|
"testing"
|
|
|
|
"gitea.dwysokinski.me/twhelp/corev3/internal/domain"
|
|
"gitea.dwysokinski.me/twhelp/corev3/internal/domain/domaintest"
|
|
"github.com/brianvoe/gofakeit/v6"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func testServerRepository(t *testing.T, newRepos func(t *testing.T) repositories) {
|
|
t.Helper()
|
|
|
|
t.Run("CreateOrUpdate", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
t.Run("OK", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx := context.Background()
|
|
|
|
repos := newRepos(t)
|
|
|
|
versions, err := repos.version.List(ctx, domain.NewListVersionsParams())
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, versions)
|
|
version := versions[0]
|
|
|
|
serversToCreate := domain.BaseServers{
|
|
domaintest.NewBaseServer(t, domaintest.BaseServerConfig{Open: true}),
|
|
domaintest.NewBaseServer(t, domaintest.BaseServerConfig{Open: true}),
|
|
}
|
|
|
|
createParams, err := domain.NewCreateServerParams(serversToCreate, version.Code())
|
|
require.NoError(t, err)
|
|
|
|
require.NoError(t, repos.server.CreateOrUpdate(ctx, createParams...))
|
|
|
|
keys := make([]string, 0, len(serversToCreate))
|
|
for _, s := range serversToCreate {
|
|
keys = append(keys, s.Key())
|
|
}
|
|
|
|
listCreatedServersParams := domain.NewListServersParams()
|
|
require.NoError(t, listCreatedServersParams.SetKeys(keys))
|
|
|
|
createdServers, err := repos.server.List(ctx, listCreatedServersParams)
|
|
require.NoError(t, err)
|
|
require.Len(t, createdServers, len(serversToCreate))
|
|
for _, base := range serversToCreate {
|
|
assert.True(t, slices.ContainsFunc(createdServers, func(server domain.Server) bool {
|
|
return server.Key() == base.Key() &&
|
|
server.Open() == base.Open() &&
|
|
server.URL().String() == base.URL().String() &&
|
|
server.VersionCode() == version.Code()
|
|
}))
|
|
}
|
|
|
|
serversToUpdate := domain.BaseServers{
|
|
domaintest.NewBaseServer(t, domaintest.BaseServerConfig{
|
|
Key: serversToCreate[0].Key(),
|
|
URL: randURL(t),
|
|
Open: !serversToCreate[0].Open(),
|
|
}),
|
|
}
|
|
|
|
updateParams, err := domain.NewCreateServerParams(serversToUpdate, version.Code())
|
|
require.NoError(t, err)
|
|
|
|
require.NoError(t, repos.server.CreateOrUpdate(ctx, updateParams...))
|
|
|
|
keys = make([]string, 0, len(serversToUpdate))
|
|
for _, s := range serversToUpdate {
|
|
keys = append(keys, s.Key())
|
|
}
|
|
|
|
listUpdatedServersParams := domain.NewListServersParams()
|
|
require.NoError(t, listUpdatedServersParams.SetKeys(keys))
|
|
|
|
updatedServers, err := repos.server.List(ctx, listUpdatedServersParams)
|
|
require.NoError(t, err)
|
|
require.Len(t, updatedServers, len(serversToUpdate))
|
|
for _, base := range serversToUpdate {
|
|
assert.True(t, slices.ContainsFunc(updatedServers, func(server domain.Server) bool {
|
|
return server.Key() == base.Key() &&
|
|
server.Open() == base.Open() &&
|
|
server.URL().String() == base.URL().String() &&
|
|
server.VersionCode() == version.Code()
|
|
}))
|
|
}
|
|
})
|
|
})
|
|
|
|
t.Run("List & ListCount", func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
repos := newRepos(t)
|
|
|
|
tests := []struct {
|
|
name string
|
|
params func(t *testing.T) domain.ListServersParams
|
|
assertServers func(t *testing.T, params domain.ListServersParams, servers domain.Servers)
|
|
assertError func(t *testing.T, err error)
|
|
assertTotal func(t *testing.T, params domain.ListServersParams, total int)
|
|
}{
|
|
{
|
|
name: "OK: default params",
|
|
params: func(t *testing.T) domain.ListServersParams {
|
|
t.Helper()
|
|
return domain.NewListServersParams()
|
|
},
|
|
assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, len(servers))
|
|
assert.True(t, slices.IsSortedFunc(servers, func(a, b domain.Server) int {
|
|
return cmp.Compare(a.Key(), b.Key())
|
|
}))
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, total)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: sort=[open ASC, key ASC]",
|
|
params: func(t *testing.T) domain.ListServersParams {
|
|
t.Helper()
|
|
params := domain.NewListServersParams()
|
|
require.NoError(t, params.SetSort([]domain.ServerSort{domain.ServerSortOpenASC, domain.ServerSortKeyASC}))
|
|
return params
|
|
},
|
|
assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, len(servers))
|
|
assert.True(t, slices.IsSortedFunc(servers, func(a, b domain.Server) int {
|
|
if a.Open() && !b.Open() {
|
|
return 1
|
|
}
|
|
|
|
if !a.Open() && b.Open() {
|
|
return -1
|
|
}
|
|
|
|
return cmp.Compare(a.Key(), b.Key())
|
|
}))
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, total)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: sort=[open DESC, key DESC]",
|
|
params: func(t *testing.T) domain.ListServersParams {
|
|
t.Helper()
|
|
params := domain.NewListServersParams()
|
|
require.NoError(t, params.SetSort([]domain.ServerSort{domain.ServerSortOpenDESC, domain.ServerSortKeyDESC}))
|
|
return params
|
|
},
|
|
assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, len(servers))
|
|
assert.True(t, slices.IsSortedFunc(servers, func(a, b domain.Server) int {
|
|
if a.Open() && !b.Open() {
|
|
return -1
|
|
}
|
|
|
|
if !a.Open() && b.Open() {
|
|
return 1
|
|
}
|
|
|
|
return cmp.Compare(a.Key(), b.Key()) * -1
|
|
}))
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, total)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: keys=[de188, en113]",
|
|
params: func(t *testing.T) domain.ListServersParams {
|
|
t.Helper()
|
|
params := domain.NewListServersParams()
|
|
require.NoError(t, params.SetKeys([]string{"de188", "en113"}))
|
|
return params
|
|
},
|
|
assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
|
|
t.Helper()
|
|
|
|
keys := params.Keys()
|
|
|
|
assert.Len(t, servers, len(keys))
|
|
for _, k := range keys {
|
|
assert.True(t, slices.ContainsFunc(servers, func(server domain.Server) bool {
|
|
return server.Key() == k
|
|
}), k)
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
|
|
t.Helper()
|
|
assert.Equal(t, len(params.Keys()), total) //nolint:testifylint
|
|
},
|
|
},
|
|
{
|
|
name: "OK: keyGT=de188",
|
|
params: func(t *testing.T) domain.ListServersParams {
|
|
t.Helper()
|
|
params := domain.NewListServersParams()
|
|
require.NoError(t, params.SetKeyGT(domain.NullString{
|
|
Value: "de188",
|
|
Valid: true,
|
|
}))
|
|
return params
|
|
},
|
|
assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, len(servers))
|
|
for _, s := range servers {
|
|
assert.Greater(t, s.Key(), params.KeyGT().Value, s.Key())
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, total)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: special=true",
|
|
params: func(t *testing.T) domain.ListServersParams {
|
|
t.Helper()
|
|
params := domain.NewListServersParams()
|
|
require.NoError(t, params.SetSpecial(domain.NullBool{
|
|
Value: true,
|
|
Valid: true,
|
|
}))
|
|
return params
|
|
},
|
|
assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, len(servers))
|
|
for _, s := range servers {
|
|
assert.True(t, s.Special(), s.Key())
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, total)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: open=false",
|
|
params: func(t *testing.T) domain.ListServersParams {
|
|
t.Helper()
|
|
params := domain.NewListServersParams()
|
|
require.NoError(t, params.SetOpen(domain.NullBool{
|
|
Value: false,
|
|
Valid: true,
|
|
}))
|
|
return params
|
|
},
|
|
assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, len(servers))
|
|
for _, s := range servers {
|
|
assert.False(t, s.Open(), s.Key())
|
|
}
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, total)
|
|
},
|
|
},
|
|
{
|
|
name: "OK: offset=1 limit=2",
|
|
params: func(t *testing.T) domain.ListServersParams {
|
|
t.Helper()
|
|
params := domain.NewListServersParams()
|
|
require.NoError(t, params.SetOffset(1))
|
|
require.NoError(t, params.SetLimit(2))
|
|
return params
|
|
},
|
|
assertServers: func(t *testing.T, params domain.ListServersParams, servers domain.Servers) {
|
|
t.Helper()
|
|
assert.Len(t, servers, params.Limit())
|
|
},
|
|
assertError: func(t *testing.T, err error) {
|
|
t.Helper()
|
|
require.NoError(t, err)
|
|
},
|
|
assertTotal: func(t *testing.T, params domain.ListServersParams, total int) {
|
|
t.Helper()
|
|
assert.NotEmpty(t, total)
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
ctx := context.Background()
|
|
params := tt.params(t)
|
|
|
|
res, err := repos.server.List(ctx, params)
|
|
tt.assertError(t, err)
|
|
tt.assertServers(t, params, res)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
func randURL(tb testing.TB) *url.URL {
|
|
tb.Helper()
|
|
u, err := url.Parse("https://" + gofakeit.DomainName())
|
|
require.NoError(tb, err)
|
|
return u
|
|
}
|