twhelp/core-old
Archived
1
0
Fork 0
Code Issues 1 Pull Requests 10 Projects Releases Wiki Activity
This repository has been archived on 2024-04-06. You can view files and clone it, but cannot push or open issues or pull requests.
9c70224fff
core-old/internal/router/rest/tribe_test.go
Dawid Wysokiński 912d39158f
All checks were successful
continuous-integration/drone/push Build is passing
Details
refactor: query params (#183) 
Reviewed-on: twhelp/core#183
2023-02-13 05:06:07 +00:00

939 lines
28 KiB
Go
Raw Blame History

package rest_test
import (
"context"
"fmt"
"net/http"
"net/url"
"testing"
"time"
"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/mock"
"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
"github.com/google/go-cmp/cmp"
"gitea.dwysokinski.me/twhelp/core/internal/domain"
)
func TestTribe_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
setup func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService)
versionCode string
serverKey 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) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
tribeSvc.ListCountCalls(func(_ context.Context, params domain.ListTribesParams) ([]domain.Tribe, int64, error) {
expectedParams := domain.ListTribesParams{
Deleted: domain.NullBool{
Valid: false,
Bool: false,
},
ServerKeys: []string{server.Key},
}
if diff := cmp.Diff(params, expectedParams); diff != "" {
return nil, 0, fmt.Errorf("validation failed: %s", diff)
}
tribes := []domain.Tribe{
{
OpponentsDefeated: domain.OpponentsDefeated{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankSup: 4,
ScoreSup: 3,
RankTotal: 2,
ScoreTotal: 1,
},
ID: 997,
Name: "name 997",
Tag: "tag 997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
ServerKey: server.Key,
Dominance: 12.5,
CreatedAt: now,
},
{
OpponentsDefeated: domain.OpponentsDefeated{
RankAtt: 1,
ScoreAtt: 2,
RankDef: 3,
ScoreDef: 4,
RankSup: 5,
ScoreSup: 6,
RankTotal: 7,
ScoreTotal: 9,
},
ID: 998,
Name: "name 998",
Tag: "tag 998",
NumMembers: 1,
NumVillages: 2,
Points: 3,
AllPoints: 4,
Rank: 5,
ProfileURL: "profile-998",
BestRank: 1113,
BestRankAt: now.Add(time.Hour),
MostPoints: 1114,
MostPointsAt: now.Add(-5 * time.Second),
MostVillages: 1115,
MostVillagesAt: now.Add(5 * time.Minute),
ServerKey: server.Key,
Dominance: 12.55,
CreatedAt: now.Add(-5000 * time.Hour),
DeletedAt: now,
},
}
return tribes, int64(len(tribes)), nil
})
},
versionCode: version.Code,
serverKey: server.Key,
expectedStatus: http.StatusOK,
target: &model.ListTribesResp{},
expectedResponse: &model.ListTribesResp{
Data: []model.Tribe{
{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankTotal: 2,
ScoreTotal: 1,
ID: 997,
Name: "name 997",
Tag: "tag 997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
Dominance: 12.5,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
CreatedAt: now,
},
{
RankAtt: 1,
ScoreAtt: 2,
RankDef: 3,
ScoreDef: 4,
RankTotal: 7,
ScoreTotal: 9,
ID: 998,
Name: "name 998",
Tag: "tag 998",
NumMembers: 1,
NumVillages: 2,
Points: 3,
AllPoints: 4,
Rank: 5,
Dominance: 12.55,
ProfileURL: "profile-998",
BestRank: 1113,
BestRankAt: now.Add(time.Hour),
MostPoints: 1114,
MostPointsAt: now.Add(-5 * time.Second),
MostVillages: 1115,
MostVillagesAt: now.Add(5 * time.Minute),
CreatedAt: now.Add(-5000 * time.Hour),
DeletedAt: model.NullTime{
Valid: true,
Time: now,
},
},
},
},
expectedTotalCount: "2",
},
{
name: "OK: sort=[id:asc,scoreDef:desc,scoreTotal:asc]",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
tribeSvc.ListCountCalls(func(_ context.Context, params domain.ListTribesParams) ([]domain.Tribe, int64, error) {
expectedParams := domain.ListTribesParams{
Deleted: domain.NullBool{
Valid: false,
Bool: false,
},
ServerKeys: []string{server.Key},
Sort: []domain.TribeSort{
{
By: domain.TribeSortByID,
Direction: domain.SortDirectionASC,
},
{
By: domain.TribeSortByScoreDef,
Direction: domain.SortDirectionDESC,
},
{
By: domain.TribeSortByScoreTotal,
Direction: domain.SortDirectionASC,
},
},
}
if diff := cmp.Diff(params, expectedParams); diff != "" {
return nil, 0, fmt.Errorf("validation failed: %s", diff)
}
tribes := []domain.Tribe{
{
OpponentsDefeated: domain.OpponentsDefeated{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankSup: 4,
ScoreSup: 3,
RankTotal: 2,
ScoreTotal: 1,
},
ID: 997,
Name: "name 997",
Tag: "tag 997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
ServerKey: server.Key,
Dominance: 12.5,
CreatedAt: now,
},
{
OpponentsDefeated: domain.OpponentsDefeated{
RankAtt: 1,
ScoreAtt: 2,
RankDef: 3,
ScoreDef: 4,
RankSup: 5,
ScoreSup: 6,
RankTotal: 7,
ScoreTotal: 9,
},
ID: 998,
Name: "name 998",
Tag: "tag 998",
NumMembers: 1,
NumVillages: 2,
Points: 3,
AllPoints: 4,
Rank: 5,
ProfileURL: "profile-998",
BestRank: 1113,
BestRankAt: now.Add(time.Hour),
MostPoints: 1114,
MostPointsAt: now.Add(-5 * time.Second),
MostVillages: 1115,
MostVillagesAt: now.Add(5 * time.Minute),
ServerKey: server.Key,
Dominance: 12.55,
CreatedAt: now.Add(-5000 * time.Hour),
DeletedAt: now,
},
}
return tribes, int64(len(tribes)), nil
})
},
versionCode: version.Code,
serverKey: server.Key,
queryParams: url.Values{
"sort": []string{"id:asc", "scoreDef:desc", "scoreTotal:asc"},
},
expectedStatus: http.StatusOK,
target: &model.ListTribesResp{},
expectedResponse: &model.ListTribesResp{
Data: []model.Tribe{
{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankTotal: 2,
ScoreTotal: 1,
ID: 997,
Name: "name 997",
Tag: "tag 997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
Dominance: 12.5,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
CreatedAt: now,
},
{
RankAtt: 1,
ScoreAtt: 2,
RankDef: 3,
ScoreDef: 4,
RankTotal: 7,
ScoreTotal: 9,
ID: 998,
Name: "name 998",
Tag: "tag 998",
NumMembers: 1,
NumVillages: 2,
Points: 3,
AllPoints: 4,
Rank: 5,
Dominance: 12.55,
ProfileURL: "profile-998",
BestRank: 1113,
BestRankAt: now.Add(time.Hour),
MostPoints: 1114,
MostPointsAt: now.Add(-5 * time.Second),
MostVillages: 1115,
MostVillagesAt: now.Add(5 * time.Minute),
CreatedAt: now.Add(-5000 * time.Hour),
DeletedAt: model.NullTime{
Valid: true,
Time: now,
},
},
},
},
expectedTotalCount: "2",
},
{
name: "OK: deleted=false,limit=1,offset=15",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
tribeSvc.ListCountCalls(func(_ context.Context, params domain.ListTribesParams) ([]domain.Tribe, int64, error) {
expectedParams := domain.ListTribesParams{
Deleted: domain.NullBool{
Valid: true,
Bool: false,
},
ServerKeys: []string{server.Key},
Pagination: domain.Pagination{
Limit: 1,
Offset: 15,
},
}
if diff := cmp.Diff(params, expectedParams); diff != "" {
return nil, 0, fmt.Errorf("validation failed: %s", diff)
}
tribes := []domain.Tribe{
{
OpponentsDefeated: domain.OpponentsDefeated{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankSup: 4,
ScoreSup: 3,
RankTotal: 2,
ScoreTotal: 1,
},
ID: 997,
Name: "name 997",
Tag: "tag 997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
ServerKey: server.Key,
Dominance: 12.5,
CreatedAt: now,
},
}
return tribes, int64(len(tribes)) + 15, nil
})
},
versionCode: version.Code,
serverKey: server.Key,
queryParams: url.Values{
"limit": []string{"1"},
"offset": []string{"15"},
"deleted": []string{"false"},
},
expectedStatus: http.StatusOK,
target: &model.ListTribesResp{},
expectedResponse: &model.ListTribesResp{
Data: []model.Tribe{
{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankTotal: 2,
ScoreTotal: 1,
ID: 997,
Name: "name 997",
Tag: "tag 997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
Dominance: 12.5,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
CreatedAt: now,
},
},
},
expectedTotalCount: "16",
},
{
name: "OK: tag=[tag997,tag998]",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
tribeSvc.ListCountCalls(func(_ context.Context, params domain.ListTribesParams) ([]domain.Tribe, int64, error) {
expectedParams := domain.ListTribesParams{
ServerKeys: []string{server.Key},
Tags: []string{"tag997", "tag998"},
}
if diff := cmp.Diff(params, expectedParams); diff != "" {
return nil, 0, fmt.Errorf("validation failed: %s", diff)
}
tribes := []domain.Tribe{
{
OpponentsDefeated: domain.OpponentsDefeated{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankSup: 4,
ScoreSup: 3,
RankTotal: 2,
ScoreTotal: 1,
},
ID: 997,
Name: "name 997",
Tag: "tag997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
ServerKey: server.Key,
Dominance: 12.5,
CreatedAt: now,
},
}
return tribes, int64(len(tribes)), nil
})
},
versionCode: version.Code,
serverKey: server.Key,
queryParams: url.Values{
"tag": []string{"tag997", "tag998"},
},
expectedStatus: http.StatusOK,
target: &model.ListTribesResp{},
expectedResponse: &model.ListTribesResp{
Data: []model.Tribe{
{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankTotal: 2,
ScoreTotal: 1,
ID: 997,
Name: "name 997",
Tag: "tag997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
Dominance: 12.5,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
CreatedAt: now,
},
},
},
expectedTotalCount: "1",
},
{
name: "ERR: limit is not a valid int32",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
},
versionCode: version.Code,
serverKey: server.Key,
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) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
},
versionCode: version.Code,
serverKey: server.Key,
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: deleted is not a valid boolean",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
},
versionCode: version.Code,
serverKey: server.Key,
queryParams: url.Values{
"deleted": []string{"asd"},
},
expectedStatus: http.StatusBadRequest,
target: &model.ErrorResp{},
expectedResponse: &model.ErrorResp{
Error: model.APIError{
Code: domain.ErrorCodeValidationError.String(),
Message: "deleted: strconv.ParseBool: parsing \"asd\": invalid syntax",
},
},
expectedTotalCount: "",
},
{
name: "ERR: sort - invalid format",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
},
versionCode: version.Code,
serverKey: server.Key,
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) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
},
versionCode: version.Code,
serverKey: server.Key,
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) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
},
versionCode: version.Code,
serverKey: server.Key,
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: version not found",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
},
versionCode: version.Code + "2",
serverKey: server.Key,
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) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
},
versionCode: version.Code,
serverKey: server.Key + "2",
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: "",
},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
versionSvc := &mock.FakeVersionService{}
serverSvc := &mock.FakeServerService{}
tribeSvc := &mock.FakeTribeService{}
tt.setup(versionSvc, serverSvc, tribeSvc)
router := newRouter(
withVersionService(versionSvc),
withServerService(serverSvc),
withTribeService(tribeSvc),
)
target := fmt.Sprintf(
"/v1/versions/%s/servers/%s/tribes?%s",
tt.versionCode,
tt.serverKey,
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 TestTribe_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
setup func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService)
versionCode string
serverKey string
id string
expectedStatus int
target any
expectedResponse any
}{
{
name: "OK",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
tribeSvc.GetByServerKeyAndIDReturns(domain.Tribe{
OpponentsDefeated: domain.OpponentsDefeated{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankSup: 4,
ScoreSup: 3,
RankTotal: 2,
ScoreTotal: 1,
},
ID: 997,
Name: "name 997",
Tag: "tag 997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
ServerKey: server.Key,
Dominance: 12.5,
CreatedAt: now,
}, nil)
},
versionCode: version.Code,
serverKey: server.Key,
id: "997",
expectedStatus: http.StatusOK,
target: &model.GetTribeResp{},
expectedResponse: &model.GetTribeResp{
Data: model.Tribe{
RankAtt: 8,
ScoreAtt: 7,
RankDef: 6,
ScoreDef: 5,
RankTotal: 2,
ScoreTotal: 1,
ID: 997,
Name: "name 997",
Tag: "tag 997",
NumMembers: 6,
NumVillages: 5,
Points: 4,
AllPoints: 3,
Rank: 2,
Dominance: 12.5,
ProfileURL: "profile-997",
BestRank: 111,
BestRankAt: now,
MostPoints: 1112,
MostPointsAt: now.Add(-5 * time.Minute),
MostVillages: 1113,
MostVillagesAt: now.Add(time.Minute),
CreatedAt: now,
},
},
},
{
name: "ERR: tribe id is not a valid int64",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
},
versionCode: version.Code,
serverKey: server.Key,
id: "true",
expectedStatus: http.StatusBadRequest,
target: &model.ErrorResp{},
expectedResponse: &model.ErrorResp{
Error: model.APIError{
Code: domain.ErrorCodeValidationError.String(),
Message: "tribeId: strconv.ParseInt: parsing \"true\": invalid syntax",
},
},
},
{
name: "ERR: version not found",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
},
versionCode: version.Code + "2",
serverKey: server.Key,
id: "1234",
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"),
},
},
},
{
name: "ERR: server not found",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
},
versionCode: version.Code,
serverKey: server.Key + "2",
id: "1234",
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"),
},
},
},
{
name: "ERR: tribe not found",
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
tribeSvc.GetByServerKeyAndIDReturns(domain.Tribe{}, domain.TribeNotFoundError{ID: 12345551})
},
versionCode: version.Code,
serverKey: server.Key,
id: "12345551",
expectedStatus: http.StatusNotFound,
target: &model.ErrorResp{},
expectedResponse: &model.ErrorResp{
Error: model.APIError{
Code: domain.ErrorCodeEntityNotFound.String(),
Message: "tribe (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{}
tribeSvc := &mock.FakeTribeService{}
tt.setup(versionSvc, serverSvc, tribeSvc)
router := newRouter(
withVersionService(versionSvc),
withServerService(serverSvc),
withTribeService(tribeSvc),
)
target := fmt.Sprintf(
"/v1/versions/%s/servers/%s/tribes/%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)
})
}
}
Reference in New Issue View Git Blame Copy Permalink