feat: add meta router (#83)

Reviewed-on: twhelp/core#83

cmd/twhelp/internal/serve/serve.go

@@ -10,12 +10,12 @@ import (
 	"syscall"
 	"time"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/meta"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest"
 	"github.com/riandyrn/otelchi"
 
 	"github.com/kelseyhightower/envconfig"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest"
-
 	"gitea.dwysokinski.me/twhelp/core/internal/bundb"
 	"gitea.dwysokinski.me/twhelp/core/internal/service"
 
@@ -142,6 +142,8 @@ func newServer(cfg serverConfig) (*http.Server, error) {
 		Swagger: apiCfg.EnableSwagger,
 	}))
 
+	r.Mount("/_meta", meta.NewRouter([]meta.Checker{bundb.NewChecker(cfg.db)}))
+
 	return &http.Server{
 		Addr:              ":" + defaultPort,
 		Handler:           r,
@@ -175,7 +177,6 @@ func getChiMiddlewares(logger *zap.Logger) chi.Middlewares {
 		otelchi.Middleware(serviceName),
 		chizap.Logger(logger),
 		middleware.Recoverer,
-		middleware.Heartbeat("/health"),
 	}
 }
 

internal/bundb/checker.go

@@ -0,0 +1,23 @@
+package bundb
+
+import (
+	"context"
+
+	"github.com/uptrace/bun"
+)
+
+type Checker struct {
+	db *bun.DB
+}
+
+func NewChecker(db *bun.DB) *Checker {
+	return &Checker{db: db}
+}
+
+func (c *Checker) Name() string {
+	return "db:ping"
+}
+
+func (c *Checker) Check(ctx context.Context) error {
+	return c.db.PingContext(ctx)
+}

internal/bundb/checker_test.go

@@ -0,0 +1,21 @@
+package bundb_test
+
+import (
+	"context"
+	"testing"
+
+	"gitea.dwysokinski.me/twhelp/core/internal/bundb"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestChecker_Name(t *testing.T) {
+	t.Parallel()
+
+	assert.Equal(t, "db:ping", bundb.NewChecker(nil).Name())
+}
+
+func TestChecker_Check(t *testing.T) {
+	t.Parallel()
+
+	assert.NoError(t, bundb.NewChecker(newDB(t)).Check(context.Background()))
+}

internal/rest/.swaggo

@@ -1,3 +0,0 @@
-replace gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model.NullTribeMeta gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model.TribeMeta
-replace gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model.NullPlayerMeta gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model.PlayerMeta
-replace gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model.NullVillageMeta gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model.VillageMeta

internal/router/meta/internal/model/model.go

@@ -0,0 +1,32 @@
+package model
+
+import (
+	"net/http"
+	"time"
+)
+
+type Status string
+
+const (
+	StatusPass Status = "pass"
+	StatusFail Status = "fail"
+)
+
+func (s Status) ToHTTPStatus() int {
+	if s != StatusPass {
+		return http.StatusFailedDependency
+	}
+	return http.StatusOK
+}
+
+type ComponentStatus struct {
+	Status Status    `json:"status"`
+	Time   time.Time `json:"time"`
+}
+
+type Checks map[string][]ComponentStatus
+
+type ReadyResp struct {
+	Status Status `json:"status"`
+	Checks Checks `json:"checks"`
+}

internal/router/meta/meta.go

@@ -0,0 +1,59 @@
+package meta
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"gitea.dwysokinski.me/twhelp/core/internal/router/meta/internal/model"
+	"github.com/go-chi/chi/v5"
+)
+
+// https://datatracker.ietf.org/doc/html/draft-inadarei-api-health-check#section-3.1
+
+const (
+	checkTimeout = 5 * time.Second
+)
+
+type Checker interface {
+	Name() string
+	Check(ctx context.Context) error
+}
+
+func NewRouter(checkers []Checker) *chi.Mux {
+	router := chi.NewRouter()
+
+	router.Get("/livez", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNoContent)
+	})
+
+	router.Get("/readyz", func(w http.ResponseWriter, r *http.Request) {
+		resp := model.ReadyResp{
+			Status: model.StatusPass,
+			Checks: make(model.Checks, len(checkers)),
+		}
+
+		ctx, cancel := context.WithTimeout(r.Context(), checkTimeout)
+		defer cancel()
+
+		for _, ch := range checkers {
+			st := model.StatusPass
+			if err := ch.Check(ctx); err != nil {
+				st = model.StatusFail
+				resp.Status = model.StatusFail
+			}
+
+			resp.Checks[ch.Name()] = append(resp.Checks[ch.Name()], model.ComponentStatus{
+				Status: st,
+				Time:   time.Now(),
+			})
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(resp.Status.ToHTTPStatus())
+		_ = json.NewEncoder(w).Encode(resp)
+	})
+
+	return router
+}

internal/router/meta/meta_test.go

