2022-09-02 05:25:57 +00:00
|
|
|
package rest_test
|
|
|
|
|
|
|
|
import (
|
2022-09-03 05:25:16 +00:00
|
|
|
"context"
|
2022-09-02 05:25:57 +00:00
|
|
|
"fmt"
|
|
|
|
"net/http"
|
2022-09-03 05:25:16 +00:00
|
|
|
"net/url"
|
2023-01-31 05:17:07 +00:00
|
|
|
"strconv"
|
2022-09-02 05:25:57 +00:00
|
|
|
"testing"
|
|
|
|
"time"
|
|
|
|
|
2022-10-17 04:45:53 +00:00
|
|
|
"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/mock"
|
|
|
|
"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
|
2022-09-03 05:25:16 +00:00
|
|
|
"github.com/google/go-cmp/cmp"
|
|
|
|
|
2022-09-02 05:25:57 +00:00
|
|
|
"gitea.dwysokinski.me/twhelp/core/internal/domain"
|
|
|
|
)
|
|
|
|
|
2022-09-03 05:25:16 +00:00
|
|
|
func TestPlayer_list(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
now := time.Now()
|
|
|
|
version := domain.Version{
|
|
|
|
Code: "pl",
|
|
|
|
Name: "Poland",
|
|
|
|
Host: "plemiona.pl",
|
|
|
|
Timezone: "Europe/Warsaw",
|
|
|
|
}
|
|
|
|
server := domain.Server{
|
|
|
|
Key: "pl151",
|
|
|
|
URL: "https://pl151.plemiona.pl",
|
|
|
|
Open: true,
|
|
|
|
Special: false,
|
|
|
|
VersionCode: "pl",
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
2022-10-17 04:45:53 +00:00
|
|
|
setup func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService)
|
2022-09-03 05:25:16 +00:00
|
|
|
versionCode string
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey string
|
2022-09-03 05:25:16 +00:00
|
|
|
queryParams url.Values
|
|
|
|
expectedStatus int
|
|
|
|
target any
|
|
|
|
expectedResponse any
|
|
|
|
expectedTotalCount string
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK: without params",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
2022-12-23 07:56:31 +00:00
|
|
|
playerSvc.ListCountWithRelationsCalls(func(
|
2022-10-21 05:19:04 +00:00
|
|
|
_ context.Context,
|
|
|
|
params domain.ListPlayersParams,
|
|
|
|
) ([]domain.PlayerWithRelations, int64, error) {
|
2022-09-03 05:25:16 +00:00
|
|
|
expectedParams := domain.ListPlayersParams{
|
2022-12-23 07:56:31 +00:00
|
|
|
ServerKeys: []string{server.Key},
|
2022-09-03 05:25:16 +00:00
|
|
|
}
|
|
|
|
|
2022-09-06 07:50:00 +00:00
|
|
|
if diff := cmp.Diff(params, expectedParams); diff != "" {
|
|
|
|
return nil, 0, fmt.Errorf("validation failed: %s", diff)
|
2022-09-03 05:25:16 +00:00
|
|
|
}
|
|
|
|
|
2022-10-21 05:19:04 +00:00
|
|
|
players := []domain.PlayerWithRelations{
|
2022-09-03 05:25:16 +00:00
|
|
|
{
|
2022-10-21 05:19:04 +00:00
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 8,
|
|
|
|
ScoreAtt: 7,
|
|
|
|
RankDef: 6,
|
|
|
|
ScoreDef: 5,
|
|
|
|
RankSup: 4,
|
|
|
|
ScoreSup: 3,
|
|
|
|
RankTotal: 2,
|
|
|
|
ScoreTotal: 1,
|
|
|
|
},
|
2023-01-01 08:35:17 +00:00
|
|
|
ID: 997,
|
|
|
|
Name: "name 997",
|
|
|
|
NumVillages: 5,
|
|
|
|
Points: 4,
|
|
|
|
Rank: 2,
|
|
|
|
TribeID: 1234,
|
|
|
|
ProfileURL: "profile-997",
|
|
|
|
BestRank: 111,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1112,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Minute),
|
|
|
|
MostVillages: 1113,
|
|
|
|
MostVillagesAt: now.Add(time.Minute),
|
|
|
|
LastActivityAt: now.Add(time.Second),
|
|
|
|
ServerKey: server.Key,
|
|
|
|
CreatedAt: now,
|
2022-09-03 05:25:16 +00:00
|
|
|
},
|
2022-10-21 05:19:04 +00:00
|
|
|
Tribe: domain.NullTribeMeta{
|
2022-09-03 05:25:16 +00:00
|
|
|
Valid: true,
|
2022-10-21 05:19:04 +00:00
|
|
|
Tribe: domain.TribeMeta{
|
|
|
|
ID: 1234,
|
|
|
|
Name: "name 997",
|
|
|
|
Tag: "tag 997",
|
|
|
|
ProfileURL: "profile-1234",
|
2022-09-03 05:25:16 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
2022-10-21 05:19:04 +00:00
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
},
|
2023-01-01 08:35:17 +00:00
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
TribeID: 0,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
ServerKey: server.Key,
|
|
|
|
CreatedAt: now,
|
2022-09-03 05:25:16 +00:00
|
|
|
},
|
2022-10-21 05:19:04 +00:00
|
|
|
Tribe: domain.NullTribeMeta{
|
2022-09-03 05:25:16 +00:00
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
return players, int64(len(players)), nil
|
|
|
|
})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusOK,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ListPlayersResp{},
|
|
|
|
expectedResponse: &model.ListPlayersResp{
|
|
|
|
Data: []model.Player{
|
2022-09-03 05:25:16 +00:00
|
|
|
{
|
2023-01-01 08:35:17 +00:00
|
|
|
RankAtt: 8,
|
|
|
|
ScoreAtt: 7,
|
|
|
|
RankDef: 6,
|
|
|
|
ScoreDef: 5,
|
|
|
|
RankSup: 4,
|
|
|
|
ScoreSup: 3,
|
|
|
|
RankTotal: 2,
|
|
|
|
ScoreTotal: 1,
|
|
|
|
ID: 997,
|
|
|
|
Name: "name 997",
|
|
|
|
NumVillages: 5,
|
|
|
|
Points: 4,
|
|
|
|
Rank: 2,
|
|
|
|
ProfileURL: "profile-997",
|
|
|
|
BestRank: 111,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1112,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Minute),
|
|
|
|
MostVillages: 1113,
|
|
|
|
MostVillagesAt: now.Add(time.Minute),
|
|
|
|
LastActivityAt: now.Add(time.Second),
|
2022-10-17 04:45:53 +00:00
|
|
|
Tribe: model.NullTribeMeta{
|
2022-09-03 05:25:16 +00:00
|
|
|
Valid: true,
|
2022-10-17 04:45:53 +00:00
|
|
|
Tribe: model.TribeMeta{
|
|
|
|
ID: 1234,
|
|
|
|
Name: "name 997",
|
|
|
|
Tag: "tag 997",
|
|
|
|
ProfileURL: "profile-1234",
|
2022-09-03 05:25:16 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
{
|
2023-01-01 08:35:17 +00:00
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
2022-10-17 04:45:53 +00:00
|
|
|
Tribe: model.NullTribeMeta{
|
2022-09-03 05:25:16 +00:00
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "2",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: deleted=true,limit=1,offset=1,sort=[deletedAt:desc]",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
2022-12-23 07:56:31 +00:00
|
|
|
playerSvc.ListCountWithRelationsCalls(func(_ context.Context, params domain.ListPlayersParams) ([]domain.PlayerWithRelations, int64, error) {
|
2022-09-03 05:25:16 +00:00
|
|
|
expectedParams := domain.ListPlayersParams{
|
|
|
|
Deleted: domain.NullBool{
|
|
|
|
Valid: true,
|
|
|
|
Bool: true,
|
|
|
|
},
|
2022-12-23 07:56:31 +00:00
|
|
|
ServerKeys: []string{server.Key},
|
2022-09-03 05:25:16 +00:00
|
|
|
Pagination: domain.Pagination{
|
|
|
|
Limit: 1,
|
|
|
|
Offset: 1,
|
|
|
|
},
|
|
|
|
Sort: []domain.PlayerSort{
|
|
|
|
{By: domain.PlayerSortByDeletedAt, Direction: domain.SortDirectionDESC},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2022-09-06 07:50:00 +00:00
|
|
|
if diff := cmp.Diff(params, expectedParams); diff != "" {
|
|
|
|
return nil, 0, fmt.Errorf("validation failed: %s", diff)
|
2022-09-03 05:25:16 +00:00
|
|
|
}
|
|
|
|
|
2022-10-21 05:19:04 +00:00
|
|
|
players := []domain.PlayerWithRelations{
|
2022-09-03 05:25:16 +00:00
|
|
|
{
|
2022-10-21 05:19:04 +00:00
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
},
|
2023-01-01 08:35:17 +00:00
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
TribeID: 0,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
ServerKey: server.Key,
|
|
|
|
CreatedAt: now,
|
|
|
|
DeletedAt: now,
|
2022-09-03 05:25:16 +00:00
|
|
|
},
|
2022-10-21 05:19:04 +00:00
|
|
|
Tribe: domain.NullTribeMeta{},
|
2022-09-03 05:25:16 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
return players, int64(len(players)), nil
|
|
|
|
})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-03 05:25:16 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"deleted": []string{"true"},
|
|
|
|
"limit": []string{"1"},
|
|
|
|
"offset": []string{"1"},
|
|
|
|
"sort": []string{"deletedAt:desc"},
|
|
|
|
},
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusOK,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ListPlayersResp{},
|
|
|
|
expectedResponse: &model.ListPlayersResp{
|
|
|
|
Data: []model.Player{
|
2022-09-03 05:25:16 +00:00
|
|
|
{
|
2023-01-01 08:35:17 +00:00
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
2022-10-17 04:45:53 +00:00
|
|
|
Tribe: model.NullTribeMeta{
|
2022-09-03 05:25:16 +00:00
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
2022-10-17 04:45:53 +00:00
|
|
|
DeletedAt: model.NullTime{
|
2022-09-03 05:25:16 +00:00
|
|
|
Valid: true,
|
|
|
|
Time: now,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "1",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: limit=1,sort=[id:asc,points:desc,scoreTotal:asc]",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
2022-12-23 07:56:31 +00:00
|
|
|
playerSvc.ListCountWithRelationsCalls(func(
|
2022-10-21 05:19:04 +00:00
|
|
|
_ context.Context,
|
|
|
|
params domain.ListPlayersParams,
|
|
|
|
) ([]domain.PlayerWithRelations, int64, error) {
|
2022-09-03 05:25:16 +00:00
|
|
|
expectedParams := domain.ListPlayersParams{
|
|
|
|
Deleted: domain.NullBool{
|
|
|
|
Valid: false,
|
|
|
|
Bool: false,
|
|
|
|
},
|
2022-12-23 07:56:31 +00:00
|
|
|
ServerKeys: []string{server.Key},
|
2022-09-03 05:25:16 +00:00
|
|
|
Pagination: domain.Pagination{
|
|
|
|
Limit: 1,
|
|
|
|
Offset: 0,
|
|
|
|
},
|
|
|
|
Sort: []domain.PlayerSort{
|
|
|
|
{By: domain.PlayerSortByID, Direction: domain.SortDirectionASC},
|
|
|
|
{By: domain.PlayerSortByPoints, Direction: domain.SortDirectionDESC},
|
|
|
|
{By: domain.PlayerSortByScoreTotal, Direction: domain.SortDirectionASC},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2022-09-06 07:50:00 +00:00
|
|
|
if diff := cmp.Diff(params, expectedParams); diff != "" {
|
|
|
|
return nil, 0, fmt.Errorf("validation failed: %s", diff)
|
2022-09-03 05:25:16 +00:00
|
|
|
}
|
|
|
|
|
2022-10-21 05:19:04 +00:00
|
|
|
players := []domain.PlayerWithRelations{
|
2022-09-03 05:25:16 +00:00
|
|
|
{
|
2022-10-21 05:19:04 +00:00
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
},
|
2023-01-01 08:35:17 +00:00
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
TribeID: 0,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
ServerKey: server.Key,
|
|
|
|
CreatedAt: now,
|
|
|
|
DeletedAt: now,
|
2022-09-03 05:25:16 +00:00
|
|
|
},
|
2022-10-21 05:19:04 +00:00
|
|
|
Tribe: domain.NullTribeMeta{},
|
2022-09-03 05:25:16 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
return players, int64(len(players)) + 1522, nil
|
|
|
|
})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-03 05:25:16 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"limit": []string{"1"},
|
|
|
|
"sort": []string{"id:asc", "points:desc", "scoreTotal:asc"},
|
|
|
|
},
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusOK,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ListPlayersResp{},
|
|
|
|
expectedResponse: &model.ListPlayersResp{
|
|
|
|
Data: []model.Player{
|
2022-09-03 05:25:16 +00:00
|
|
|
{
|
2023-01-01 08:35:17 +00:00
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
2022-10-17 04:45:53 +00:00
|
|
|
Tribe: model.NullTribeMeta{
|
2022-09-03 05:25:16 +00:00
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
2022-10-17 04:45:53 +00:00
|
|
|
DeletedAt: model.NullTime{
|
2022-09-03 05:25:16 +00:00
|
|
|
Valid: true,
|
|
|
|
Time: now,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "1523",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: limit is not a valid int32",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-03 05:25:16 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"limit": []string{"asd"},
|
|
|
|
},
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusBadRequest,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-03 05:25:16 +00:00
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "limit: strconv.ParseInt: parsing \"asd\": invalid syntax",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: offset is not a valid int32",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-03 05:25:16 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"offset": []string{"asd"},
|
|
|
|
},
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusBadRequest,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-03 05:25:16 +00:00
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "offset: strconv.ParseInt: parsing \"asd\": invalid syntax",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: deleted is not a valid boolean",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-03 05:25:16 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"deleted": []string{"asd"},
|
|
|
|
},
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusBadRequest,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-03 05:25:16 +00:00
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "deleted: strconv.ParseBool: parsing \"asd\": invalid syntax",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: sort - invalid format",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-03 05:25:16 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"sort": []string{"id:asc", "test"},
|
|
|
|
},
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusBadRequest,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-03 05:25:16 +00:00
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "sort[1]: parsing \"test\": invalid syntax, expected field:direction",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: sort - unsupported field",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-03 05:25:16 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"sort": []string{"id:asc", "test:asc"},
|
|
|
|
},
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusBadRequest,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-03 05:25:16 +00:00
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "sort[1]: unsupported sort by: \"test\"",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: sort - unsupported direction",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-03 05:25:16 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"sort": []string{"id:asc2"},
|
|
|
|
},
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusBadRequest,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-03 05:25:16 +00:00
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "sort[0]: unsupported sort direction: \"asc2\"",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: version not found",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
|
|
|
|
},
|
|
|
|
versionCode: version.Code + "2",
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key,
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusNotFound,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-03 05:25:16 +00:00
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: server not found",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-03 05:25:16 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2023-01-31 05:17:07 +00:00
|
|
|
serverKey: server.Key + "2",
|
2023-01-04 05:21:02 +00:00
|
|
|
expectedStatus: http.StatusNotFound,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-03 05:25:16 +00:00
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
tt := tt
|
|
|
|
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
2022-10-17 04:45:53 +00:00
|
|
|
versionSvc := &mock.FakeVersionService{}
|
|
|
|
serverSvc := &mock.FakeServerService{}
|
|
|
|
playerSvc := &mock.FakePlayerService{}
|
2022-09-03 05:25:16 +00:00
|
|
|
tt.setup(versionSvc, serverSvc, playerSvc)
|
|
|
|
|
2023-01-27 06:03:20 +00:00
|
|
|
router := newRouter(
|
|
|
|
withVersionService(versionSvc),
|
|
|
|
withPlayerService(playerSvc),
|
|
|
|
withServerService(serverSvc),
|
|
|
|
)
|
2022-09-03 05:25:16 +00:00
|
|
|
|
|
|
|
target := fmt.Sprintf(
|
|
|
|
"/v1/versions/%s/servers/%s/players?%s",
|
|
|
|
tt.versionCode,
|
2023-01-31 05:17:07 +00:00
|
|
|
tt.serverKey,
|
2022-09-03 05:25:16 +00:00
|
|
|
tt.queryParams.Encode(),
|
|
|
|
)
|
|
|
|
resp := doRequest(router, http.MethodGet, target, nil)
|
|
|
|
defer resp.Body.Close()
|
|
|
|
assertTotalCount(t, resp.Header, tt.expectedTotalCount)
|
|
|
|
assertJSONResponse(t, resp, tt.expectedStatus, tt.expectedResponse, tt.target)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-02 05:25:57 +00:00
|
|
|
func TestPlayer_getByID(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
now := time.Now()
|
|
|
|
version := domain.Version{
|
|
|
|
Code: "pl",
|
|
|
|
Name: "Poland",
|
|
|
|
Host: "plemiona.pl",
|
|
|
|
Timezone: "Europe/Warsaw",
|
|
|
|
}
|
|
|
|
server := domain.Server{
|
|
|
|
Key: "pl151",
|
|
|
|
URL: "https://pl151.plemiona.pl",
|
|
|
|
Open: true,
|
|
|
|
Special: false,
|
|
|
|
VersionCode: "pl",
|
|
|
|
}
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
2022-10-17 04:45:53 +00:00
|
|
|
setup func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService)
|
2022-09-02 05:25:57 +00:00
|
|
|
versionCode string
|
|
|
|
serverKey string
|
|
|
|
id string
|
|
|
|
expectedStatus int
|
|
|
|
target any
|
|
|
|
expectedResponse any
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-02 05:25:57 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
2022-12-23 07:56:31 +00:00
|
|
|
playerSvc.GetByServerKeyAndIDWithRelationsReturns(domain.PlayerWithRelations{
|
2022-10-21 05:19:04 +00:00
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 8,
|
|
|
|
ScoreAtt: 7,
|
|
|
|
RankDef: 6,
|
|
|
|
ScoreDef: 5,
|
|
|
|
RankSup: 4,
|
|
|
|
ScoreSup: 3,
|
|
|
|
RankTotal: 2,
|
|
|
|
ScoreTotal: 1,
|
|
|
|
},
|
2023-01-01 08:35:17 +00:00
|
|
|
ID: 997,
|
|
|
|
Name: "name 997",
|
|
|
|
NumVillages: 5,
|
|
|
|
Points: 4,
|
|
|
|
Rank: 2,
|
|
|
|
TribeID: 1234,
|
|
|
|
ProfileURL: "profile-997",
|
|
|
|
BestRank: 111,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1112,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Minute),
|
|
|
|
MostVillages: 1113,
|
|
|
|
MostVillagesAt: now.Add(time.Minute),
|
|
|
|
LastActivityAt: now.Add(time.Second),
|
|
|
|
ServerKey: server.Key,
|
|
|
|
CreatedAt: now,
|
2022-09-02 05:25:57 +00:00
|
|
|
},
|
2022-10-21 05:19:04 +00:00
|
|
|
Tribe: domain.NullTribeMeta{
|
2022-09-02 05:25:57 +00:00
|
|
|
Valid: true,
|
2022-10-21 05:19:04 +00:00
|
|
|
Tribe: domain.TribeMeta{
|
|
|
|
ID: 1234,
|
|
|
|
Name: "name 997",
|
|
|
|
Tag: "tag 997",
|
|
|
|
ProfileURL: "profile-1234",
|
2022-09-02 05:25:57 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
}, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2022-09-04 07:07:32 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-02 05:25:57 +00:00
|
|
|
id: "997",
|
|
|
|
expectedStatus: http.StatusOK,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.GetPlayerResp{},
|
|
|
|
expectedResponse: &model.GetPlayerResp{
|
|
|
|
Data: model.Player{
|
2023-01-01 08:35:17 +00:00
|
|
|
ID: 997,
|
|
|
|
Name: "name 997",
|
|
|
|
NumVillages: 5,
|
|
|
|
Points: 4,
|
|
|
|
Rank: 2,
|
|
|
|
RankAtt: 8,
|
|
|
|
ScoreAtt: 7,
|
|
|
|
RankDef: 6,
|
|
|
|
ScoreDef: 5,
|
|
|
|
RankSup: 4,
|
|
|
|
ScoreSup: 3,
|
|
|
|
RankTotal: 2,
|
|
|
|
ScoreTotal: 1,
|
|
|
|
ProfileURL: "profile-997",
|
|
|
|
BestRank: 111,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1112,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Minute),
|
|
|
|
MostVillages: 1113,
|
|
|
|
MostVillagesAt: now.Add(time.Minute),
|
|
|
|
LastActivityAt: now.Add(time.Second),
|
|
|
|
CreatedAt: now,
|
2022-10-17 04:45:53 +00:00
|
|
|
Tribe: model.NullTribeMeta{
|
|
|
|
Tribe: model.TribeMeta{
|
|
|
|
ID: 1234,
|
|
|
|
Name: "name 997",
|
|
|
|
Tag: "tag 997",
|
|
|
|
ProfileURL: "profile-1234",
|
2022-09-02 05:25:57 +00:00
|
|
|
},
|
|
|
|
Valid: true,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: player id is not a valid int64",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-02 05:25:57 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2022-09-04 07:07:32 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-02 05:25:57 +00:00
|
|
|
id: "true",
|
|
|
|
expectedStatus: http.StatusBadRequest,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-02 05:25:57 +00:00
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "playerId: strconv.ParseInt: parsing \"true\": invalid syntax",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: version not found",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-02 05:25:57 +00:00
|
|
|
versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
|
|
|
|
},
|
|
|
|
versionCode: version.Code + "2",
|
2022-09-04 07:07:32 +00:00
|
|
|
serverKey: server.Key,
|
2022-09-02 05:25:57 +00:00
|
|
|
id: "1234",
|
|
|
|
expectedStatus: http.StatusNotFound,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-02 05:25:57 +00:00
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: server not found",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-02 05:25:57 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
2022-09-04 07:07:32 +00:00
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
|
2022-09-02 05:25:57 +00:00
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
2022-09-04 07:07:32 +00:00
|
|
|
serverKey: server.Key + "2",
|
2022-09-02 05:25:57 +00:00
|
|
|
id: "1234",
|
|
|
|
expectedStatus: http.StatusNotFound,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-02 05:25:57 +00:00
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
2022-09-04 07:07:32 +00:00
|
|
|
Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
|
2022-09-02 05:25:57 +00:00
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: player not found",
|
2022-10-17 04:45:53 +00:00
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
2022-09-02 05:25:57 +00:00
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
2022-12-23 07:56:31 +00:00
|
|
|
playerSvc.GetByServerKeyAndIDWithRelationsReturns(domain.PlayerWithRelations{}, domain.PlayerNotFoundError{ID: 12345551})
|
2022-09-02 05:25:57 +00:00
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
id: "12345551",
|
|
|
|
expectedStatus: http.StatusNotFound,
|
2022-10-17 04:45:53 +00:00
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
2022-09-02 05:25:57 +00:00
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: "player (id=12345551) not found",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
tt := tt
|
|
|
|
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
2022-10-17 04:45:53 +00:00
|
|
|
versionSvc := &mock.FakeVersionService{}
|
|
|
|
serverSvc := &mock.FakeServerService{}
|
|
|
|
playerSvc := &mock.FakePlayerService{}
|
2022-09-02 05:25:57 +00:00
|
|
|
tt.setup(versionSvc, serverSvc, playerSvc)
|
|
|
|
|
2023-01-27 06:03:20 +00:00
|
|
|
router := newRouter(
|
|
|
|
withVersionService(versionSvc),
|
|
|
|
withPlayerService(playerSvc),
|
|
|
|
withServerService(serverSvc),
|
|
|
|
)
|
2022-09-02 05:25:57 +00:00
|
|
|
|
|
|
|
target := fmt.Sprintf(
|
|
|
|
"/v1/versions/%s/servers/%s/players/%s",
|
|
|
|
tt.versionCode,
|
|
|
|
tt.serverKey,
|
|
|
|
tt.id,
|
|
|
|
)
|
|
|
|
resp := doRequest(router, http.MethodGet, target, nil)
|
|
|
|
defer resp.Body.Close()
|
|
|
|
assertJSONResponse(t, resp, tt.expectedStatus, tt.expectedResponse, tt.target)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
2023-01-31 05:17:07 +00:00
|
|
|
|
|
|
|
func TestPlayer_listOtherServers(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
now := time.Now()
|
|
|
|
version := domain.Version{
|
|
|
|
Code: "pl",
|
|
|
|
Name: "Poland",
|
|
|
|
Host: "plemiona.pl",
|
|
|
|
Timezone: "Europe/Warsaw",
|
|
|
|
}
|
|
|
|
serverPL151 := domain.Server{
|
|
|
|
Key: "pl151",
|
|
|
|
URL: "https://pl151.plemiona.pl",
|
|
|
|
Open: true,
|
|
|
|
Special: false,
|
|
|
|
VersionCode: "pl",
|
|
|
|
}
|
|
|
|
serverPL153 := domain.ServerMeta{
|
|
|
|
Key: "pl153",
|
|
|
|
URL: "https://pl153.plemiona.pl",
|
|
|
|
Open: true,
|
|
|
|
}
|
|
|
|
serverPL155 := domain.ServerMeta{
|
|
|
|
Key: "pl155",
|
|
|
|
URL: "https://pl155.plemiona.pl",
|
|
|
|
Open: true,
|
|
|
|
}
|
|
|
|
var playerID int64 = 998
|
|
|
|
playerIdStr := strconv.FormatInt(playerID, 10)
|
|
|
|
player := domain.PlayerWithRelations{
|
|
|
|
Player: domain.Player{
|
|
|
|
ID: playerID,
|
|
|
|
Name: "name " + playerIdStr,
|
|
|
|
NumVillages: 1,
|
|
|
|
Points: 2,
|
|
|
|
Rank: 3,
|
|
|
|
TribeID: 4,
|
|
|
|
ProfileURL: "profile-" + playerIdStr,
|
|
|
|
BestRank: 1234,
|
|
|
|
BestRankAt: time.Now(),
|
|
|
|
MostPoints: 1235,
|
|
|
|
MostPointsAt: time.Now(),
|
|
|
|
MostVillages: 1236,
|
|
|
|
MostVillagesAt: time.Now(),
|
|
|
|
LastActivityAt: time.Now(),
|
|
|
|
ServerKey: serverPL151.Key,
|
|
|
|
CreatedAt: time.Now(),
|
|
|
|
},
|
|
|
|
Server: domain.ServerMeta{
|
|
|
|
Key: serverPL151.Key,
|
|
|
|
URL: serverPL151.URL,
|
|
|
|
Open: serverPL151.Open,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
setup func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService)
|
|
|
|
versionCode string
|
|
|
|
serverKey string
|
2023-02-06 07:18:32 +00:00
|
|
|
playerID string
|
2023-01-31 05:17:07 +00:00
|
|
|
queryParams url.Values
|
|
|
|
expectedStatus int
|
|
|
|
target any
|
|
|
|
expectedResponse any
|
|
|
|
expectedTotalCount string
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK: without params",
|
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(serverPL151, nil)
|
|
|
|
playerSvc.GetByServerKeyAndIDWithRelationsReturns(player, nil)
|
|
|
|
playerSvc.ListCountWithRelationsCalls(func(
|
|
|
|
_ context.Context,
|
|
|
|
params domain.ListPlayersParams,
|
|
|
|
) ([]domain.PlayerWithRelations, int64, error) {
|
|
|
|
expectedParams := domain.ListPlayersParams{
|
|
|
|
VersionCodes: []string{version.Code},
|
|
|
|
IDs: []int64{playerID},
|
|
|
|
ServerKeysNIN: []string{serverPL151.Key},
|
|
|
|
}
|
|
|
|
|
|
|
|
if diff := cmp.Diff(params, expectedParams); diff != "" {
|
|
|
|
return nil, 0, fmt.Errorf("validation failed: %s", diff)
|
|
|
|
}
|
|
|
|
|
|
|
|
players := []domain.PlayerWithRelations{
|
|
|
|
{
|
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 8,
|
|
|
|
ScoreAtt: 7,
|
|
|
|
RankDef: 6,
|
|
|
|
ScoreDef: 5,
|
|
|
|
RankSup: 4,
|
|
|
|
ScoreSup: 3,
|
|
|
|
RankTotal: 2,
|
|
|
|
ScoreTotal: 1,
|
|
|
|
},
|
|
|
|
ID: playerID,
|
|
|
|
Name: "name " + playerIdStr,
|
|
|
|
NumVillages: 5,
|
|
|
|
Points: 4,
|
|
|
|
Rank: 2,
|
|
|
|
TribeID: 1234,
|
|
|
|
ProfileURL: "profile-" + playerIdStr,
|
|
|
|
BestRank: 111,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1112,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Minute),
|
|
|
|
MostVillages: 1113,
|
|
|
|
MostVillagesAt: now.Add(time.Minute),
|
|
|
|
LastActivityAt: now.Add(time.Second),
|
|
|
|
ServerKey: serverPL153.Key,
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
Tribe: domain.NullTribeMeta{
|
|
|
|
Valid: true,
|
|
|
|
Tribe: domain.TribeMeta{
|
|
|
|
ID: 1234,
|
|
|
|
Name: "name 1234",
|
|
|
|
Tag: "tag 1234",
|
|
|
|
ProfileURL: "profile-1234",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
Server: serverPL153,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
},
|
|
|
|
ID: playerID,
|
|
|
|
Name: "name " + playerIdStr,
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
TribeID: 0,
|
|
|
|
ProfileURL: "profile-" + playerIdStr,
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
ServerKey: serverPL155.Key,
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
Tribe: domain.NullTribeMeta{
|
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
Server: serverPL155,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
return players, int64(len(players)), nil
|
|
|
|
})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: serverPL151.Key,
|
2023-02-06 07:18:32 +00:00
|
|
|
playerID: playerIdStr,
|
2023-01-31 05:17:07 +00:00
|
|
|
expectedStatus: http.StatusOK,
|
|
|
|
target: &model.ListPlayerOtherServersResp{},
|
|
|
|
expectedResponse: &model.ListPlayerOtherServersResp{
|
|
|
|
Data: []model.PlayerWithServer{
|
|
|
|
{
|
|
|
|
Player: model.Player{
|
|
|
|
RankAtt: 8,
|
|
|
|
ScoreAtt: 7,
|
|
|
|
RankDef: 6,
|
|
|
|
ScoreDef: 5,
|
|
|
|
RankSup: 4,
|
|
|
|
ScoreSup: 3,
|
|
|
|
RankTotal: 2,
|
|
|
|
ScoreTotal: 1,
|
|
|
|
ID: playerID,
|
|
|
|
Name: "name " + playerIdStr,
|
|
|
|
NumVillages: 5,
|
|
|
|
Points: 4,
|
|
|
|
Rank: 2,
|
|
|
|
ProfileURL: "profile-" + playerIdStr,
|
|
|
|
BestRank: 111,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1112,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Minute),
|
|
|
|
MostVillages: 1113,
|
|
|
|
MostVillagesAt: now.Add(time.Minute),
|
|
|
|
LastActivityAt: now.Add(time.Second),
|
|
|
|
Tribe: model.NullTribeMeta{
|
|
|
|
Valid: true,
|
|
|
|
Tribe: model.TribeMeta{
|
|
|
|
ID: 1234,
|
|
|
|
Name: "name 1234",
|
|
|
|
Tag: "tag 1234",
|
|
|
|
ProfileURL: "profile-1234",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
Server: model.ServerMeta{
|
|
|
|
Key: serverPL153.Key,
|
|
|
|
URL: serverPL153.URL,
|
|
|
|
Open: serverPL153.Open,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Player: model.Player{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
ID: playerID,
|
|
|
|
Name: "name " + playerIdStr,
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
ProfileURL: "profile-" + playerIdStr,
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
Tribe: model.NullTribeMeta{
|
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
Server: model.ServerMeta{
|
|
|
|
Key: serverPL155.Key,
|
|
|
|
URL: serverPL155.URL,
|
|
|
|
Open: serverPL155.Open,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "2",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: limit=1,offset=1",
|
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(serverPL151, nil)
|
|
|
|
playerSvc.GetByServerKeyAndIDWithRelationsReturns(player, nil)
|
|
|
|
playerSvc.ListCountWithRelationsCalls(func(_ context.Context, params domain.ListPlayersParams) ([]domain.PlayerWithRelations, int64, error) {
|
|
|
|
expectedParams := domain.ListPlayersParams{
|
|
|
|
VersionCodes: []string{version.Code},
|
|
|
|
IDs: []int64{playerID},
|
|
|
|
ServerKeysNIN: []string{serverPL151.Key},
|
|
|
|
Pagination: domain.Pagination{
|
|
|
|
Limit: 1,
|
|
|
|
Offset: 1,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
if diff := cmp.Diff(params, expectedParams); diff != "" {
|
|
|
|
return nil, 0, fmt.Errorf("validation failed: %s", diff)
|
|
|
|
}
|
|
|
|
|
|
|
|
players := []domain.PlayerWithRelations{
|
|
|
|
{
|
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
},
|
|
|
|
ID: playerID,
|
|
|
|
Name: "name " + playerIdStr,
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
TribeID: 0,
|
|
|
|
ProfileURL: "profile-" + playerIdStr,
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
ServerKey: serverPL153.Key,
|
|
|
|
CreatedAt: now,
|
|
|
|
DeletedAt: now,
|
|
|
|
},
|
|
|
|
Tribe: domain.NullTribeMeta{},
|
|
|
|
Server: serverPL153,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
return players, int64(len(players)), nil
|
|
|
|
})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: serverPL151.Key,
|
2023-02-06 07:18:32 +00:00
|
|
|
playerID: playerIdStr,
|
2023-01-31 05:17:07 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"limit": []string{"1"},
|
|
|
|
"offset": []string{"1"},
|
|
|
|
},
|
|
|
|
expectedStatus: http.StatusOK,
|
|
|
|
target: &model.ListPlayerOtherServersResp{},
|
|
|
|
expectedResponse: &model.ListPlayerOtherServersResp{
|
|
|
|
Data: []model.PlayerWithServer{
|
|
|
|
{
|
|
|
|
Player: model.Player{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
Tribe: model.NullTribeMeta{
|
|
|
|
Valid: false,
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
|
|
|
DeletedAt: model.NullTime{
|
|
|
|
Valid: true,
|
|
|
|
Time: now,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
Server: model.ServerMeta{
|
|
|
|
Key: serverPL153.Key,
|
|
|
|
URL: serverPL153.URL,
|
|
|
|
Open: serverPL153.Open,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "1",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: limit is not a valid int32",
|
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(serverPL151, nil)
|
|
|
|
playerSvc.GetByServerKeyAndIDWithRelationsReturns(player, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: serverPL151.Key,
|
2023-02-06 07:18:32 +00:00
|
|
|
playerID: playerIdStr,
|
2023-01-31 05:17:07 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"limit": []string{"asd"},
|
|
|
|
},
|
|
|
|
expectedStatus: http.StatusBadRequest,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "limit: strconv.ParseInt: parsing \"asd\": invalid syntax",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: offset is not a valid int32",
|
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(serverPL151, nil)
|
|
|
|
playerSvc.GetByServerKeyAndIDWithRelationsReturns(player, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: serverPL151.Key,
|
2023-02-06 07:18:32 +00:00
|
|
|
playerID: playerIdStr,
|
2023-01-31 05:17:07 +00:00
|
|
|
queryParams: url.Values{
|
|
|
|
"offset": []string{"asd"},
|
|
|
|
},
|
|
|
|
expectedStatus: http.StatusBadRequest,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "offset: strconv.ParseInt: parsing \"asd\": invalid syntax",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: version not found",
|
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
|
|
|
versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
|
|
|
|
},
|
|
|
|
versionCode: version.Code + "2",
|
|
|
|
serverKey: serverPL151.Key,
|
2023-02-06 07:18:32 +00:00
|
|
|
playerID: playerIdStr,
|
2023-01-31 05:17:07 +00:00
|
|
|
expectedStatus: http.StatusNotFound,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: server not found",
|
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: serverPL151.Key + "2"})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: serverPL151.Key + "2",
|
2023-02-06 07:18:32 +00:00
|
|
|
playerID: playerIdStr,
|
2023-01-31 05:17:07 +00:00
|
|
|
expectedStatus: http.StatusNotFound,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: fmt.Sprintf("server (key=%s) not found", serverPL151.Key+"2"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: player not found",
|
|
|
|
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(serverPL151, nil)
|
|
|
|
playerSvc.GetByServerKeyAndIDWithRelationsReturns(domain.PlayerWithRelations{}, domain.PlayerNotFoundError{ID: 12345551})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: serverPL151.Key,
|
2023-02-06 07:18:32 +00:00
|
|
|
playerID: "12345551",
|
2023-01-31 05:17:07 +00:00
|
|
|
expectedStatus: http.StatusNotFound,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: "player (id=12345551) not found",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
tt := tt
|
|
|
|
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
versionSvc := &mock.FakeVersionService{}
|
|
|
|
serverSvc := &mock.FakeServerService{}
|
|
|
|
playerSvc := &mock.FakePlayerService{}
|
|
|
|
tt.setup(versionSvc, serverSvc, playerSvc)
|
|
|
|
|
|
|
|
router := newRouter(
|
|
|
|
withVersionService(versionSvc),
|
|
|
|
withPlayerService(playerSvc),
|
|
|
|
withServerService(serverSvc),
|
|
|
|
)
|
|
|
|
|
|
|
|
target := fmt.Sprintf(
|
|
|
|
"/v1/versions/%s/servers/%s/players/%s/other-servers?%s",
|
|
|
|
tt.versionCode,
|
|
|
|
tt.serverKey,
|
2023-02-06 07:18:32 +00:00
|
|
|
tt.playerID,
|
|
|
|
tt.queryParams.Encode(),
|
|
|
|
)
|
|
|
|
resp := doRequest(router, http.MethodGet, target, nil)
|
|
|
|
defer resp.Body.Close()
|
|
|
|
assertTotalCount(t, resp.Header, tt.expectedTotalCount)
|
|
|
|
assertJSONResponse(t, resp, tt.expectedStatus, tt.expectedResponse, tt.target)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestPlayer_listTribeMembers(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
now := time.Now()
|
|
|
|
version := domain.Version{
|
|
|
|
Code: "pl",
|
|
|
|
Name: "Poland",
|
|
|
|
Host: "plemiona.pl",
|
|
|
|
Timezone: "Europe/Warsaw",
|
|
|
|
}
|
|
|
|
server := domain.Server{
|
|
|
|
Key: "pl151",
|
|
|
|
URL: "https://pl151.plemiona.pl",
|
|
|
|
Open: true,
|
|
|
|
Special: false,
|
|
|
|
VersionCode: "pl",
|
|
|
|
}
|
|
|
|
tribe := domain.Tribe{
|
|
|
|
ID: 124,
|
|
|
|
Name: "tribe 124",
|
|
|
|
Tag: "tag 124",
|
|
|
|
ProfileURL: "tribe-124",
|
|
|
|
}
|
|
|
|
tribeID := strconv.FormatInt(tribe.ID, 10)
|
|
|
|
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
|
|
|
setup func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
)
|
|
|
|
versionCode string
|
|
|
|
serverKey string
|
|
|
|
tribeID string
|
|
|
|
queryParams url.Values
|
|
|
|
expectedStatus int
|
|
|
|
target any
|
|
|
|
expectedResponse any
|
|
|
|
expectedTotalCount string
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "OK: without params",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
tribeSvc.GetByServerKeyAndIDReturns(tribe, nil)
|
|
|
|
playerSvc.ListCountWithRelationsCalls(func(
|
|
|
|
_ context.Context,
|
|
|
|
params domain.ListPlayersParams,
|
|
|
|
) ([]domain.PlayerWithRelations, int64, error) {
|
|
|
|
expectedParams := domain.ListPlayersParams{
|
|
|
|
ServerKeys: []string{server.Key},
|
|
|
|
TribeID: tribe.ID,
|
|
|
|
}
|
|
|
|
|
|
|
|
if diff := cmp.Diff(params, expectedParams); diff != "" {
|
|
|
|
return nil, 0, fmt.Errorf("validation failed: %s", diff)
|
|
|
|
}
|
|
|
|
|
|
|
|
players := []domain.PlayerWithRelations{
|
|
|
|
{
|
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 8,
|
|
|
|
ScoreAtt: 7,
|
|
|
|
RankDef: 6,
|
|
|
|
ScoreDef: 5,
|
|
|
|
RankSup: 4,
|
|
|
|
ScoreSup: 3,
|
|
|
|
RankTotal: 2,
|
|
|
|
ScoreTotal: 1,
|
|
|
|
},
|
|
|
|
ID: 997,
|
|
|
|
Name: "name 997",
|
|
|
|
NumVillages: 5,
|
|
|
|
Points: 4,
|
|
|
|
Rank: 2,
|
|
|
|
TribeID: tribe.ID,
|
|
|
|
ProfileURL: "profile-997",
|
|
|
|
BestRank: 111,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1112,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Minute),
|
|
|
|
MostVillages: 1113,
|
|
|
|
MostVillagesAt: now.Add(time.Minute),
|
|
|
|
LastActivityAt: now.Add(time.Second),
|
|
|
|
ServerKey: server.Key,
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
Tribe: domain.NullTribeMeta{
|
|
|
|
Valid: true,
|
|
|
|
Tribe: domain.TribeMeta{
|
|
|
|
ID: tribe.ID,
|
|
|
|
Name: tribe.Name,
|
|
|
|
Tag: tribe.Tag,
|
|
|
|
ProfileURL: tribe.ProfileURL,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
},
|
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
TribeID: tribe.ID,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
ServerKey: server.Key,
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
Tribe: domain.NullTribeMeta{
|
|
|
|
Valid: true,
|
|
|
|
Tribe: domain.TribeMeta{
|
|
|
|
ID: tribe.ID,
|
|
|
|
Name: tribe.Name,
|
|
|
|
Tag: tribe.Tag,
|
|
|
|
ProfileURL: tribe.ProfileURL,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
return players, int64(len(players)), nil
|
|
|
|
})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: tribeID,
|
|
|
|
expectedStatus: http.StatusOK,
|
|
|
|
target: &model.ListPlayersResp{},
|
|
|
|
expectedResponse: &model.ListPlayersResp{
|
|
|
|
Data: []model.Player{
|
|
|
|
{
|
|
|
|
RankAtt: 8,
|
|
|
|
ScoreAtt: 7,
|
|
|
|
RankDef: 6,
|
|
|
|
ScoreDef: 5,
|
|
|
|
RankSup: 4,
|
|
|
|
ScoreSup: 3,
|
|
|
|
RankTotal: 2,
|
|
|
|
ScoreTotal: 1,
|
|
|
|
ID: 997,
|
|
|
|
Name: "name 997",
|
|
|
|
NumVillages: 5,
|
|
|
|
Points: 4,
|
|
|
|
Rank: 2,
|
|
|
|
ProfileURL: "profile-997",
|
|
|
|
BestRank: 111,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1112,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Minute),
|
|
|
|
MostVillages: 1113,
|
|
|
|
MostVillagesAt: now.Add(time.Minute),
|
|
|
|
LastActivityAt: now.Add(time.Second),
|
|
|
|
Tribe: model.NullTribeMeta{
|
|
|
|
Valid: true,
|
|
|
|
Tribe: model.TribeMeta{
|
|
|
|
ID: tribe.ID,
|
|
|
|
Name: tribe.Name,
|
|
|
|
Tag: tribe.Tag,
|
|
|
|
ProfileURL: tribe.ProfileURL,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
Tribe: model.NullTribeMeta{
|
|
|
|
Valid: true,
|
|
|
|
Tribe: model.TribeMeta{
|
|
|
|
ID: tribe.ID,
|
|
|
|
Name: tribe.Name,
|
|
|
|
Tag: tribe.Tag,
|
|
|
|
ProfileURL: tribe.ProfileURL,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "2",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "OK: limit=1,sort=[id:asc,points:desc,scoreTotal:asc]",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
tribeSvc.GetByServerKeyAndIDReturns(tribe, nil)
|
|
|
|
playerSvc.ListCountWithRelationsCalls(func(
|
|
|
|
_ context.Context,
|
|
|
|
params domain.ListPlayersParams,
|
|
|
|
) ([]domain.PlayerWithRelations, int64, error) {
|
|
|
|
expectedParams := domain.ListPlayersParams{
|
|
|
|
ServerKeys: []string{server.Key},
|
|
|
|
Pagination: domain.Pagination{
|
|
|
|
Limit: 1,
|
|
|
|
Offset: 0,
|
|
|
|
},
|
|
|
|
TribeID: tribe.ID,
|
|
|
|
Sort: []domain.PlayerSort{
|
|
|
|
{By: domain.PlayerSortByID, Direction: domain.SortDirectionASC},
|
|
|
|
{By: domain.PlayerSortByPoints, Direction: domain.SortDirectionDESC},
|
|
|
|
{By: domain.PlayerSortByScoreTotal, Direction: domain.SortDirectionASC},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
if diff := cmp.Diff(params, expectedParams); diff != "" {
|
|
|
|
return nil, 0, fmt.Errorf("validation failed: %s", diff)
|
|
|
|
}
|
|
|
|
|
|
|
|
players := []domain.PlayerWithRelations{
|
|
|
|
{
|
|
|
|
Player: domain.Player{
|
|
|
|
OpponentsDefeated: domain.OpponentsDefeated{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
},
|
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
TribeID: 0,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
ServerKey: server.Key,
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
Tribe: domain.NullTribeMeta{
|
|
|
|
Valid: true,
|
|
|
|
Tribe: domain.TribeMeta{
|
|
|
|
ID: tribe.ID,
|
|
|
|
Name: tribe.Name,
|
|
|
|
Tag: tribe.Tag,
|
|
|
|
ProfileURL: tribe.ProfileURL,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
return players, int64(len(players)) + 49, nil
|
|
|
|
})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: tribeID,
|
|
|
|
queryParams: url.Values{
|
|
|
|
"limit": []string{"1"},
|
|
|
|
"sort": []string{"id:asc", "points:desc", "scoreTotal:asc"},
|
|
|
|
},
|
|
|
|
expectedStatus: http.StatusOK,
|
|
|
|
target: &model.ListPlayersResp{},
|
|
|
|
expectedResponse: &model.ListPlayersResp{
|
|
|
|
Data: []model.Player{
|
|
|
|
{
|
|
|
|
RankAtt: 1,
|
|
|
|
ScoreAtt: 2,
|
|
|
|
RankDef: 3,
|
|
|
|
ScoreDef: 4,
|
|
|
|
RankSup: 5,
|
|
|
|
ScoreSup: 6,
|
|
|
|
RankTotal: 7,
|
|
|
|
ScoreTotal: 8,
|
|
|
|
ID: 998,
|
|
|
|
Name: "name 998",
|
|
|
|
NumVillages: 2,
|
|
|
|
Points: 3,
|
|
|
|
Rank: 4,
|
|
|
|
ProfileURL: "profile-998",
|
|
|
|
BestRank: 1117,
|
|
|
|
BestRankAt: now,
|
|
|
|
MostPoints: 1115,
|
|
|
|
MostPointsAt: now.Add(-5 * time.Second),
|
|
|
|
MostVillages: 1114,
|
|
|
|
MostVillagesAt: now.Add(time.Hour),
|
|
|
|
LastActivityAt: now.Add(time.Minute),
|
|
|
|
Tribe: model.NullTribeMeta{
|
|
|
|
Valid: true,
|
|
|
|
Tribe: model.TribeMeta{
|
|
|
|
ID: tribe.ID,
|
|
|
|
Name: tribe.Name,
|
|
|
|
Tag: tribe.Tag,
|
|
|
|
ProfileURL: tribe.ProfileURL,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
CreatedAt: now,
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "50",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: limit is not a valid int32",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
tribeSvc.GetByServerKeyAndIDReturns(tribe, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: tribeID,
|
|
|
|
queryParams: url.Values{
|
|
|
|
"limit": []string{"asd"},
|
|
|
|
},
|
|
|
|
expectedStatus: http.StatusBadRequest,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "limit: strconv.ParseInt: parsing \"asd\": invalid syntax",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: offset is not a valid int32",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
tribeSvc.GetByServerKeyAndIDReturns(tribe, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: tribeID,
|
|
|
|
queryParams: url.Values{
|
|
|
|
"offset": []string{"asd"},
|
|
|
|
},
|
|
|
|
expectedStatus: http.StatusBadRequest,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "offset: strconv.ParseInt: parsing \"asd\": invalid syntax",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: sort - invalid format",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
tribeSvc.GetByServerKeyAndIDReturns(tribe, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: tribeID,
|
|
|
|
queryParams: url.Values{
|
|
|
|
"sort": []string{"id:asc", "test"},
|
|
|
|
},
|
|
|
|
expectedStatus: http.StatusBadRequest,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "sort[1]: parsing \"test\": invalid syntax, expected field:direction",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: sort - unsupported field",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
tribeSvc.GetByServerKeyAndIDReturns(tribe, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: tribeID,
|
|
|
|
queryParams: url.Values{
|
|
|
|
"sort": []string{"id:asc", "test:asc"},
|
|
|
|
},
|
|
|
|
expectedStatus: http.StatusBadRequest,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "sort[1]: unsupported sort by: \"test\"",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: sort - unsupported direction",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
tribeSvc.GetByServerKeyAndIDReturns(tribe, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: tribeID,
|
|
|
|
queryParams: url.Values{
|
|
|
|
"sort": []string{"id:asc2"},
|
|
|
|
},
|
|
|
|
expectedStatus: http.StatusBadRequest,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "sort[0]: unsupported sort direction: \"asc2\"",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: tribe id is not a valid int64",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: "asdf",
|
|
|
|
expectedStatus: http.StatusBadRequest,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeValidationError.String(),
|
|
|
|
Message: "tribeId: strconv.ParseInt: parsing \"asdf\": invalid syntax",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: version not found",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
|
|
|
|
},
|
|
|
|
versionCode: version.Code + "2",
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: tribeID,
|
|
|
|
expectedStatus: http.StatusNotFound,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: server not found",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key + "2",
|
|
|
|
tribeID: tribeID,
|
|
|
|
expectedStatus: http.StatusNotFound,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "ERR: tribe not found",
|
|
|
|
setup: func(
|
|
|
|
versionSvc *mock.FakeVersionService,
|
|
|
|
serverSvc *mock.FakeServerService,
|
|
|
|
tribeSvc *mock.FakeTribeService,
|
|
|
|
playerSvc *mock.FakePlayerService,
|
|
|
|
) {
|
|
|
|
versionSvc.GetByCodeReturns(version, nil)
|
|
|
|
serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, nil)
|
|
|
|
tribeSvc.GetByServerKeyAndIDCalls(func(_ context.Context, _ string, id int64) (domain.Tribe, error) {
|
|
|
|
return domain.Tribe{}, domain.TribeNotFoundError{ID: id}
|
|
|
|
})
|
|
|
|
},
|
|
|
|
versionCode: version.Code,
|
|
|
|
serverKey: server.Key,
|
|
|
|
tribeID: tribeID + "2",
|
|
|
|
expectedStatus: http.StatusNotFound,
|
|
|
|
target: &model.ErrorResp{},
|
|
|
|
expectedResponse: &model.ErrorResp{
|
|
|
|
Error: model.APIError{
|
|
|
|
Code: domain.ErrorCodeEntityNotFound.String(),
|
|
|
|
Message: fmt.Sprintf("tribe (id=%s) not found", tribeID+"2"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
expectedTotalCount: "",
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, tt := range tests {
|
|
|
|
tt := tt
|
|
|
|
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
versionSvc := &mock.FakeVersionService{}
|
|
|
|
serverSvc := &mock.FakeServerService{}
|
|
|
|
playerSvc := &mock.FakePlayerService{}
|
|
|
|
tribeSvc := &mock.FakeTribeService{}
|
|
|
|
tt.setup(versionSvc, serverSvc, tribeSvc, playerSvc)
|
|
|
|
|
|
|
|
router := newRouter(
|
|
|
|
withVersionService(versionSvc),
|
|
|
|
withPlayerService(playerSvc),
|
|
|
|
withServerService(serverSvc),
|
|
|
|
withTribeService(tribeSvc),
|
|
|
|
)
|
|
|
|
|
|
|
|
target := fmt.Sprintf(
|
|
|
|
"/v1/versions/%s/servers/%s/tribes/%s/members?%s",
|
|
|
|
tt.versionCode,
|
|
|
|
tt.serverKey,
|
|
|
|
tt.tribeID,
|
2023-01-31 05:17:07 +00:00
|
|
|
tt.queryParams.Encode(),
|
|
|
|
)
|
|
|
|
resp := doRequest(router, http.MethodGet, target, nil)
|
|
|
|
defer resp.Body.Close()
|
|
|
|
assertTotalCount(t, resp.Header, tt.expectedTotalCount)
|
|
|
|
assertJSONResponse(t, resp, tt.expectedStatus, tt.expectedResponse, tt.target)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|