twhelp/core-old
Archived
1
0
Fork 0
Code Issues 1 Pull Requests 10 Projects Releases Wiki Activity

refactor: ennoblement - split the List method into two (#146)
All checks were successful
continuous-integration/drone/push Build is passing
Details
continuous-integration/drone/tag Build is passing
Details

Browse Source 
Reviewed-on: twhelp/core#146
This commit is contained in:
Dawid Wysokiński 2022-12-24 09:21:26 +00:00
parent def3161957
commit d795776f95
10 changed files with 152 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
internal/bundb/ennoblement.go
View File

@ -11,6 +11,10 @@ import (
"github.com/uptrace/bun"
)
var (
ennoblementOrders = []string{"ennoblement.server_key ASC"}
)
type Ennoblement struct {
db *bun.DB
}
@ -39,37 +43,68 @@ func (e *Ennoblement) Create(ctx context.Context, params ...domain.CreateEnnoble
return nil
}
func (e *Ennoblement) List(
func (e *Ennoblement) List(ctx context.Context, params domain.ListEnnoblementsParams) ([]domain.Ennoblement, error) {
var ennoblements []model.Ennoblement
q := e.db.NewSelect().
Model(&ennoblements).
Order(ennoblementOrders...)
q, err := listEnnoblementsParamsApplier{params}.apply(q)
if err != nil {
return nil, err
}
if err = q.Scan(ctx); err != nil && !errors.Is(err, sql.ErrNoRows) {
return nil, fmt.Errorf("couldn't select ennoblements from the db: %w", err)
}
result := make([]domain.Ennoblement, 0, len(ennoblements))
for _, ennoblement := range ennoblements {
result = append(result, ennoblement.ToDomain())
}
return result, nil
}
func (e *Ennoblement) ListCountWithRelations(
ctx context.Context,
params domain.ListEnnoblementsParams,
) ([]domain.EnnoblementWithRelations, int64, error) {
var ennoblements []model.Ennoblement
var count int
var err error
paramsApplier := listEnnoblementsParamsApplier{params}
base := e.db.NewSelect().
Model(&model.Ennoblement{}).
Order("ennoblement.server_key ASC").
Apply(paramsApplier.applyFilters)
q := e.db.NewSelect().
With("ennoblements_base", base).
Model(&ennoblements).
ModelTableExpr("ennoblements_base AS ennoblement").
Apply(paramsApplier.applyRelations).
Apply(paramsApplier.applyPagination)
q, err = paramsApplier.applySort(q)
Order(ennoblementOrders...).
Apply(paramsApplier.applyPagination).
Relation("OldOwner", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(playerMetaColumns...)
}).
Relation("OldTribe", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(tribeMetaColumns...)
}).
Relation("NewOwner", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(playerMetaColumns...)
}).
Relation("NewTribe", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(tribeMetaColumns...)
}).
Relation("Village", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(villageMetaColumns...)
})
q, err := paramsApplier.applySort(q)
if err != nil {
return nil, 0, err
}
if params.Count {
count, err = scanAndCount(ctx, base, q)
} else {
err = q.Scan(ctx)
}
count, err := scanAndCount(ctx, base, q)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return nil, 0, fmt.Errorf("couldn't select ennoblements from the db: %w", err)
}
@ -86,38 +121,12 @@ type listEnnoblementsParamsApplier struct {
params domain.ListEnnoblementsParams
}
func (l listEnnoblementsParamsApplier) applyRelations(q *bun.SelectQuery) *bun.SelectQuery {
if l.params.IncludeVillage {
q = q.Relation("Village", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(villageMetaColumns...)
})
func (l listEnnoblementsParamsApplier) apply(q *bun.SelectQuery) (*bun.SelectQuery, error) {
q, err := l.applySort(q)
if err != nil {
return nil, err
}
if l.params.IncludeNewOwner {
q = q.Relation("NewOwner", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(playerMetaColumns...)
})
}
if l.params.IncludeNewTribe {
q = q.Relation("NewTribe", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(tribeMetaColumns...)
})
}
if l.params.IncludeOldOwner {
q = q.Relation("OldOwner", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(playerMetaColumns...)
})
}
if l.params.IncludeOldTribe {
q = q.Relation("OldTribe", func(q *bun.SelectQuery) *bun.SelectQuery {
return q.Column(tribeMetaColumns...)
})
}
return q
return l.applyPagination(l.applyFilters(q)), nil
}
func (l listEnnoblementsParamsApplier) applyFilters(q *bun.SelectQuery) *bun.SelectQuery {

128
internal/bundb/ennoblement_test.go
View File

@ -80,7 +80,7 @@ func TestEnnoblement_Create(t *testing.T) {
assert.NoError(t, repo.Create(context.Background(), params...))
ennoblements, _, err := repo.List(context.Background(), domain.ListEnnoblementsParams{
ennoblements, err := repo.List(context.Background(), domain.ListEnnoblementsParams{
ServerKeys: []string{server.Key},
})
assert.NoError(t, err)
@ -118,9 +118,8 @@ func TestEnnoblement_Create(t *testing.T) {
ennoblement := getEnnoblementFromFixture(t, fixture, "pl169-village-2-1")
_, totalBeforeCreate, err := repo.List(context.Background(), domain.ListEnnoblementsParams{
_, totalBeforeCreate, err := repo.ListCountWithRelations(context.Background(), domain.ListEnnoblementsParams{
ServerKeys: []string{ennoblement.ServerKey},
Count: true,
})
assert.NoError(t, err)
@ -136,9 +135,8 @@ func TestEnnoblement_Create(t *testing.T) {
})
assert.NoError(t, err)
_, totalAfterCreate, err := repo.List(context.Background(), domain.ListEnnoblementsParams{
_, totalAfterCreate, err := repo.ListCountWithRelations(context.Background(), domain.ListEnnoblementsParams{
ServerKeys: []string{ennoblement.ServerKey},
Count: true,
})
assert.NoError(t, err)
@ -155,13 +153,8 @@ func TestEnnoblement_List(t *testing.T) {
ennoblements := getAllEnnoblementsFromFixture(t, fixture)
type expectedEnnoblement struct {
id int64
serverKey string
villageID int64
newOwnerID int64
newTribeID int64
oldOwnerID int64
oldTribeID int64
id int64
serverKey string
}
allEnnoblements := make([]expectedEnnoblement, 0, len(ennoblements))
@ -180,21 +173,14 @@ func TestEnnoblement_List(t *testing.T) {
expectedErr error
}{
{
name: "Count=true",
params: domain.ListEnnoblementsParams{Count: true},
name: "Empty struct",
params: domain.ListEnnoblementsParams{},
expectedEnnoblements: allEnnoblements,
expectedCount: int64(len(allEnnoblements)),
},
{
name: "Count=false",
params: domain.ListEnnoblementsParams{Count: false},
expectedEnnoblements: allEnnoblements,
expectedCount: 0,
},
{
name: "ServerKeys=[pl169],Count=true",
name: "ServerKeys=[pl169]",
params: domain.ListEnnoblementsParams{
Count: true,
ServerKeys: []string{"pl169"},
},
expectedEnnoblements: []expectedEnnoblement{
@ -210,9 +196,8 @@ func TestEnnoblement_List(t *testing.T) {
expectedCount: 2,
},
{
name: "ServerKeys=[pl169],Sort=[{By=CreatedAt,Direction=DESC}],Limit=1,Count=true",
name: "ServerKeys=[pl169],Sort=[{By=CreatedAt,Direction=DESC}],Limit=1",
params: domain.ListEnnoblementsParams{
Count: true,
Pagination: domain.Pagination{
Limit: 1,
},
@ -230,9 +215,8 @@ func TestEnnoblement_List(t *testing.T) {
expectedCount: 2,
},
{
name: "ServerKeys=[it70],Sort=[{By=ID,Direction=DESC}],Limit=1,Offset=1,Count=true",
name: "ServerKeys=[it70],Sort=[{By=ID,Direction=DESC}],Limit=1,Offset=1",
params: domain.ListEnnoblementsParams{
Count: true,
Pagination: domain.Pagination{
Limit: 1,
Offset: 1,
@ -251,42 +235,8 @@ func TestEnnoblement_List(t *testing.T) {
expectedCount: 2,
},
{
name: "ServerKeys=[it70],IncludeVillage=true,IncludeNewOwner=true,IncludeNewTribe=true,IncludeOldOwner=true,IncludeOldTribe=true,Count=true",
name: "CreatedAtLTE=2021-12-31T23:59:59Z,CreatedAtGTE=2021-01-01T00:00:00Z",
params: domain.ListEnnoblementsParams{
Count: true,
ServerKeys: []string{"it70"},
IncludeVillage: true,
IncludeNewOwner: true,
IncludeNewTribe: true,
IncludeOldOwner: true,
IncludeOldTribe: true,
},
expectedEnnoblements: []expectedEnnoblement{
{
id: 3,
serverKey: "it70",
villageID: 10023,
newOwnerID: 848881282,
newTribeID: 31,
oldOwnerID: 0,
oldTribeID: 0,
},
{
id: 4,
serverKey: "it70",
villageID: 10023,
newOwnerID: 578014,
newTribeID: 1,
oldOwnerID: 848881282,
oldTribeID: 31,
},
},
expectedCount: 2,
},
{
name: "CreatedAtLTE=2021-12-31T23:59:59Z,CreatedAtGTE=2021-01-01T00:00:00Z,Count=true",
params: domain.ListEnnoblementsParams{
Count: true,
CreatedAtLTE: domain.NullTime{
Time: time.Date(2021, time.December, 31, 23, 59, 59, 0, time.UTC),
Valid: true,
@ -338,39 +288,55 @@ func TestEnnoblement_List(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
res, count, err := repo.List(context.Background(), tt.params)
resListCountWithRelations, count, err := repo.ListCountWithRelations(context.Background(), tt.params)
assert.ErrorIs(t, err, tt.expectedErr)
assert.Equal(t, tt.expectedCount, count)
assert.Len(t, res, len(tt.expectedEnnoblements))
assert.Len(t, resListCountWithRelations, len(tt.expectedEnnoblements))
for _, expEnnoblement := range tt.expectedEnnoblements {
found := false
for _, ennoblement := range res {
if ennoblement.ID != expEnnoblement.id {
for _, ennoblement := range resListCountWithRelations {
if ennoblement.ID != expEnnoblement.id || ennoblement.ServerKey != expEnnoblement.serverKey {
continue
}
if ennoblement.ServerKey != expEnnoblement.serverKey {
if ennoblement.VillageID != 0 && (!ennoblement.Village.Valid || ennoblement.Village.Village.ID != ennoblement.VillageID) {
continue
}
if ennoblement.Village.Village.ID != expEnnoblement.villageID {
if ennoblement.VillageID == 0 && ennoblement.Village.Valid {
continue
}
if ennoblement.NewOwner.Player.ID != expEnnoblement.newOwnerID {
if ennoblement.NewOwnerID != 0 && (!ennoblement.NewOwner.Valid || ennoblement.NewOwner.Player.ID != ennoblement.NewOwnerID) {
continue
}
if ennoblement.NewTribe.Tribe.ID != expEnnoblement.newTribeID {
if ennoblement.NewOwnerID == 0 && ennoblement.NewOwner.Valid {
continue
}
if ennoblement.OldOwner.Player.ID != expEnnoblement.oldOwnerID {
if ennoblement.NewTribeID != 0 && (!ennoblement.NewTribe.Valid || ennoblement.NewTribe.Tribe.ID != ennoblement.NewTribeID) {
continue
}
if ennoblement.OldTribe.Tribe.ID != expEnnoblement.oldTribeID {
if ennoblement.NewTribeID == 0 && ennoblement.NewTribe.Valid {
continue
}
if ennoblement.OldOwnerID != 0 && (!ennoblement.OldOwner.Valid || ennoblement.OldOwner.Player.ID != ennoblement.OldOwnerID) {
continue
}
if ennoblement.OldOwnerID == 0 && ennoblement.OldOwner.Valid {
continue
}
if ennoblement.OldTribeID != 0 && (!ennoblement.OldTribe.Valid || ennoblement.OldTribe.Tribe.ID != ennoblement.OldTribeID) {
continue
}
if ennoblement.OldTribeID == 0 && ennoblement.OldTribe.Valid {
continue
}
@ -378,18 +344,14 @@ func TestEnnoblement_List(t *testing.T) {
break
}
assert.True(
t,
found,
"ennoblement (id=%d,villageID=%d,newOwnerID=%d,newTribeID=%d,oldOwnerID=%d,oldTribeID=%d,serverkey=%s) not found",
expEnnoblement.id,
expEnnoblement.villageID,
expEnnoblement.newOwnerID,
expEnnoblement.newTribeID,
expEnnoblement.oldOwnerID,
expEnnoblement.oldTribeID,
expEnnoblement.serverKey,
)
assert.True(t, found, "ennoblement (id=%d,serverkey=%s) not found", expEnnoblement.id, expEnnoblement.serverKey)
}
resList, err := repo.List(context.Background(), tt.params)
assert.ErrorIs(t, err, tt.expectedErr)
assert.Len(t, resList, len(resListCountWithRelations))
for i, ennoblement := range resList {
assert.Equal(t, resListCountWithRelations[i].Ennoblement, ennoblement)
}
})
}

2
internal/bundb/player_test.go
View File

@ -604,7 +604,7 @@ func TestPlayer_List_ListCountWithRelations(t *testing.T) {
continue
}
if player.TribeID == 0 && (player.Tribe.Valid || player.Tribe.Tribe.ID != player.TribeID) {
if player.TribeID == 0 && player.Tribe.Valid {
continue
}

15
internal/bundb/tribe.go
View File

@ -156,8 +156,14 @@ type listTribesParamsApplier struct {
}
func (l listTribesParamsApplier) apply(q *bun.SelectQuery) (*bun.SelectQuery, error) {
var err error
q, err := l.applySort(q)
if err != nil {
return nil, fmt.Errorf("listTribesParamsApplier.applySort: %w", err)
}
return l.applyPagination(l.applyFilters(q)), nil
}
func (l listTribesParamsApplier) applyFilters(q *bun.SelectQuery) *bun.SelectQuery {
if l.params.IDs != nil {
q = q.Where("tribe.id IN (?)", bun.In(l.params.IDs))
}
@ -182,12 +188,7 @@ func (l listTribesParamsApplier) apply(q *bun.SelectQuery) (*bun.SelectQuery, er
}
}
q, err = l.applySort(q)
if err != nil {
return nil, fmt.Errorf("listTribesParamsApplier.applySort: %w", err)
}
return l.applyPagination(q), nil
return q
}
func (l listTribesParamsApplier) applySort(q *bun.SelectQuery) (*bun.SelectQuery, error) {

14
internal/bundb/village_test.go
View File

@ -258,11 +258,7 @@ func TestVillage_List_ListCountWithRelations(t *testing.T) {
found := false
for _, village := range resListCountWithRelations {
if village.ID != expVillage.id {
continue
}
if village.ServerKey != expVillage.serverKey {
if village.ID != expVillage.id || village.ServerKey != expVillage.serverKey {
continue
}
@ -270,6 +266,10 @@ func TestVillage_List_ListCountWithRelations(t *testing.T) {
continue
}
if village.PlayerID == 0 && village.Player.Valid {
continue
}
if village.Player.Player.Tribe.Valid && village.Player.Player.Tribe.Tribe.ID == 0 {
continue
}
@ -278,10 +278,6 @@ func TestVillage_List_ListCountWithRelations(t *testing.T) {
continue
}
if village.PlayerID == 0 && (village.Player.Valid || village.Player.Player.ID != village.PlayerID) {
continue
}
found = true
break
}

16
internal/domain/ennoblement.go
View File

@ -61,17 +61,11 @@ type EnnoblementSort struct {
}
type ListEnnoblementsParams struct {
ServerKeys []string
CreatedAtGTE NullTime
CreatedAtLTE NullTime
Pagination Pagination
Sort []EnnoblementSort
IncludeVillage bool
IncludeNewOwner bool
IncludeNewTribe bool
IncludeOldOwner bool
IncludeOldTribe bool
Count bool
ServerKeys []string
CreatedAtGTE NullTime
CreatedAtLTE NullTime
Pagination Pagination
Sort []EnnoblementSort
}
type RefreshEnnoblementsCmdPayload struct {

12
internal/router/rest/ennoblement.go
View File

@ -17,7 +17,7 @@ const (
//counterfeiter:generate -o internal/mock/ennoblement_service.gen.go . EnnoblementService
type EnnoblementService interface {
List(ctx context.Context, params domain.ListEnnoblementsParams) ([]domain.EnnoblementWithRelations, int64, error)
ListCountWithRelations(ctx context.Context, params domain.ListEnnoblementsParams) ([]domain.EnnoblementWithRelations, int64, error)
}
type ennoblement struct {
@ -46,13 +46,7 @@ func (e *ennoblement) list(w http.ResponseWriter, r *http.Request) {
var err error
ctx := r.Context()
params := domain.ListEnnoblementsParams{
ServerKeys: []string{chi.URLParamFromCtx(ctx, "serverKey")},
Count: true,
IncludeVillage: true,
IncludeNewOwner: true,
IncludeNewTribe: true,
IncludeOldOwner: true,
IncludeOldTribe: true,
ServerKeys: []string{chi.URLParamFromCtx(ctx, "serverKey")},
}
query := queryParams{r.URL.Query()}
@ -80,7 +74,7 @@ func (e *ennoblement) list(w http.ResponseWriter, r *http.Request) {
return
}
ennoblements, count, err := e.svc.List(ctx, params)
ennoblements, count, err := e.svc.ListCountWithRelations(ctx, params)
if err != nil {
renderErr(w, err)
return

20
internal/router/rest/ennoblement_test.go
View File

@ -53,22 +53,16 @@ func TestEnnoblement_list(t *testing.T) {
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
ennoblementSvc.ListCalls(func(
ennoblementSvc.ListCountWithRelationsCalls(func(
_ context.Context,
params domain.ListEnnoblementsParams,
) ([]domain.EnnoblementWithRelations, int64, error) {
expectedParams := domain.ListEnnoblementsParams{
ServerKeys: []string{server.Key},
IncludeVillage: true,
IncludeNewOwner: true,
IncludeNewTribe: true,
IncludeOldOwner: true,
IncludeOldTribe: true,
ServerKeys: []string{server.Key},
Pagination: domain.Pagination{
Limit: 200,
Offset: 0,
},
Count: true,
}
if diff := cmp.Diff(params, expectedParams); diff != "" {
@ -265,17 +259,12 @@ func TestEnnoblement_list(t *testing.T) {
setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
versionSvc.GetByCodeReturns(version, nil)
serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
ennoblementSvc.ListCalls(func(
ennoblementSvc.ListCountWithRelationsCalls(func(
_ context.Context,
params domain.ListEnnoblementsParams,
) ([]domain.EnnoblementWithRelations, int64, error) {
expectedParams := domain.ListEnnoblementsParams{
ServerKeys: []string{server.Key},
IncludeVillage: true,
IncludeNewOwner: true,
IncludeNewTribe: true,
IncludeOldOwner: true,
IncludeOldTribe: true,
ServerKeys: []string{server.Key},
CreatedAtGTE: domain.NullTime{
Valid: true,
Time: now.Add(-30 * time.Hour).Truncate(time.Second),
@ -291,7 +280,6 @@ func TestEnnoblement_list(t *testing.T) {
Limit: 1,
Offset: 100,
},
Count: true,
}
if diff := cmp.Diff(params, expectedParams, cmpopts.IgnoreUnexported(time.Time{})); diff != "" {

16
internal/service/ennoblement.go
View File

@ -23,7 +23,8 @@ var (
//counterfeiter:generate -o internal/mock/ennoblement_repository.gen.go . EnnoblementRepository
type EnnoblementRepository interface {
Create(ctx context.Context, params ...domain.CreateEnnoblementParams) error
List(
List(ctx context.Context, params domain.ListEnnoblementsParams) ([]domain.Ennoblement, error)
ListCountWithRelations(
ctx context.Context,
params domain.ListEnnoblementsParams,
) ([]domain.EnnoblementWithRelations, int64, error)
@ -88,7 +89,7 @@ func (e *Ennoblement) Refresh(ctx context.Context, key, url string) error {
return nil
}
func (e *Ennoblement) List(
func (e *Ennoblement) ListCountWithRelations(
ctx context.Context,
params domain.ListEnnoblementsParams,
) ([]domain.EnnoblementWithRelations, int64, error) {
@ -118,7 +119,7 @@ func (e *Ennoblement) List(
return nil, 0, fmt.Errorf("validatePagination: %w", err)
}
ennoblements, count, err := e.repo.List(ctx, params)
ennoblements, count, err := e.repo.ListCountWithRelations(ctx, params)
if err != nil {
return nil, 0, fmt.Errorf("EnnoblementRepository.List: %w", err)
}
@ -126,8 +127,8 @@ func (e *Ennoblement) List(
return ennoblements, count, nil
}
func (e *Ennoblement) getLatestEnnoblement(ctx context.Context, key string) (domain.EnnoblementWithRelations, error) {
ennoblements, _, err := e.repo.List(ctx, domain.ListEnnoblementsParams{
func (e *Ennoblement) getLatestEnnoblement(ctx context.Context, key string) (domain.Ennoblement, error) {
ennoblements, err := e.repo.List(ctx, domain.ListEnnoblementsParams{
ServerKeys: []string{key},
Pagination: domain.Pagination{
Limit: 1,
@ -135,13 +136,12 @@ func (e *Ennoblement) getLatestEnnoblement(ctx context.Context, key string) (dom
Sort: []domain.EnnoblementSort{
{By: domain.EnnoblementSortByCreatedAt, Direction: domain.SortDirectionDESC},
},
Count: false,
})
if err != nil {
return domain.EnnoblementWithRelations{}, fmt.Errorf("EnnoblementRepository.List: %w", err)
return domain.Ennoblement{}, fmt.Errorf("EnnoblementRepository.List: %w", err)
}
if len(ennoblements) == 0 {
return domain.EnnoblementWithRelations{}, errEnnoblementNotFound
return domain.Ennoblement{}, errEnnoblementNotFound
}
return ennoblements[0], nil

44
internal/service/ennoblement_test.go
View File

@ -25,26 +25,24 @@ func TestEnnoblement_Refresh(t *testing.T) {
name string
key string
url string
ennoblementsRepo []domain.EnnoblementWithRelations
ennoblementsRepo []domain.Ennoblement
ennoblementsClient []tw.Ennoblement
}{
{
name: "OK: since=now-20h",
key: "pl151",
url: "https://pl151.plemiona.pl",
ennoblementsRepo: []domain.EnnoblementWithRelations{
ennoblementsRepo: []domain.Ennoblement{
{
Ennoblement: domain.Ennoblement{
ID: 111,
VillageID: 112,
NewOwnerID: 113,
NewTribeID: 114,
OldOwnerID: 115,
OldTribeID: 116,
Points: 117,
CreatedAt: time.Now().Add(-20 * time.Hour),
ServerKey: "pl151",
},
ID: 111,
VillageID: 112,
NewOwnerID: 113,
NewTribeID: 114,
OldOwnerID: 115,
OldTribeID: 116,
Points: 117,
CreatedAt: time.Now().Add(-20 * time.Hour),
ServerKey: "pl151",
},
},
ennoblementsClient: []tw.Ennoblement{
@ -102,7 +100,7 @@ func TestEnnoblement_Refresh(t *testing.T) {
t.Parallel()
repo := &mock.FakeEnnoblementRepository{}
repo.ListReturns(tt.ennoblementsRepo, 0, nil)
repo.ListReturns(tt.ennoblementsRepo, nil)
repo.CreateReturns(nil)
client := &mock.FakeEnnoblementGetter{}
client.GetEnnoblementsReturns(tt.ennoblementsClient, nil)
@ -134,7 +132,7 @@ func TestEnnoblement_Refresh(t *testing.T) {
}
}
func TestEnnoblement_List(t *testing.T) {
func TestEnnoblement_ListCountWithRelations(t *testing.T) {
t.Parallel()
t.Run("OK", func(t *testing.T) {
@ -175,7 +173,7 @@ func TestEnnoblement_List(t *testing.T) {
}
repo := &mock.FakeEnnoblementRepository{}
repo.ListCalls(func(
repo.ListCountWithRelationsCalls(func(
_ context.Context,
params domain.ListEnnoblementsParams,
) ([]domain.EnnoblementWithRelations, int64, error) {
@ -204,8 +202,8 @@ func TestEnnoblement_List(t *testing.T) {
})
client := &mock.FakeEnnoblementGetter{}
players, count, err := service.NewEnnoblement(repo, client).
List(context.Background(), domain.ListEnnoblementsParams{
ennoblements, count, err := service.NewEnnoblement(repo, client).
ListCountWithRelations(context.Background(), domain.ListEnnoblementsParams{
Pagination: domain.Pagination{
Limit: tt.limit,
},
@ -213,7 +211,7 @@ func TestEnnoblement_List(t *testing.T) {
})
assert.NoError(t, err)
assert.EqualValues(t, limit, count)
assert.Len(t, players, int(limit))
assert.Len(t, ennoblements, int(limit))
})
}
})
@ -304,12 +302,12 @@ func TestEnnoblement_List(t *testing.T) {
repo := &mock.FakeEnnoblementRepository{}
client := &mock.FakeEnnoblementGetter{}
players, count, err := service.NewEnnoblement(repo, client).
List(context.Background(), tt.params)
ennoblements, count, err := service.NewEnnoblement(repo, client).
ListCountWithRelations(context.Background(), tt.params)
assert.ErrorIs(t, err, tt.expectedErr)
assert.Zero(t, players)
assert.Zero(t, ennoblements)
assert.Zero(t, count)
assert.Equal(t, 0, repo.ListCallCount())
assert.Equal(t, 0, repo.ListCountWithRelationsCallCount())
})
}
})