@@ -0,0 +1,127 @@
+package meta_test
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"gitea.dwysokinski.me/twhelp/core/internal/router/meta"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/meta/internal/model"
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLivez(t *testing.T) {
+	t.Parallel()
+
+	rr := httptest.NewRecorder()
+	meta.NewRouter(nil).ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/livez", nil))
+
+	assert.Equal(t, http.StatusNoContent, rr.Code)
+	assert.Equal(t, 0, rr.Body.Len())
+}
+
+func TestReadyz(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name           string
+		checkers       []meta.Checker
+		expectedStatus int
+		expectedResp   model.ReadyResp
+	}{
+		{
+			name:           "0 checks",
+			checkers:       nil,
+			expectedStatus: http.StatusOK,
+			expectedResp: model.ReadyResp{
+				Status: model.StatusPass,
+				Checks: map[string][]model.ComponentStatus{},
+			},
+		},
+		{
+			name: "2 passed",
+			checkers: []meta.Checker{
+				checker{name: "test", err: nil},
+				checker{name: "test2", err: nil},
+			},
+			expectedStatus: http.StatusOK,
+			expectedResp: model.ReadyResp{
+				Status: model.StatusPass,
+				Checks: map[string][]model.ComponentStatus{
+					"test": {
+						{
+							Status: model.StatusPass,
+						},
+					},
+					"test2": {
+						{
+							Status: model.StatusPass,
+						},
+					},
+				},
+			},
+		},
+		{
+			name: "1 passed and 1 failed",
+			checkers: []meta.Checker{
+				checker{name: "test", err: nil},
+				checker{name: "test2", err: errors.New("any")},
+			},
+			expectedStatus: http.StatusFailedDependency,
+			expectedResp: model.ReadyResp{
+				Status: model.StatusFail,
+				Checks: map[string][]model.ComponentStatus{
+					"test": {
+						{
+							Status: model.StatusPass,
+						},
+					},
+					"test2": {
+						{
+							Status: model.StatusFail,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			rr := httptest.NewRecorder()
+			meta.NewRouter(tt.checkers).ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/readyz", nil))
+
+			assert.Equal(t, tt.expectedStatus, rr.Code)
+			assert.Equal(t, "application/json", rr.Header().Get("Content-Type"))
+			var target model.ReadyResp
+			assert.NoError(t, json.NewDecoder(rr.Body).Decode(&target))
+			opts := cmp.Options{
+				cmpopts.IgnoreTypes(time.Time{}),
+			}
+			assert.Empty(t, cmp.Diff(tt.expectedResp, target, opts...))
+		})
+	}
+}
+
+type checker struct {
+	name string
+	err  error
+}
+
+func (c checker) Name() string {
+	return c.name
+}
+
+func (c checker) Check(_ context.Context) error {
+	return c.err
+}

internal/router/rest/.swaggo

@@ -0,0 +1,3 @@
+replace gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model.NullTribeMeta gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model.TribeMeta
+replace gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model.NullPlayerMeta gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model.PlayerMeta
+replace gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model.NullVillageMeta gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model.VillageMeta

internal/router/rest/ennoblement.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"net/http"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/go-chi/chi/v5"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"

internal/router/rest/ennoblement_test.go

@@ -9,14 +9,14 @@ import (
 	"testing"
 	"time"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest"
+	mock2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/mock"
+	model2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/google/go-cmp/cmp/cmpopts"
 
 	"github.com/google/go-cmp/cmp"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/mock"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
 )
 
 func TestEnnoblement_list(t *testing.T) {
@@ -39,7 +39,7 @@ func TestEnnoblement_list(t *testing.T) {
 
 	tests := []struct {
 		name               string
-		setup              func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService)
+		setup              func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, ennoblementSvc *mock2.FakeEnnoblementService)
 		versionCode        string
 		key                string
 		queryParams        url.Values
@@ -50,7 +50,7 @@ func TestEnnoblement_list(t *testing.T) {
 	}{
 		{
 			name: "OK: without params",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, ennoblementSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				ennoblementSvc.ListCalls(func(_ context.Context, params domain.ListEnnoblementsParams) ([]domain.Ennoblement, int64, error) {
@@ -188,24 +188,24 @@ func TestEnnoblement_list(t *testing.T) {
 			versionCode:    version.Code,
 			key:            server.Key,
 			expectedStatus: 200,
-			target:         &model.ListEnnoblementsResp{},
-			expectedResponse: &model.ListEnnoblementsResp{
-				Data: []model.Ennoblement{
+			target:         &model2.ListEnnoblementsResp{},
+			expectedResponse: &model2.ListEnnoblementsResp{
+				Data: []model2.Ennoblement{
 					{
 						ID:     1234,
 						Points: 128,
-						Village: model.VillageMeta{
+						Village: model2.VillageMeta{
 							ID:       123,
 							FullName: "village name (450|450) K44",
 						},
-						NewOwner: model.NullPlayerMeta{
+						NewOwner: model2.NullPlayerMeta{
 							Valid: true,
-							Player: model.PlayerMeta{
+							Player: model2.PlayerMeta{
 								ID:   124,
 								Name: "new owner name",
-								Tribe: model.NullTribeMeta{
+								Tribe: model2.NullTribeMeta{
 									Valid: true,
-									Tribe: model.TribeMeta{
+									Tribe: model2.TribeMeta{
 										ID:   125,
 										Name: "new tribe name",
 										Tag:  "new tribe tag",
@@ -213,14 +213,14 @@ func TestEnnoblement_list(t *testing.T) {
 								},
 							},
 						},
-						OldOwner: model.NullPlayerMeta{
+						OldOwner: model2.NullPlayerMeta{
 							Valid: true,
-							Player: model.PlayerMeta{
+							Player: model2.PlayerMeta{
 								ID:   126,
 								Name: "old owner name",
-								Tribe: model.NullTribeMeta{
+								Tribe: model2.NullTribeMeta{
 									Valid: true,
-									Tribe: model.TribeMeta{
+									Tribe: model2.TribeMeta{
 										ID:   127,
 										Name: "old tribe name",
 										Tag:  "old tribe tag",
@@ -233,18 +233,18 @@ func TestEnnoblement_list(t *testing.T) {
 					{
 						ID:     12345,
 						Points: 129,
-						Village: model.VillageMeta{
+						Village: model2.VillageMeta{
 							ID:       311,
 							FullName: "village name (550|550) K55",
 						},
-						NewOwner: model.NullPlayerMeta{
+						NewOwner: model2.NullPlayerMeta{
 							Valid: true,
-							Player: model.PlayerMeta{
+							Player: model2.PlayerMeta{
 								ID:   312,
 								Name: "new owner name",
-								Tribe: model.NullTribeMeta{
+								Tribe: model2.NullTribeMeta{
 									Valid: true,
-									Tribe: model.TribeMeta{
+									Tribe: model2.TribeMeta{
 										ID:   313,
 										Name: "new tribe name",
 										Tag:  "new tribe tag",
@@ -260,7 +260,7 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "OK: limit=1,offset=100,since=now-30h,before=now,sort=[createdAt:desc]",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, ennoblementSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				ennoblementSvc.ListCalls(func(_ context.Context, params domain.ListEnnoblementsParams) ([]domain.Ennoblement, int64, error) {
@@ -352,24 +352,24 @@ func TestEnnoblement_list(t *testing.T) {
 				"since":  []string{now.Add(-30 * time.Hour).Format(time.RFC3339)},
 				"before": []string{now.Format(time.RFC3339)},
 			},
-			target: &model.ListEnnoblementsResp{},
-			expectedResponse: &model.ListEnnoblementsResp{
-				Data: []model.Ennoblement{
+			target: &model2.ListEnnoblementsResp{},
+			expectedResponse: &model2.ListEnnoblementsResp{
+				Data: []model2.Ennoblement{
 					{
 						ID:     12345,
 						Points: 129,
-						Village: model.VillageMeta{
+						Village: model2.VillageMeta{
 							ID:       311,
 							FullName: "village name (450|450) K44",
 						},
-						NewOwner: model.NullPlayerMeta{
+						NewOwner: model2.NullPlayerMeta{
 							Valid: true,
-							Player: model.PlayerMeta{
+							Player: model2.PlayerMeta{
 								ID:   312,
 								Name: "new owner name",
-								Tribe: model.NullTribeMeta{
+								Tribe: model2.NullTribeMeta{
 									Valid: true,
-									Tribe: model.TribeMeta{
+									Tribe: model2.TribeMeta{
 										ID:   313,
 										Name: "new tribe name",
 										Tag:  "new tribe tag",
@@ -385,7 +385,7 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "ERR: since is not a valid timestamp",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -395,9 +395,9 @@ func TestEnnoblement_list(t *testing.T) {
 				"since": []string{"???"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "since: parsing time \"???\" as \"2006-01-02T15:04:05Z07:00\": cannot parse \"???\" as \"2006\"",
 				},
@@ -406,7 +406,7 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "ERR: before is not a valid timestamp",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -416,9 +416,9 @@ func TestEnnoblement_list(t *testing.T) {
 				"before": []string{"???"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "before: parsing time \"???\" as \"2006-01-02T15:04:05Z07:00\": cannot parse \"???\" as \"2006\"",
 				},
@@ -427,7 +427,7 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "ERR: limit is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -437,9 +437,9 @@ func TestEnnoblement_list(t *testing.T) {
 				"limit": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "limit: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -448,7 +448,7 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "ERR: offset is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, ennoblementSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -458,9 +458,9 @@ func TestEnnoblement_list(t *testing.T) {
 				"offset": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "offset: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -469,7 +469,7 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "ERR: sort - invalid format",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, ennoblementSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -479,9 +479,9 @@ func TestEnnoblement_list(t *testing.T) {
 				"sort": []string{"id:asc", "test"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "sort[1]: parsing \"test\": invalid syntax, expected field:direction",
 				},
@@ -490,7 +490,7 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "ERR: sort - unsupported field",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, ennoblementSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -500,9 +500,9 @@ func TestEnnoblement_list(t *testing.T) {
 				"sort": []string{"id:asc", "test:asc"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "sort[1]: unsupported sort by: \"test\"",
 				},
@@ -511,7 +511,7 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "ERR: sort - unsupported direction",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, ennoblementSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -521,9 +521,9 @@ func TestEnnoblement_list(t *testing.T) {
 				"sort": []string{"id:asc2"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "sort[0]: unsupported sort direction: \"asc2\"",
 				},
@@ -532,15 +532,15 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, ennoblementSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
 			},
 			versionCode:    version.Code + "2",
 			key:            server.Key,
 			expectedStatus: 404,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -549,16 +549,16 @@ func TestEnnoblement_list(t *testing.T) {
 		},
 		{
 			name: "ERR: server not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, ennoblementSvc *mock.FakeEnnoblementService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, ennoblementSvc *mock2.FakeEnnoblementService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
 			},
 			versionCode:    version.Code,
 			key:            server.Key + "2",
 			expectedStatus: 404,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
 				},
@@ -573,9 +573,9 @@ func TestEnnoblement_list(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
-			ennoblementSvc := &mock.FakeEnnoblementService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
+			ennoblementSvc := &mock2.FakeEnnoblementService{}
 			tt.setup(versionSvc, serverSvc, ennoblementSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{

internal/router/rest/internal/model/building_info_test.go

@@ -3,10 +3,9 @@ package model_test
 import (
 	"testing"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
-
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
 )
 

internal/router/rest/internal/model/ennoblement_test.go

@@ -4,10 +4,9 @@ import (
 	"testing"
 	"time"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
-
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
 )
 

internal/router/rest/internal/model/model_test.go

@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 )
 

internal/router/rest/internal/model/player_test.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	model2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -32,7 +32,7 @@ func TestNewPlayer(t *testing.T) {
 		ServerKey: "pl151",
 		CreatedAt: time.Now(),
 	}
-	assertPlayer(t, playerWithoutTribe, model.NewPlayer(playerWithoutTribe))
+	assertPlayer(t, playerWithoutTribe, model2.NewPlayer(playerWithoutTribe))
 
 	playerWithTribe := domain.Player{
 		BasePlayer: domain.BasePlayer{
@@ -84,7 +84,7 @@ func TestNewPlayer(t *testing.T) {
 		},
 		CreatedAt: time.Now(),
 	}
-	assertPlayer(t, playerWithTribe, model.NewPlayer(playerWithTribe))
+	assertPlayer(t, playerWithTribe, model2.NewPlayer(playerWithTribe))
 }
 
 func TestNewPlayerMeta(t *testing.T) {
@@ -109,7 +109,7 @@ func TestNewPlayerMeta(t *testing.T) {
 		ServerKey: "pl151",
 		CreatedAt: time.Now(),
 	}
-	assertPlayerMeta(t, playerWithoutTribe, model.NewPlayerMeta(playerWithoutTribe))
+	assertPlayerMeta(t, playerWithoutTribe, model2.NewPlayerMeta(playerWithoutTribe))
 
 	playerWithTribe := domain.Player{
 		BasePlayer: domain.BasePlayer{
@@ -161,7 +161,7 @@ func TestNewPlayerMeta(t *testing.T) {
 		},
 		CreatedAt: time.Now(),
 	}
-	assertPlayerMeta(t, playerWithTribe, model.NewPlayerMeta(playerWithTribe))
+	assertPlayerMeta(t, playerWithTribe, model2.NewPlayerMeta(playerWithTribe))
 }
 
 func TestNullPlayerMeta_MarshalJSON(t *testing.T) {
@@ -169,34 +169,34 @@ func TestNullPlayerMeta_MarshalJSON(t *testing.T) {
 
 	tests := []struct {
 		name         string
-		player       model.NullPlayerMeta
+		player       model2.NullPlayerMeta
 		expectedJSON string
 	}{
 		{
 			name: "OK: null 1",
-			player: model.NullPlayerMeta{
-				Player: model.PlayerMeta{},
+			player: model2.NullPlayerMeta{
+				Player: model2.PlayerMeta{},
 				Valid:  false,
 			},
 			expectedJSON: "null",
 		},
 		{
 			name: "OK: null 2",
-			player: model.NullPlayerMeta{
-				Player: model.PlayerMeta{ID: 1234},
+			player: model2.NullPlayerMeta{
+				Player: model2.PlayerMeta{ID: 1234},
 				Valid:  false,
 			},
 			expectedJSON: "null",
 		},
 		{
 			name: "OK: valid struct",
-			player: model.NullPlayerMeta{
-				Player: model.PlayerMeta{
+			player: model2.NullPlayerMeta{
+				Player: model2.PlayerMeta{
 					ID:   997,
 					Name: "name 997",
-					Tribe: model.NullTribeMeta{
+					Tribe: model2.NullTribeMeta{
 						Valid: true,
-						Tribe: model.TribeMeta{
+						Tribe: model2.TribeMeta{
 							ID:   1234,
 							Name: "name 997",
 							Tag:  "tag 997",
@@ -229,14 +229,14 @@ func TestNullPlayerMeta_UnmarshalJSON(t *testing.T) {
 	tests := []struct {
 		name                    string
 		json                    string
-		expectedPlayer          model.NullPlayerMeta
+		expectedPlayer          model2.NullPlayerMeta
 		expectedJSONSyntaxError bool
 	}{
 		{
 			name: "OK: null",
 			json: "null",
-			expectedPlayer: model.NullPlayerMeta{
-				Player: model.PlayerMeta{},
+			expectedPlayer: model2.NullPlayerMeta{
+				Player: model2.PlayerMeta{},
 				Valid:  false,
 			},
 		},
@@ -244,13 +244,13 @@ func TestNullPlayerMeta_UnmarshalJSON(t *testing.T) {
 			name: "OK: valid struct",
 			//nolint:lll
 			json: `{"id":997,"name":"name 997","tribe":{"id":1234,"name":"name 997","tag":"tag 997"}}`,
-			expectedPlayer: model.NullPlayerMeta{
-				Player: model.PlayerMeta{
+			expectedPlayer: model2.NullPlayerMeta{
+				Player: model2.PlayerMeta{
 					ID:   997,
 					Name: "name 997",
-					Tribe: model.NullTribeMeta{
+					Tribe: model2.NullTribeMeta{
 						Valid: true,
-						Tribe: model.TribeMeta{
+						Tribe: model2.TribeMeta{
 							ID:   1234,
 							Name: "name 997",
 							Tag:  "tag 997",
@@ -263,13 +263,13 @@ func TestNullPlayerMeta_UnmarshalJSON(t *testing.T) {
 		{
 			name:                    "ERR: invalid tribe 1",
 			json:                    "2022-07-30T14:13:12.0000005Z",
-			expectedPlayer:          model.NullPlayerMeta{},
+			expectedPlayer:          model2.NullPlayerMeta{},
 			expectedJSONSyntaxError: true,
 		},
 		{
 			name:                    "ERR: invalid tribe 2",
 			json:                    "hello world",
-			expectedPlayer:          model.NullPlayerMeta{},
+			expectedPlayer:          model2.NullPlayerMeta{},
 			expectedJSONSyntaxError: true,
 		},
 	}
@@ -280,7 +280,7 @@ func TestNullPlayerMeta_UnmarshalJSON(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			var target model.NullPlayerMeta
+			var target model2.NullPlayerMeta
 			err := json.Unmarshal([]byte(tt.json), &target)
 			if tt.expectedJSONSyntaxError {
 				var syntaxError *json.SyntaxError
@@ -373,7 +373,7 @@ func TestNewListPlayersResp(t *testing.T) {
 			CreatedAt: time.Now(),
 		},
 	}
-	resp := model.NewListPlayersResp(players)
+	resp := model2.NewListPlayersResp(players)
 	assert.Len(t, resp.Data, len(players))
 	for i, player := range resp.Data {
 		assertPlayer(t, players[i], player)
@@ -404,10 +404,10 @@ func TestNewGetPlayerResp(t *testing.T) {
 		ServerKey: "pl151",
 		CreatedAt: time.Now(),
 	}
-	assertPlayer(t, player, model.NewGetPlayerResp(player).Data)
+	assertPlayer(t, player, model2.NewGetPlayerResp(player).Data)
 }
 
-func assertPlayer(tb testing.TB, dp domain.Player, rp model.Player) {
+func assertPlayer(tb testing.TB, dp domain.Player, rp model2.Player) {
 	tb.Helper()
 
 	assert.Equal(tb, dp.ID, rp.ID)
@@ -428,7 +428,7 @@ func assertPlayer(tb testing.TB, dp domain.Player, rp model.Player) {
 	assertNullTime(tb, dp.DeletedAt, rp.DeletedAt)
 }
 
-func assertPlayerMeta(tb testing.TB, dp domain.Player, rp model.PlayerMeta) {
+func assertPlayerMeta(tb testing.TB, dp domain.Player, rp model2.PlayerMeta) {
 	tb.Helper()
 
 	assert.Equal(tb, dp.ID, rp.ID)
@@ -436,7 +436,7 @@ func assertPlayerMeta(tb testing.TB, dp domain.Player, rp model.PlayerMeta) {
 	assertNullTribeMeta(tb, dp.Tribe, rp.Tribe)
 }
 
-func assertNullPlayerMeta(tb testing.TB, dp domain.NullPlayer, rp model.NullPlayerMeta) {
+func assertNullPlayerMeta(tb testing.TB, dp domain.NullPlayer, rp model2.NullPlayerMeta) {
 	tb.Helper()
 
 	if !dp.Valid {

internal/router/rest/internal/model/server_config_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 )
 

internal/router/rest/internal/model/server_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"

internal/router/rest/internal/model/tribe_test.go

@@ -5,10 +5,9 @@ import (
 	"testing"
 	"time"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
-
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
 )
 

internal/router/rest/internal/model/unit_info_test.go

@@ -3,10 +3,10 @@ package model_test
 import (
 	"testing"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
 )
 
 func TestNewUnitInfo(t *testing.T) {

internal/router/rest/internal/model/version_test.go

@@ -3,7 +3,7 @@ package model_test
 import (
 	"testing"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"

internal/router/rest/internal/model/village_test.go

@@ -5,7 +5,7 @@ import (
 	"time"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/stretchr/testify/assert"
 )
 

internal/router/rest/player.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"net/http"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/go-chi/chi/v5"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"

internal/router/rest/player_test.go

@@ -8,12 +8,12 @@ import (
 	"testing"
 	"time"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest"
+	mock2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/mock"
+	model2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/google/go-cmp/cmp"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/mock"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
 )
 
 func TestPlayer_list(t *testing.T) {
@@ -36,7 +36,7 @@ func TestPlayer_list(t *testing.T) {
 
 	tests := []struct {
 		name               string
-		setup              func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService)
+		setup              func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService)
 		versionCode        string
 		key                string
 		queryParams        url.Values
@@ -47,7 +47,7 @@ func TestPlayer_list(t *testing.T) {
 	}{
 		{
 			name: "OK: without params",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				playerSvc.ListCalls(func(_ context.Context, params domain.ListPlayersParams) ([]domain.Player, int64, error) {
@@ -148,9 +148,9 @@ func TestPlayer_list(t *testing.T) {
 			versionCode:    version.Code,
 			key:            server.Key,
 			expectedStatus: 200,
-			target:         &model.ListPlayersResp{},
-			expectedResponse: &model.ListPlayersResp{
-				Data: []model.Player{
+			target:         &model2.ListPlayersResp{},
+			expectedResponse: &model2.ListPlayersResp{
+				Data: []model2.Player{
 					{
 						RankAtt:     8,
 						ScoreAtt:    7,
@@ -165,9 +165,9 @@ func TestPlayer_list(t *testing.T) {
 						NumVillages: 5,
 						Points:      4,
 						Rank:        2,
-						Tribe: model.NullTribeMeta{
+						Tribe: model2.NullTribeMeta{
 							Valid: true,
-							Tribe: model.TribeMeta{
+							Tribe: model2.TribeMeta{
 								ID:   1234,
 								Name: "name 997",
 								Tag:  "tag 997",
@@ -189,7 +189,7 @@ func TestPlayer_list(t *testing.T) {
 						NumVillages: 2,
 						Points:      3,
 						Rank:        4,
-						Tribe: model.NullTribeMeta{
+						Tribe: model2.NullTribeMeta{
 							Valid: false,
 						},
 						CreatedAt: now,
@@ -200,7 +200,7 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "OK: deleted=true,limit=1,offset=1,sort=[deletedAt:desc]",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				playerSvc.ListCalls(func(_ context.Context, params domain.ListPlayersParams) ([]domain.Player, int64, error) {
@@ -265,9 +265,9 @@ func TestPlayer_list(t *testing.T) {
 				"sort":    []string{"deletedAt:desc"},
 			},
 			expectedStatus: 200,
-			target:         &model.ListPlayersResp{},
-			expectedResponse: &model.ListPlayersResp{
-				Data: []model.Player{
+			target:         &model2.ListPlayersResp{},
+			expectedResponse: &model2.ListPlayersResp{
+				Data: []model2.Player{
 					{
 						RankAtt:     1,
 						ScoreAtt:    2,
@@ -282,11 +282,11 @@ func TestPlayer_list(t *testing.T) {
 						NumVillages: 2,
 						Points:      3,
 						Rank:        4,
-						Tribe: model.NullTribeMeta{
+						Tribe: model2.NullTribeMeta{
 							Valid: false,
 						},
 						CreatedAt: now,
-						DeletedAt: model.NullTime{
+						DeletedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
@@ -297,7 +297,7 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "OK: limit=1,sort=[id:asc,points:desc,scoreTotal:asc]",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				playerSvc.ListCalls(func(_ context.Context, params domain.ListPlayersParams) ([]domain.Player, int64, error) {
@@ -362,9 +362,9 @@ func TestPlayer_list(t *testing.T) {
 				"sort":  []string{"id:asc", "points:desc", "scoreTotal:asc"},
 			},
 			expectedStatus: 200,
-			target:         &model.ListPlayersResp{},
-			expectedResponse: &model.ListPlayersResp{
-				Data: []model.Player{
+			target:         &model2.ListPlayersResp{},
+			expectedResponse: &model2.ListPlayersResp{
+				Data: []model2.Player{
 					{
 						RankAtt:     1,
 						ScoreAtt:    2,
@@ -379,11 +379,11 @@ func TestPlayer_list(t *testing.T) {
 						NumVillages: 2,
 						Points:      3,
 						Rank:        4,
-						Tribe: model.NullTribeMeta{
+						Tribe: model2.NullTribeMeta{
 							Valid: false,
 						},
 						CreatedAt: now,
-						DeletedAt: model.NullTime{
+						DeletedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
@@ -394,7 +394,7 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: limit is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -404,9 +404,9 @@ func TestPlayer_list(t *testing.T) {
 				"limit": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "limit: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -415,7 +415,7 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: offset is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -425,9 +425,9 @@ func TestPlayer_list(t *testing.T) {
 				"offset": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "offset: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -436,7 +436,7 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: deleted is not a valid boolean",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -446,9 +446,9 @@ func TestPlayer_list(t *testing.T) {
 				"deleted": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "deleted: strconv.ParseBool: parsing \"asd\": invalid syntax",
 				},
@@ -457,7 +457,7 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: sort - invalid format",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -467,9 +467,9 @@ func TestPlayer_list(t *testing.T) {
 				"sort": []string{"id:asc", "test"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "sort[1]: parsing \"test\": invalid syntax, expected field:direction",
 				},
@@ -478,7 +478,7 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: sort - unsupported field",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -488,9 +488,9 @@ func TestPlayer_list(t *testing.T) {
 				"sort": []string{"id:asc", "test:asc"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "sort[1]: unsupported sort by: \"test\"",
 				},
@@ -499,7 +499,7 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: sort - unsupported direction",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -509,9 +509,9 @@ func TestPlayer_list(t *testing.T) {
 				"sort": []string{"id:asc2"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "sort[0]: unsupported sort direction: \"asc2\"",
 				},
@@ -520,15 +520,15 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
 			},
 			versionCode:    version.Code + "2",
 			key:            server.Key,
 			expectedStatus: 404,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -537,16 +537,16 @@ func TestPlayer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: server not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
 			},
 			versionCode:    version.Code,
 			key:            server.Key + "2",
 			expectedStatus: 404,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
 				},
@@ -561,9 +561,9 @@ func TestPlayer_list(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
-			playerSvc := &mock.FakePlayerService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
+			playerSvc := &mock2.FakePlayerService{}
 			tt.setup(versionSvc, serverSvc, playerSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{
@@ -605,7 +605,7 @@ func TestPlayer_getByID(t *testing.T) {
 	}
 	tests := []struct {
 		name             string
-		setup            func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService)
+		setup            func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService)
 		versionCode      string
 		serverKey        string
 		id               string
@@ -615,7 +615,7 @@ func TestPlayer_getByID(t *testing.T) {
 	}{
 		{
 			name: "OK",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				playerSvc.GetByServerKeyAndIDReturns(domain.Player{
@@ -673,9 +673,9 @@ func TestPlayer_getByID(t *testing.T) {
 			serverKey:      server.Key,
 			id:             "997",
 			expectedStatus: http.StatusOK,
-			target:         &model.GetPlayerResp{},
-			expectedResponse: &model.GetPlayerResp{
-				Data: model.Player{
+			target:         &model2.GetPlayerResp{},
+			expectedResponse: &model2.GetPlayerResp{
+				Data: model2.Player{
 					ID:          997,
 					Name:        "name 997",
 					NumVillages: 5,
@@ -690,8 +690,8 @@ func TestPlayer_getByID(t *testing.T) {
 					RankTotal:   2,
 					ScoreTotal:  1,
 					CreatedAt:   now,
-					Tribe: model.NullTribeMeta{
-						Tribe: model.TribeMeta{
+					Tribe: model2.NullTribeMeta{
+						Tribe: model2.TribeMeta{
 							ID:   1234,
 							Name: "name 997",
 							Tag:  "tag 997",
@@ -703,7 +703,7 @@ func TestPlayer_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: player id is not a valid int64",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -711,9 +711,9 @@ func TestPlayer_getByID(t *testing.T) {
 			serverKey:      server.Key,
 			id:             "true",
 			expectedStatus: http.StatusBadRequest,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "playerId: strconv.ParseInt: parsing \"true\": invalid syntax",
 				},
@@ -721,16 +721,16 @@ func TestPlayer_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				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{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -738,7 +738,7 @@ func TestPlayer_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: server not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
 			},
@@ -746,9 +746,9 @@ func TestPlayer_getByID(t *testing.T) {
 			serverKey:      server.Key + "2",
 			id:             "1234",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
 				},
@@ -756,7 +756,7 @@ func TestPlayer_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: player not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, playerSvc *mock.FakePlayerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, playerSvc *mock2.FakePlayerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				playerSvc.GetByServerKeyAndIDReturns(domain.Player{}, domain.PlayerNotFoundError{ID: 12345551})
@@ -765,9 +765,9 @@ func TestPlayer_getByID(t *testing.T) {
 			serverKey:      server.Key,
 			id:             "12345551",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: "player (id=12345551) not found",
 				},
@@ -781,9 +781,9 @@ func TestPlayer_getByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
-			playerSvc := &mock.FakePlayerService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
+			playerSvc := &mock2.FakePlayerService{}
 			tt.setup(versionSvc, serverSvc, playerSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{

internal/router/rest/rest.go

@@ -6,16 +6,15 @@ import (
 	"net/http"
 	"strconv"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	httpSwagger "github.com/swaggo/http-swagger"
 
 	"github.com/go-chi/cors"
 
 	"github.com/go-chi/chi/v5"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
-
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	_ "gitea.dwysokinski.me/twhelp/core/internal/rest/internal/docs"
+	_ "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/docs"
 )
 
 //go:generate counterfeiter -generate

internal/router/rest/rest_test.go

@@ -8,8 +8,8 @@ import (
 	"testing"
 	"time"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/google/uuid"
 
 	"github.com/go-chi/chi/v5"
@@ -87,20 +87,20 @@ func TestSwagger(t *testing.T) {
 
 func doRequest(mux chi.Router, method, target string, body io.Reader) *http.Response {
 	rr := httptest.NewRecorder()
-	req := httptest.NewRequest(method, target, body)
-	mux.ServeHTTP(rr, req)
+	mux.ServeHTTP(rr, httptest.NewRequest(method, target, body))
 	return rr.Result()
 }
 
 func assertJSONResponse(tb testing.TB, resp *http.Response, expectedStatus int, expected any, target any) {
 	tb.Helper()
 
+	assert.Equal(tb, "application/json", resp.Header.Get("Content-Type"))
 	assert.Equal(tb, expectedStatus, resp.StatusCode)
 	assert.NoError(tb, json.NewDecoder(resp.Body).Decode(target))
 	opts := cmp.Options{
 		cmpopts.IgnoreUnexported(time.Time{}),
 	}
-	assert.True(tb, cmp.Equal(expected, target, opts...), cmp.Diff(expected, target, opts...))
+	assert.Empty(tb, cmp.Diff(expected, target, opts...))
 }
 
 func assertTotalCount(tb testing.TB, header http.Header, expected string) {

internal/router/rest/server.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"net/http"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 
 	"github.com/go-chi/chi/v5"
 

internal/router/rest/server_test.go

@@ -8,13 +8,12 @@ import (
 	"testing"
 	"time"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest"
+	mock2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/mock"
+	model2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/google/go-cmp/cmp"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest"
-
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/mock"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
 )
 
 func TestServer_list(t *testing.T) {
@@ -30,7 +29,7 @@ func TestServer_list(t *testing.T) {
 
 	tests := []struct {
 		name               string
-		setup              func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService)
+		setup              func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService)
 		versionCode        string
 		queryParams        url.Values
 		expectedStatus     int
@@ -40,7 +39,7 @@ func TestServer_list(t *testing.T) {
 	}{
 		{
 			name: "OK: without params",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.ListCalls(func(_ context.Context, params domain.ListServersParams) ([]domain.Server, int64, error) {
 					expectedParams := domain.ListServersParams{
@@ -108,9 +107,9 @@ func TestServer_list(t *testing.T) {
 			},
 			versionCode:    version.Code,
 			expectedStatus: 200,
-			target:         &model.ListServersResp{},
-			expectedResponse: &model.ListServersResp{
-				Data: []model.Server{
+			target:         &model2.ListServersResp{},
+			expectedResponse: &model2.ListServersResp{
+				Data: []model2.Server{
 					{
 						Key:                 "pl151",
 						URL:                 "https://pl151.plemiona.pl",
@@ -119,12 +118,12 @@ func TestServer_list(t *testing.T) {
 						NumTribes:           1235,
 						NumVillages:         1236,
 						CreatedAt:           now.Add(-20 * time.Hour),
-						PlayerDataUpdatedAt: model.NullTime{},
-						TribeDataUpdatedAt: model.NullTime{
+						PlayerDataUpdatedAt: model2.NullTime{},
+						TribeDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
-						VillageDataUpdatedAt: model.NullTime{
+						VillageDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now.Add(-5 * time.Hour),
 						},
@@ -137,15 +136,15 @@ func TestServer_list(t *testing.T) {
 						NumTribes:   2235,
 						NumVillages: 2236,
 						CreatedAt:   now.Add(-20 * time.Hour),
-						PlayerDataUpdatedAt: model.NullTime{
+						PlayerDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
-						TribeDataUpdatedAt: model.NullTime{
+						TribeDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
-						VillageDataUpdatedAt: model.NullTime{
+						VillageDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now.Add(-5 * time.Hour),
 						},
@@ -156,7 +155,7 @@ func TestServer_list(t *testing.T) {
 		},
 		{
 			name: "OK: open=true,limit=500,offset=25",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.ListCalls(func(_ context.Context, params domain.ListServersParams) ([]domain.Server, int64, error) {
 					expectedParams := domain.ListServersParams{
@@ -229,9 +228,9 @@ func TestServer_list(t *testing.T) {
 				"limit":  []string{"500"},
 			},
 			expectedStatus: 200,
-			target:         &model.ListServersResp{},
-			expectedResponse: &model.ListServersResp{
-				Data: []model.Server{
+			target:         &model2.ListServersResp{},
+			expectedResponse: &model2.ListServersResp{
+				Data: []model2.Server{
 					{
 						Key:                 "pl151",
 						URL:                 "https://pl151.plemiona.pl",
@@ -240,12 +239,12 @@ func TestServer_list(t *testing.T) {
 						NumTribes:           1235,
 						NumVillages:         1236,
 						CreatedAt:           now.Add(-20 * time.Hour),
-						PlayerDataUpdatedAt: model.NullTime{},
-						TribeDataUpdatedAt: model.NullTime{
+						PlayerDataUpdatedAt: model2.NullTime{},
+						TribeDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
-						VillageDataUpdatedAt: model.NullTime{
+						VillageDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now.Add(-5 * time.Hour),
 						},
@@ -258,15 +257,15 @@ func TestServer_list(t *testing.T) {
 						NumTribes:   2235,
 						NumVillages: 2236,
 						CreatedAt:   now.Add(-20 * time.Hour),
-						PlayerDataUpdatedAt: model.NullTime{
+						PlayerDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
-						TribeDataUpdatedAt: model.NullTime{
+						TribeDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
-						VillageDataUpdatedAt: model.NullTime{
+						VillageDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now.Add(-5 * time.Hour),
 						},
@@ -277,7 +276,7 @@ func TestServer_list(t *testing.T) {
 		},
 		{
 			name: "OK: open=false,limit=1",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.ListCalls(func(_ context.Context, params domain.ListServersParams) ([]domain.Server, int64, error) {
 					expectedParams := domain.ListServersParams{
@@ -332,9 +331,9 @@ func TestServer_list(t *testing.T) {
 				"limit": []string{"1"},
 			},
 			expectedStatus: 200,
-			target:         &model.ListServersResp{},
-			expectedResponse: &model.ListServersResp{
-				Data: []model.Server{
+			target:         &model2.ListServersResp{},
+			expectedResponse: &model2.ListServersResp{
+				Data: []model2.Server{
 					{
 						Key:                 "pl151",
 						URL:                 "https://pl151.plemiona.pl",
@@ -343,12 +342,12 @@ func TestServer_list(t *testing.T) {
 						NumTribes:           1235,
 						NumVillages:         1236,
 						CreatedAt:           now.Add(-20 * time.Hour),
-						PlayerDataUpdatedAt: model.NullTime{},
-						TribeDataUpdatedAt: model.NullTime{
+						PlayerDataUpdatedAt: model2.NullTime{},
+						TribeDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
-						VillageDataUpdatedAt: model.NullTime{
+						VillageDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now.Add(-5 * time.Hour),
 						},
@@ -359,7 +358,7 @@ func TestServer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: limit is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 			},
 			versionCode: version.Code,
@@ -367,9 +366,9 @@ func TestServer_list(t *testing.T) {
 				"limit": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "limit: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -378,7 +377,7 @@ func TestServer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: offset is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 			},
 			versionCode: version.Code,
@@ -386,9 +385,9 @@ func TestServer_list(t *testing.T) {
 				"offset": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "offset: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -397,7 +396,7 @@ func TestServer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: open is not a valid boolean",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 			},
 			versionCode: version.Code,
@@ -405,9 +404,9 @@ func TestServer_list(t *testing.T) {
 				"open": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "open: strconv.ParseBool: parsing \"asd\": invalid syntax",
 				},
@@ -416,14 +415,14 @@ func TestServer_list(t *testing.T) {
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
 			},
 			versionCode:    version.Code + "2",
 			expectedStatus: 404,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -438,8 +437,8 @@ func TestServer_list(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
 			tt.setup(versionSvc, serverSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{
@@ -468,7 +467,7 @@ func TestServer_getByKey(t *testing.T) {
 	}
 	tests := []struct {
 		name             string
-		setup            func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService)
+		setup            func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService)
 		versionCode      string
 		key              string
 		expectedStatus   int
@@ -477,7 +476,7 @@ func TestServer_getByKey(t *testing.T) {
 	}{
 		{
 			name: "OK",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{
 					Key:         "pl151",
@@ -506,10 +505,10 @@ func TestServer_getByKey(t *testing.T) {
 			versionCode:    version.Code,
 			key:            "pl151",
 			expectedStatus: http.StatusOK,
-			target:         &model.GetServerResp{},
-			expectedResponse: &model.GetServerResp{
-				Data: model.ExtendedServer{
-					Server: model.Server{
+			target:         &model2.GetServerResp{},
+			expectedResponse: &model2.GetServerResp{
+				Data: model2.ExtendedServer{
+					Server: model2.Server{
 						Key:                 "pl151",
 						URL:                 "https://pl151.plemiona.pl",
 						Open:                false,
@@ -517,39 +516,39 @@ func TestServer_getByKey(t *testing.T) {
 						NumTribes:           1235,
 						NumVillages:         1236,
 						CreatedAt:           now.Add(-20 * time.Hour),
-						PlayerDataUpdatedAt: model.NullTime{},
-						TribeDataUpdatedAt: model.NullTime{
+						PlayerDataUpdatedAt: model2.NullTime{},
+						TribeDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
-						VillageDataUpdatedAt: model.NullTime{
+						VillageDataUpdatedAt: model2.NullTime{
 							Valid: true,
 							Time:  now.Add(-5 * time.Hour),
 						},
 					},
-					Config: model.ServerConfig{
+					Config: model2.ServerConfig{
 						Speed: 0.25,
 					},
-					BuildingInfo: model.BuildingInfo{
-						Snob: model.Building{BuildTime: 1234.444},
+					BuildingInfo: model2.BuildingInfo{
+						Snob: model2.Building{BuildTime: 1234.444},
 					},
-					UnitInfo: model.UnitInfo{
-						Sword: model.Unit{BuildTime: 1111122.2222},
+					UnitInfo: model2.UnitInfo{
+						Sword: model2.Unit{BuildTime: 1111122.2222},
 					},
 				},
 			},
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
 			},
 			versionCode:    version.Code + "2",
 			key:            "pl151",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -557,16 +556,16 @@ func TestServer_getByKey(t *testing.T) {
 		},
 		{
 			name: "ERR: server not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: "pl1512"})
 			},
 			versionCode:    version.Code,
 			key:            "pl1512",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: "server (key=pl1512) not found",
 				},
@@ -580,8 +579,8 @@ func TestServer_getByKey(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
 			tt.setup(versionSvc, serverSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{

internal/router/rest/tribe.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"net/http"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/go-chi/chi/v5"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"

internal/router/rest/tribe_test.go

@@ -8,12 +8,12 @@ import (
 	"testing"
 	"time"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest"
+	mock2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/mock"
+	model2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/google/go-cmp/cmp"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/mock"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
 )
 
 func TestTribe_list(t *testing.T) {
@@ -48,7 +48,7 @@ func TestTribe_list(t *testing.T) {
 
 	tests := []struct {
 		name               string
-		setup              func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService)
+		setup              func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService)
 		versionCode        string
 		key                string
 		queryParams        url.Values
@@ -59,7 +59,7 @@ func TestTribe_list(t *testing.T) {
 	}{
 		{
 			name: "OK: without params",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				tribeSvc.ListCalls(func(_ context.Context, params domain.ListTribesParams) ([]domain.Tribe, int64, error) {
@@ -139,9 +139,9 @@ func TestTribe_list(t *testing.T) {
 			versionCode:    version.Code,
 			key:            server.Key,
 			expectedStatus: 200,
-			target:         &model.ListTribesResp{},
-			expectedResponse: &model.ListTribesResp{
-				Data: []model.Tribe{
+			target:         &model2.ListTribesResp{},
+			expectedResponse: &model2.ListTribesResp{
+				Data: []model2.Tribe{
 					{
 						RankAtt:     8,
 						ScoreAtt:    7,
@@ -177,7 +177,7 @@ func TestTribe_list(t *testing.T) {
 						Rank:        5,
 						Dominance:   12.55,
 						CreatedAt:   now.Add(-5000 * time.Hour),
-						DeletedAt: model.NullTime{
+						DeletedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
@@ -188,7 +188,7 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "OK: sort=[id:asc,scoreDef:desc,scoreTotal:asc]",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				tribeSvc.ListCalls(func(_ context.Context, params domain.ListTribesParams) ([]domain.Tribe, int64, error) {
@@ -285,9 +285,9 @@ func TestTribe_list(t *testing.T) {
 				"sort": []string{"id:asc", "scoreDef:desc", "scoreTotal:asc"},
 			},
 			expectedStatus: 200,
-			target:         &model.ListTribesResp{},
-			expectedResponse: &model.ListTribesResp{
-				Data: []model.Tribe{
+			target:         &model2.ListTribesResp{},
+			expectedResponse: &model2.ListTribesResp{
+				Data: []model2.Tribe{
 					{
 						RankAtt:     8,
 						ScoreAtt:    7,
@@ -323,7 +323,7 @@ func TestTribe_list(t *testing.T) {
 						Rank:        5,
 						Dominance:   12.55,
 						CreatedAt:   now.Add(-5000 * time.Hour),
-						DeletedAt: model.NullTime{
+						DeletedAt: model2.NullTime{
 							Valid: true,
 							Time:  now,
 						},
@@ -334,7 +334,7 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "OK: deleted=false,limit=1,offset=15",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				tribeSvc.ListCalls(func(_ context.Context, params domain.ListTribesParams) ([]domain.Tribe, int64, error) {
@@ -393,9 +393,9 @@ func TestTribe_list(t *testing.T) {
 				"deleted": []string{"false"},
 			},
 			expectedStatus: 200,
-			target:         &model.ListTribesResp{},
-			expectedResponse: &model.ListTribesResp{
-				Data: []model.Tribe{
+			target:         &model2.ListTribesResp{},
+			expectedResponse: &model2.ListTribesResp{
+				Data: []model2.Tribe{
 					{
 						RankAtt:     8,
 						ScoreAtt:    7,
@@ -420,7 +420,7 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "ERR: limit is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -430,9 +430,9 @@ func TestTribe_list(t *testing.T) {
 				"limit": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "limit: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -441,7 +441,7 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "ERR: offset is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -451,9 +451,9 @@ func TestTribe_list(t *testing.T) {
 				"offset": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "offset: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -462,7 +462,7 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "ERR: deleted is not a valid boolean",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -472,9 +472,9 @@ func TestTribe_list(t *testing.T) {
 				"deleted": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "deleted: strconv.ParseBool: parsing \"asd\": invalid syntax",
 				},
@@ -483,7 +483,7 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "ERR: sort - invalid format",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -493,9 +493,9 @@ func TestTribe_list(t *testing.T) {
 				"sort": []string{"id:asc", "test"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "sort[1]: parsing \"test\": invalid syntax, expected field:direction",
 				},
@@ -504,7 +504,7 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "ERR: sort - unsupported field",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -514,9 +514,9 @@ func TestTribe_list(t *testing.T) {
 				"sort": []string{"id:asc", "test:asc"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "sort[1]: unsupported sort by: \"test\"",
 				},
@@ -525,7 +525,7 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "ERR: sort - unsupported direction",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -535,9 +535,9 @@ func TestTribe_list(t *testing.T) {
 				"sort": []string{"id:asc2"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "sort[0]: unsupported sort direction: \"asc2\"",
 				},
@@ -546,15 +546,15 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
 			},
 			versionCode:    version.Code + "2",
 			key:            server.Key,
 			expectedStatus: 404,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -563,16 +563,16 @@ func TestTribe_list(t *testing.T) {
 		},
 		{
 			name: "ERR: server not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
 			},
 			versionCode:    version.Code,
 			key:            server.Key + "2",
 			expectedStatus: 404,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
 				},
@@ -587,9 +587,9 @@ func TestTribe_list(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
-			tribeSvc := &mock.FakeTribeService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
+			tribeSvc := &mock2.FakeTribeService{}
 			tt.setup(versionSvc, serverSvc, tribeSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{
@@ -631,7 +631,7 @@ func TestTribe_getByID(t *testing.T) {
 	}
 	tests := []struct {
 		name             string
-		setup            func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService)
+		setup            func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService)
 		versionCode      string
 		serverKey        string
 		id               string
@@ -641,7 +641,7 @@ func TestTribe_getByID(t *testing.T) {
 	}{
 		{
 			name: "OK",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				tribeSvc.GetByServerKeyAndIDReturns(domain.Tribe{
@@ -674,9 +674,9 @@ func TestTribe_getByID(t *testing.T) {
 			serverKey:      server.Key,
 			id:             "997",
 			expectedStatus: http.StatusOK,
-			target:         &model.GetTribeResp{},
-			expectedResponse: &model.GetTribeResp{
-				Data: model.Tribe{
+			target:         &model2.GetTribeResp{},
+			expectedResponse: &model2.GetTribeResp{
+				Data: model2.Tribe{
 					RankAtt:     8,
 					ScoreAtt:    7,
 					RankDef:     6,
@@ -698,7 +698,7 @@ func TestTribe_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: tribe id is not a valid int64",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -706,9 +706,9 @@ func TestTribe_getByID(t *testing.T) {
 			serverKey:      server.Key,
 			id:             "true",
 			expectedStatus: http.StatusBadRequest,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "tribeId: strconv.ParseInt: parsing \"true\": invalid syntax",
 				},
@@ -716,16 +716,16 @@ func TestTribe_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.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{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -733,7 +733,7 @@ func TestTribe_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: server not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
 			},
@@ -741,9 +741,9 @@ func TestTribe_getByID(t *testing.T) {
 			serverKey:      server.Key + "2",
 			id:             "1234",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
 				},
@@ -751,7 +751,7 @@ func TestTribe_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: tribe not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				tribeSvc.GetByServerKeyAndIDReturns(domain.Tribe{}, domain.TribeNotFoundError{ID: 12345551})
@@ -760,9 +760,9 @@ func TestTribe_getByID(t *testing.T) {
 			serverKey:      server.Key,
 			id:             "12345551",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: "tribe (id=12345551) not found",
 				},
@@ -776,9 +776,9 @@ func TestTribe_getByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
-			tribeSvc := &mock.FakeTribeService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
+			tribeSvc := &mock2.FakeTribeService{}
 			tt.setup(versionSvc, serverSvc, tribeSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{
@@ -819,7 +819,7 @@ func TestTribe_getByTag(t *testing.T) {
 	}
 	tests := []struct {
 		name             string
-		setup            func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService)
+		setup            func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService)
 		versionCode      string
 		serverKey        string
 		tag              string
@@ -829,7 +829,7 @@ func TestTribe_getByTag(t *testing.T) {
 	}{
 		{
 			name: "OK",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				tribeSvc.GetByServerKeyAndTagReturns(domain.Tribe{
@@ -862,9 +862,9 @@ func TestTribe_getByTag(t *testing.T) {
 			serverKey:      server.Key,
 			tag:            "*CSA*",
 			expectedStatus: http.StatusOK,
-			target:         &model.GetTribeResp{},
-			expectedResponse: &model.GetTribeResp{
-				Data: model.Tribe{
+			target:         &model2.GetTribeResp{},
+			expectedResponse: &model2.GetTribeResp{
+				Data: model2.Tribe{
 					RankAtt:     8,
 					ScoreAtt:    7,
 					RankDef:     6,
@@ -886,16 +886,16 @@ func TestTribe_getByTag(t *testing.T) {
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
 			},
 			versionCode:    version.Code + "2",
 			serverKey:      "pl151",
 			tag:            "*CSA*",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -903,7 +903,7 @@ func TestTribe_getByTag(t *testing.T) {
 		},
 		{
 			name: "ERR: server not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
 			},
@@ -911,9 +911,9 @@ func TestTribe_getByTag(t *testing.T) {
 			serverKey:      server.Key + "2",
 			tag:            "*CSA*",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: "server (key=pl1512) not found",
 				},
@@ -921,7 +921,7 @@ func TestTribe_getByTag(t *testing.T) {
 		},
 		{
 			name: "ERR: tribe not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, tribeSvc *mock.FakeTribeService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, tribeSvc *mock2.FakeTribeService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				tribeSvc.GetByServerKeyAndTagReturns(domain.Tribe{}, domain.TribeNotFoundError{Tag: "*CSA*"})
@@ -930,9 +930,9 @@ func TestTribe_getByTag(t *testing.T) {
 			serverKey:      server.Key,
 			tag:            "*CSA*",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: "tribe (tag=*CSA*) not found",
 				},
@@ -946,9 +946,9 @@ func TestTribe_getByTag(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
-			tribeSvc := &mock.FakeTribeService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
+			tribeSvc := &mock2.FakeTribeService{}
 			tt.setup(versionSvc, serverSvc, tribeSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{

internal/router/rest/version.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"net/http"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 
 	"github.com/go-chi/chi/v5"
 

internal/router/rest/version_test.go

@@ -4,11 +4,11 @@ import (
 	"net/http"
 	"testing"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/mock"
+	model2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/mock"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
 )
 
 func TestVersionHandler_list(t *testing.T) {
@@ -48,9 +48,9 @@ func TestVersionHandler_list(t *testing.T) {
 				svc.ListReturns(versions, int64(len(versions)), nil)
 			},
 			expectedStatus: http.StatusOK,
-			target:         &model.ListVersionsResp{},
-			expectedResponse: &model.ListVersionsResp{
-				Data: []model.Version{
+			target:         &model2.ListVersionsResp{},
+			expectedResponse: &model2.ListVersionsResp{
+				Data: []model2.Version{
 					{
 						Code:     "pl",
 						Name:     "Poland",
@@ -119,9 +119,9 @@ func TestVersion_getByCode(t *testing.T) {
 			},
 			code:           "pl",
 			expectedStatus: http.StatusOK,
-			target:         &model.GetVersionResp{},
-			expectedResponse: &model.GetVersionResp{
-				Data: model.Version{
+			target:         &model2.GetVersionResp{},
+			expectedResponse: &model2.GetVersionResp{
+				Data: model2.Version{
 					Code:     "pl",
 					Name:     "Poland",
 					Host:     "plemiona.pl",
@@ -136,9 +136,9 @@ func TestVersion_getByCode(t *testing.T) {
 			},
 			code:           "pl2",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: "version (code=pl2) not found",
 				},

internal/router/rest/village.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"net/http"
 
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/go-chi/chi/v5"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"

internal/router/rest/village_test.go

@@ -8,12 +8,12 @@ import (
 	"testing"
 	"time"
 
+	"gitea.dwysokinski.me/twhelp/core/internal/router/rest"
+	mock2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/mock"
+	model2 "gitea.dwysokinski.me/twhelp/core/internal/router/rest/internal/model"
 	"github.com/google/go-cmp/cmp"
 
 	"gitea.dwysokinski.me/twhelp/core/internal/domain"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/mock"
-	"gitea.dwysokinski.me/twhelp/core/internal/rest/internal/model"
 )
 
 func TestVillage_list(t *testing.T) {
@@ -36,7 +36,7 @@ func TestVillage_list(t *testing.T) {
 
 	tests := []struct {
 		name               string
-		setup              func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService)
+		setup              func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService)
 		versionCode        string
 		key                string
 		queryParams        url.Values
@@ -47,7 +47,7 @@ func TestVillage_list(t *testing.T) {
 	}{
 		{
 			name: "OK: without params",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				villageSvc.ListCalls(func(_ context.Context, params domain.ListVillagesParams) ([]domain.Village, int64, error) {
@@ -156,9 +156,9 @@ func TestVillage_list(t *testing.T) {
 			versionCode:    version.Code,
 			key:            server.Key,
 			expectedStatus: 200,
-			target:         &model.ListVillagesResp{},
-			expectedResponse: &model.ListVillagesResp{
-				Data: []model.Village{
+			target:         &model2.ListVillagesResp{},
+			expectedResponse: &model2.ListVillagesResp{
+				Data: []model2.Village{
 					{
 						ID:        1234,
 						Name:      "name",
@@ -168,14 +168,14 @@ func TestVillage_list(t *testing.T) {
 						Y:         3,
 						Continent: "K11",
 						Bonus:     1,
-						Player: model.NullPlayerMeta{
+						Player: model2.NullPlayerMeta{
 							Valid: true,
-							Player: model.PlayerMeta{
+							Player: model2.PlayerMeta{
 								ID:   997,
 								Name: "name 997",
-								Tribe: model.NullTribeMeta{
+								Tribe: model2.NullTribeMeta{
 									Valid: true,
-									Tribe: model.TribeMeta{
+									Tribe: model2.TribeMeta{
 										ID:   1234,
 										Name: "name 997",
 										Tag:  "tag 997",
@@ -194,9 +194,9 @@ func TestVillage_list(t *testing.T) {
 						Y:         22,
 						Continent: "K22",
 						Bonus:     0,
-						Player: model.NullPlayerMeta{
+						Player: model2.NullPlayerMeta{
 							Valid:  false,
-							Player: model.PlayerMeta{},
+							Player: model2.PlayerMeta{},
 						},
 						CreatedAt: now,
 					},
@@ -206,7 +206,7 @@ func TestVillage_list(t *testing.T) {
 		},
 		{
 			name: "OK: limit=1, offset=15",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				villageSvc.ListCalls(func(_ context.Context, params domain.ListVillagesParams) ([]domain.Village, int64, error) {
@@ -252,9 +252,9 @@ func TestVillage_list(t *testing.T) {
 				"offset": []string{"15"},
 			},
 			expectedStatus: 200,
-			target:         &model.ListVillagesResp{},
-			expectedResponse: &model.ListVillagesResp{
-				Data: []model.Village{
+			target:         &model2.ListVillagesResp{},
+			expectedResponse: &model2.ListVillagesResp{
+				Data: []model2.Village{
 					{
 						ID:        12345,
 						Name:      "name 2",
@@ -264,9 +264,9 @@ func TestVillage_list(t *testing.T) {
 						Y:         22,
 						Continent: "K22",
 						Bonus:     0,
-						Player: model.NullPlayerMeta{
+						Player: model2.NullPlayerMeta{
 							Valid:  false,
-							Player: model.PlayerMeta{},
+							Player: model2.PlayerMeta{},
 						},
 						CreatedAt: now,
 					},
@@ -276,7 +276,7 @@ func TestVillage_list(t *testing.T) {
 		},
 		{
 			name: "ERR: limit is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -286,9 +286,9 @@ func TestVillage_list(t *testing.T) {
 				"limit": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "limit: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -297,7 +297,7 @@ func TestVillage_list(t *testing.T) {
 		},
 		{
 			name: "ERR: offset is not a valid int32",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -307,9 +307,9 @@ func TestVillage_list(t *testing.T) {
 				"offset": []string{"asd"},
 			},
 			expectedStatus: 400,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "offset: strconv.ParseInt: parsing \"asd\": invalid syntax",
 				},
@@ -318,15 +318,15 @@ func TestVillage_list(t *testing.T) {
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(domain.Version{}, domain.VersionNotFoundError{VerCode: version.Code + "2"})
 			},
 			versionCode:    version.Code + "2",
 			key:            server.Key,
 			expectedStatus: 404,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -335,16 +335,16 @@ func TestVillage_list(t *testing.T) {
 		},
 		{
 			name: "ERR: server not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
 			},
 			versionCode:    version.Code,
 			key:            server.Key + "2",
 			expectedStatus: 404,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
 				},
@@ -359,9 +359,9 @@ func TestVillage_list(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
-			villageSvc := &mock.FakeVillageService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
+			villageSvc := &mock2.FakeVillageService{}
 			tt.setup(versionSvc, serverSvc, villageSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{
@@ -403,7 +403,7 @@ func TestVillage_getByID(t *testing.T) {
 	}
 	tests := []struct {
 		name             string
-		setup            func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService)
+		setup            func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService)
 		versionCode      string
 		serverKey        string
 		id               string
@@ -413,7 +413,7 @@ func TestVillage_getByID(t *testing.T) {
 	}{
 		{
 			name: "OK",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				villageSvc.GetByServerKeyAndIDReturns(domain.Village{
@@ -488,9 +488,9 @@ func TestVillage_getByID(t *testing.T) {
 			serverKey:      server.Key,
 			id:             "1234",
 			expectedStatus: http.StatusOK,
-			target:         &model.GetVillageResp{},
-			expectedResponse: &model.GetVillageResp{
-				Data: model.Village{
+			target:         &model2.GetVillageResp{},
+			expectedResponse: &model2.GetVillageResp{
+				Data: model2.Village{
 					ID:        1234,
 					Name:      "name",
 					FullName:  "name (2|3) K11",
@@ -499,14 +499,14 @@ func TestVillage_getByID(t *testing.T) {
 					Y:         3,
 					Continent: "K11",
 					Bonus:     1,
-					Player: model.NullPlayerMeta{
+					Player: model2.NullPlayerMeta{
 						Valid: true,
-						Player: model.PlayerMeta{
+						Player: model2.PlayerMeta{
 							ID:   997,
 							Name: "name 997",
-							Tribe: model.NullTribeMeta{
+							Tribe: model2.NullTribeMeta{
 								Valid: true,
-								Tribe: model.TribeMeta{
+								Tribe: model2.TribeMeta{
 									ID:   1234,
 									Name: "name 997",
 									Tag:  "tag 997",
@@ -520,7 +520,7 @@ func TestVillage_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: village id is not a valid int64",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 			},
@@ -528,9 +528,9 @@ func TestVillage_getByID(t *testing.T) {
 			serverKey:      server.Key,
 			id:             "true",
 			expectedStatus: http.StatusBadRequest,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeValidationError.String(),
 					Message: "villageId: strconv.ParseInt: parsing \"true\": invalid syntax",
 				},
@@ -538,16 +538,16 @@ func TestVillage_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: version not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				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{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("version (code=%s) not found", version.Code+"2"),
 				},
@@ -555,7 +555,7 @@ func TestVillage_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: server not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(domain.Server{}, domain.ServerNotFoundError{Key: server.Key + "2"})
 			},
@@ -563,9 +563,9 @@ func TestVillage_getByID(t *testing.T) {
 			serverKey:      server.Key + "2",
 			id:             "1234",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: fmt.Sprintf("server (key=%s) not found", server.Key+"2"),
 				},
@@ -573,7 +573,7 @@ func TestVillage_getByID(t *testing.T) {
 		},
 		{
 			name: "ERR: village not found",
-			setup: func(versionSvc *mock.FakeVersionService, serverSvc *mock.FakeServerService, villageSvc *mock.FakeVillageService) {
+			setup: func(versionSvc *mock2.FakeVersionService, serverSvc *mock2.FakeServerService, villageSvc *mock2.FakeVillageService) {
 				versionSvc.GetByCodeReturns(version, nil)
 				serverSvc.GetNormalByVersionCodeAndKeyReturns(server, nil)
 				villageSvc.GetByServerKeyAndIDReturns(domain.Village{}, domain.VillageNotFoundError{ID: 12345551})
@@ -582,9 +582,9 @@ func TestVillage_getByID(t *testing.T) {
 			serverKey:      server.Key,
 			id:             "12345551",
 			expectedStatus: http.StatusNotFound,
-			target:         &model.ErrorResp{},
-			expectedResponse: &model.ErrorResp{
-				Error: model.APIError{
+			target:         &model2.ErrorResp{},
+			expectedResponse: &model2.ErrorResp{
+				Error: model2.APIError{
 					Code:    domain.ErrorCodeEntityNotFound.String(),
 					Message: "village (id=12345551) not found",
 				},
@@ -598,9 +598,9 @@ func TestVillage_getByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			versionSvc := &mock.FakeVersionService{}
-			serverSvc := &mock.FakeServerService{}
-			villageSvc := &mock.FakeVillageService{}
+			versionSvc := &mock2.FakeVersionService{}
+			serverSvc := &mock2.FakeServerService{}
+			villageSvc := &mock2.FakeVillageService{}
 			tt.setup(versionSvc, serverSvc, villageSvc)
 
 			router := rest.NewRouter(rest.RouterConfig{

k8s/base/api.yml

@@ -34,15 +34,16 @@ spec:
               value: "false"
           livenessProbe:
             httpGet:
-              path: /health
+              path: /_meta/livez
               port: container-port
             initialDelaySeconds: 5
             periodSeconds: 5
           readinessProbe:
-            tcpSocket:
+            httpGet:
+              path: /_meta/readyz
               port: container-port
             initialDelaySeconds: 5
-            periodSeconds: 5
+            periodSeconds: 10
 ---
 apiVersion: v1
 kind: Service