From d795776f9560549f4917e5d3ddef081c26eaffe2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dawid=20Wysoki=C5=84ski?= Date: Sat, 24 Dec 2022 09:21:26 +0000 Subject: [PATCH] refactor: ennoblement - split the List method into two (#146) Reviewed-on: https://gitea.dwysokinski.me/twhelp/core/pulls/146 --- internal/bundb/ennoblement.go | 95 +++++++++-------- internal/bundb/ennoblement_test.go | 128 ++++++++--------------- internal/bundb/player_test.go | 2 +- internal/bundb/tribe.go | 15 +-- internal/bundb/village_test.go | 14 +-- internal/domain/ennoblement.go | 16 +-- internal/router/rest/ennoblement.go | 12 +-- internal/router/rest/ennoblement_test.go | 20 +--- internal/service/ennoblement.go | 16 +-- internal/service/ennoblement_test.go | 44 ++++---- 10 files changed, 152 insertions(+), 210 deletions(-) diff --git a/internal/bundb/ennoblement.go b/internal/bundb/ennoblement.go index bf27096..abd9ce1 100644 --- a/internal/bundb/ennoblement.go +++ b/internal/bundb/ennoblement.go @@ -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 { diff --git a/internal/bundb/ennoblement_test.go b/internal/bundb/ennoblement_test.go index 324e9e5..bbe00f8 100644 --- a/internal/bundb/ennoblement_test.go +++ b/internal/bundb/ennoblement_test.go @@ -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) } }) } diff --git a/internal/bundb/player_test.go b/internal/bundb/player_test.go index 22d1f96..0af18ec 100644 --- a/internal/bundb/player_test.go +++ b/internal/bundb/player_test.go @@ -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 } diff --git a/internal/bundb/tribe.go b/internal/bundb/tribe.go index cbf6eac..976a7fc 100644 --- a/internal/bundb/tribe.go +++ b/internal/bundb/tribe.go @@ -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) { diff --git a/internal/bundb/village_test.go b/internal/bundb/village_test.go index 5ab7e10..bffd208 100644 --- a/internal/bundb/village_test.go +++ b/internal/bundb/village_test.go @@ -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 } diff --git a/internal/domain/ennoblement.go b/internal/domain/ennoblement.go index 7ec36ed..4350f14 100644 --- a/internal/domain/ennoblement.go +++ b/internal/domain/ennoblement.go @@ -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 { diff --git a/internal/router/rest/ennoblement.go b/internal/router/rest/ennoblement.go index bd0afa0..ced6c1f 100644 --- a/internal/router/rest/ennoblement.go +++ b/internal/router/rest/ennoblement.go @@ -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 diff --git a/internal/router/rest/ennoblement_test.go b/internal/router/rest/ennoblement_test.go index d3e66b5..b2127e3 100644 --- a/internal/router/rest/ennoblement_test.go +++ b/internal/router/rest/ennoblement_test.go @@ -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 != "" { diff --git a/internal/service/ennoblement.go b/internal/service/ennoblement.go index 222a7bf..15c0560 100644 --- a/internal/service/ennoblement.go +++ b/internal/service/ennoblement.go @@ -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 diff --git a/internal/service/ennoblement_test.go b/internal/service/ennoblement_test.go index f4a5cd1..237b80f 100644 --- a/internal/service/ennoblement_test.go +++ b/internal/service/ennoblement_test.go @@ -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()) }) } })