Merge pull request #212 from o-ga09/fix/ci-lint-fail-on-error

o-ga09 · web-flow · commit 8cb0b508aa95 · 2026-04-08T21:26:30.000+09:00
fix: リンターエラー時にCIが失敗するよう修正
diff --git a/.github/workflows/lint_and_test.yml b/.github/workflows/lint_and_test.yml
@@ -9,27 +9,27 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
       - name: golangci-lint
-        uses: reviewdog/action-golangci-lint@v2
+        uses: golangci/golangci-lint-action@v7
         with:
-          golangci_lint_version: v2.4.0
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          workdir: ./
-          golangci_lint_flags: "--timeout=5m --config=./.golangci.yaml ./..."
-          fail_on_error: true
-          reporter: "github-pr-review"
+          version: v2.4.0
+          args: "--timeout=5m --config=./.golangci.yaml ./..."
           
   test:
     name: test
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - name: Set up Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.25
+          go-version-file: go.mod
       
       - name: run Docker
         run: |
diff --git a/cmd/api/main.go b/cmd/api/main.go
@@ -35,8 +35,8 @@ func main() {
 	defer func() {
 		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
-		if err := shutdown(shutdownCtx); err != nil {
-			panic(err)
+		if shutdownErr := shutdown(shutdownCtx); shutdownErr != nil {
+			panic(shutdownErr)
 		}
 	}()
 
@@ -48,8 +48,8 @@ func main() {
 	defer func() {
 		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
-		if err := shutdownMeter(shutdownCtx); err != nil {
-			panic(err)
+		if meterErr := shutdownMeter(shutdownCtx); meterErr != nil {
+			panic(meterErr)
 		}
 	}()
 
@@ -58,8 +58,8 @@ func main() {
 	metricsMux.Handle("/metrics", metricsHandler)
 	go func() {
 		addr := fmt.Sprintf(":%s", cfg.MetricsPort)
-		if err := http.ListenAndServe(addr, metricsMux); err != nil {
-			panic(err)
+		if listenErr := http.ListenAndServe(addr, metricsMux); listenErr != nil {
+			panic(listenErr)
 		}
 	}()
 
diff --git a/cmd/mcp/main.go b/cmd/mcp/main.go
@@ -147,7 +147,7 @@ func (m *MCPServer) getMonsters(ctx context.Context, _ *mcp.CallToolRequest, in
 		Limit:           limit,
 		Offset:          (offset - 1) * limit,
 	}
-	ctx = context.WithValue(ctx, "param", param)
+	ctx = context.WithValue(ctx, request.CtxParamKey, param)
 
 	result, err := m.monsterService.FetchMonsterDetail(ctx, "")
 	if err != nil {
diff --git a/cmd/migration/main.go b/cmd/migration/main.go
@@ -58,7 +58,7 @@ func main() {
 		if err != nil {
 			log.Fatal("failed to create file:", err)
 		}
-		defer f.Close()
+		defer func() { _ = f.Close() }()
 
 		f.WriteString("-- +migrate Up\n\n\n") //nolint:all
 		f.WriteString("-- +migrate Down\n\n") //nolint:all
@@ -109,7 +109,7 @@ func executeSeedFile(db *sql.DB, filePath string) error {
 	if err != nil {
 		return err
 	}
-	defer file.Close()
+	defer func() { _ = file.Close() }()
 
 	var queries []string
 	var currentQuery strings.Builder
@@ -133,8 +133,8 @@ func executeSeedFile(db *sql.DB, filePath string) error {
 		}
 	}
 
-	if err := scanner.Err(); err != nil {
-		return err
+	if scanErr := scanner.Err(); scanErr != nil {
+		return scanErr
 	}
 
 	// トランザクション内でクエリを実行
diff --git a/internal/agent/server.go b/internal/agent/server.go
@@ -109,7 +109,7 @@ func NewServer(cfg *Config) (*Server, error) {
 	mux.HandleFunc("/v1/agent/health", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
-		w.Write([]byte(`{"status":"ok"}`))
+		_, _ = w.Write([]byte(`{"status":"ok"}`))
 	})
 
 	return &Server{
diff --git a/internal/agent/tools.go b/internal/agent/tools.go
@@ -209,7 +209,7 @@ func (m *MonHunTools) getMonsters(ctx context.Context, args GetMonstersInput) (s
 		Limit:           limit,
 		Offset:          calculatedOffset,
 	}
-	ctx = context.WithValue(ctx, "param", param)
+	ctx = context.WithValue(ctx, request.CtxParamKey, param)
 
 	monsters, err := m.monsterService.FetchMonsterDetail(ctx, "")
 	if err != nil {
diff --git a/internal/controller/monster/handler.go b/internal/controller/monster/handler.go
@@ -17,6 +17,11 @@ import (
 
 const YOUTUBE_URL = "https://www.youtube.com/watch?v="
 
+type ctxParamKey string
+
+// CtxParamKey はリクエストパラメータをコンテキストに格納する際のキー
+const CtxParamKey ctxParamKey = "param"
+
 type MonsterHandler struct {
 	monsterService monsters.IMonsterService
 }
@@ -65,7 +70,7 @@ func (m *MonsterHandler) GetAll(c *gin.Context) {
 	if ok {
 		id = ""
 	}
-	ctx = context.WithValue(ctx, "param", param)
+	ctx = context.WithValue(ctx, CtxParamKey, param)
 	result, err := m.monsterService.FetchMonsterDetail(ctx, id)
 
 	if err == gorm.ErrRecordNotFound {
diff --git a/internal/database/mysql/armorQueryService_test.go b/internal/database/mysql/armorQueryService_test.go
@@ -63,22 +63,22 @@ func createTestArmors(t *testing.T, ctx context.Context) []*Armor {
 		{ArmorId: "armor003", ItemId: "ITM0019", ItemName: "リオレウスの鱗"},
 	}
 
-	db := CtxFromTestDB(ctx)
+	gormDB := CtxFromTestDB(ctx)
 
 	for _, armor := range testArmors {
-		if err := db.Create(armor).Error; err != nil {
+		if err := gormDB.Create(armor).Error; err != nil {
 			t.Fatalf("failed to create test armor: %v", err)
 		}
 	}
 
 	for _, skill := range testSkills {
-		if err := db.Create(skill).Error; err != nil {
+		if err := gormDB.Create(skill).Error; err != nil {
 			t.Fatalf("failed to create test armor skill: %v", err)
 		}
 	}
 
 	for _, item := range testRequiredItems {
-		if err := db.Create(item).Error; err != nil {
+		if err := gormDB.Create(item).Error; err != nil {
 			t.Fatalf("failed to create test armor required item: %v", err)
 		}
 	}
diff --git a/internal/database/mysql/db_connect.go b/internal/database/mysql/db_connect.go
@@ -41,8 +41,8 @@ func New(ctx context.Context) context.Context {
 			Logger: logger.Default.LogMode(logger.Info),
 		})
 		if err == nil {
-			if err := db.Use(tracing.NewPlugin()); err != nil {
-				log.Printf("failed to use tracing plugin: %v", err)
+			if pluginErr := db.Use(tracing.NewPlugin()); pluginErr != nil {
+				log.Printf("failed to use tracing plugin: %v", pluginErr)
 			}
 		} else {
 			ctx = connect(ctx, dialector)
diff --git a/internal/database/mysql/health.go b/internal/database/mysql/health.go
@@ -12,11 +12,11 @@ func NewHealthRepository() *healthRepository {
 }
 
 func (h *healthRepository) GetStatus(ctx context.Context) error {
-	db := CtxFromDB(ctx)
-	if db == nil {
+	gormDB := CtxFromDB(ctx)
+	if gormDB == nil {
 		return errors.New("database connection not found")
 	}
-	conn, err := db.DB()
+	conn, err := gormDB.DB()
 	if err != nil {
 		return err
 	}
diff --git a/internal/database/mysql/itemQueryService.go b/internal/database/mysql/itemQueryService.go
@@ -16,10 +16,10 @@ func NewItemQueryService() items.Repository {
 }
 
 func (s *itemQueryService) FindAll(ctx context.Context) (items.Items, error) {
-	db := CtxFromDB(ctx)
+	gormDB := CtxFromDB(ctx)
 
 	var itemModels []Item
-	if err := db.Find(&itemModels).Error; err != nil {
+	if err := gormDB.Find(&itemModels).Error; err != nil {
 		return nil, fmt.Errorf("failed to fetch items: %w", err)
 	}
 
@@ -33,10 +33,10 @@ func (s *itemQueryService) FindAll(ctx context.Context) (items.Items, error) {
 }
 
 func (s *itemQueryService) FindByID(ctx context.Context, itemID string) (*items.Item, error) {
-	db := CtxFromDB(ctx)
+	gormDB := CtxFromDB(ctx)
 
 	var itemModel Item
-	if err := db.Where("item_id = ?", itemID).First(&itemModel).Error; err != nil {
+	if err := gormDB.Where("item_id = ?", itemID).First(&itemModel).Error; err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, gorm.ErrRecordNotFound
 		}
@@ -47,10 +47,10 @@ func (s *itemQueryService) FindByID(ctx context.Context, itemID string) (*items.
 }
 
 func (s *itemQueryService) FindByMonsterID(ctx context.Context, monsterID string) (items.Items, error) {
-	db := CtxFromDB(ctx)
+	gormDB := CtxFromDB(ctx)
 
 	var itemModels []Item
-	if err := db.Where("monster_id = ?", monsterID).Find(&itemModels).Error; err != nil {
+	if err := gormDB.Where("monster_id = ?", monsterID).Find(&itemModels).Error; err != nil {
 		return nil, fmt.Errorf("failed to fetch items by monster ID: %w", err)
 	}
 
diff --git a/internal/database/mysql/monsterQueryService.go b/internal/database/mysql/monsterQueryService.go
@@ -114,7 +114,7 @@ func (s *monsterQueryService) FetchList(ctx context.Context, id string) (*monste
 	sort := ""
 
 	if id == "" {
-		p = ctx.Value("param").(param.RequestParam)
+		p = ctx.Value(param.CtxParamKey).(param.RequestParam)
 	}
 
 	limit := p.Limit
diff --git a/internal/database/mysql/monsterQueryService_test.go b/internal/database/mysql/monsterQueryService_test.go
@@ -170,7 +170,7 @@ func Test_monsterQueryService_FetchList(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			ctx = context.WithValue(ctx, "param", tt.args.param)
+			ctx = context.WithValue(ctx, param.CtxParamKey, tt.args.param)
 			s := &monsterQueryService{}
 			got, err := s.FetchList(ctx, tt.args.id)
 			assert.True(t, (err != nil) == tt.wantErr)
diff --git a/internal/database/mysql/skillQueryService.go b/internal/database/mysql/skillQueryService.go
@@ -16,10 +16,10 @@ func NewSkillQueryService() skills.Repository {
 }
 
 func (s *skillQueryService) FindAll(ctx context.Context) (skills.Skills, error) {
-	db := CtxFromDB(ctx)
+	gormDB := CtxFromDB(ctx)
 
 	var skillModels []Skill
-	if err := db.Preload("Levels").Find(&skillModels).Error; err != nil {
+	if err := gormDB.Preload("Levels").Find(&skillModels).Error; err != nil {
 		return nil, fmt.Errorf("failed to fetch skills: %w", err)
 	}
 
@@ -44,10 +44,10 @@ func (s *skillQueryService) FindAll(ctx context.Context) (skills.Skills, error)
 }
 
 func (s *skillQueryService) FindById(ctx context.Context, skillId string) (skills.Skill, error) {
-	db := CtxFromDB(ctx)
+	gormDB := CtxFromDB(ctx)
 
 	var skillModel Skill
-	if err := db.Preload("Levels").Where("skill_id = ?", skillId).First(&skillModel).Error; err != nil {
+	if err := gormDB.Preload("Levels").Where("skill_id = ?", skillId).First(&skillModel).Error; err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return skills.Skill{}, gorm.ErrRecordNotFound
 		}
@@ -70,7 +70,7 @@ func (s *skillQueryService) FindById(ctx context.Context, skillId string) (skill
 }
 
 func (s *skillQueryService) Save(ctx context.Context, skill skills.Skill) error {
-	db := CtxFromDB(ctx)
+	gormDB := CtxFromDB(ctx)
 
 	skillModel := Skill{
 		SkillId:     skill.GetId(),
@@ -88,17 +88,17 @@ func (s *skillQueryService) Save(ctx context.Context, skill skills.Skill) error
 		skillModel.Levels = append(skillModel.Levels, levelModel)
 	}
 
-	if err := db.Create(&skillModel).Error; err != nil {
+	if err := gormDB.Create(&skillModel).Error; err != nil {
 		return fmt.Errorf("failed to save skill: %w", err)
 	}
 
 	return nil
 }
 
 func (s *skillQueryService) Remove(ctx context.Context, skillId string) error {
-	db := CtxFromDB(ctx)
+	gormDB := CtxFromDB(ctx)
 
-	if err := db.Where("skill_id = ?", skillId).Delete(&Skill{}).Error; err != nil {
+	if err := gormDB.Where("skill_id = ?", skillId).Delete(&Skill{}).Error; err != nil {
 		return fmt.Errorf("failed to remove skill: %w", err)
 	}
 
diff --git a/internal/database/mysql/testHelper.go b/internal/database/mysql/testHelper.go
@@ -20,7 +20,9 @@ var testDB *gorm.DB
 
 // setupTestDB はテスト用のDBセットアップを行うヘルパー関数
 func setupTestDB(ctx context.Context) context.Context {
-	os.Setenv("DATABASE_URL", "mh-api:P@ssw0rd@tcp(127.0.0.1:3306)/ci?charset=utf8&parseTime=True&loc=Local")
+	if err := os.Setenv("DATABASE_URL", "mh-api:P@ssw0rd@tcp(127.0.0.1:3306)/ci?charset=utf8&parseTime=True&loc=Local"); err != nil {
+		log.Fatal(err)
+	}
 	cfg, err := config.New()
 	if err != nil {
 		log.Fatal(err)
diff --git a/internal/database/mysql/weaponQueryService.go b/internal/database/mysql/weaponQueryService.go
@@ -20,43 +20,45 @@ func (qs *WeaponQueryService) FindWeapons(ctx context.Context, params weaponServ
 	var total int64
 
 	// コンテキストからDBを取得
-	db := CtxFromDB(ctx)
+	gormDB := CtxFromDB(ctx)
 
 	if params.WeaponID != nil {
-		db = db.Where("weapon_id = ?", *params.WeaponID)
+		gormDB = gormDB.Where("weapon_id = ?", *params.WeaponID)
 	}
 
 	if params.Name != nil {
-		db = db.Where("name LIKE ?", "%"+*params.Name+"%")
+		gormDB = gormDB.Where("name LIKE ?", "%"+*params.Name+"%")
 	}
 
 	if params.Sort != nil {
-		if *params.Sort == "asc" {
-			db = db.Order("id ASC")
-		} else if *params.Sort == "desc" {
-			db = db.Order("id DESC")
+		switch *params.Sort {
+		case "asc":
+			gormDB = gormDB.Order("id ASC")
+		case "desc":
+			gormDB = gormDB.Order("id DESC")
 		}
 	}
 
 	if params.Order != nil {
-		if *params.Order == 1 {
-			db = db.Order("id ASC")
-		} else if *params.Order == 2 {
-			db = db.Order("id DESC")
+		switch *params.Order {
+		case 1:
+			gormDB = gormDB.Order("id ASC")
+		case 2:
+			gormDB = gormDB.Order("id DESC")
 		}
 	}
 	if params.Limit != nil && *params.Limit > 0 {
-		db = db.Limit(*params.Limit)
+		gormDB = gormDB.Limit(*params.Limit)
 	} else {
 		defaultLimit := 20
-		db = db.Limit(defaultLimit)
+		gormDB = gormDB.Limit(defaultLimit)
 	}
 
 	if params.Offset != nil {
-		db = db.Offset(*params.Offset)
+		gormDB = gormDB.Offset(*params.Offset)
 	}
 
-	result := db.Find(&weaponsList)
+	result := gormDB.Find(&weaponsList)
 	if result.Error != nil {
 		return nil, 0, result.Error
 	}
diff --git a/internal/presenter/middleware/logger.go b/internal/presenter/middleware/logger.go
diff --git a/internal/service/weapons/weapons.go b/internal/service/weapons/weapons.go

Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ func (m MCPServer) getMonsters(ctx context.Context, _ mcp.CallToolRequest, in`
`147`	`147`	`Limit: limit,`
`148`	`148`	`Offset: (offset - 1) * limit,`
`149`	`149`	`}`
`150`		`- ctx = context.WithValue(ctx, "param", param)`
	`150`	`+ ctx = context.WithValue(ctx, request.CtxParamKey, param)`
`151`	`151`
`152`	`152`	`result, err := m.monsterService.FetchMonsterDetail(ctx, "")`
`153`	`153`	`if err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ func main() {`
`58`	`58`	`if err != nil {`
`59`	`59`	`log.Fatal("failed to create file:", err)`
`60`	`60`	`}`
`61`		`- defer f.Close()`
	`61`	`+ defer func() { _ = f.Close() }()`
`62`	`62`
`63`	`63`	`f.WriteString("-- +migrate Up\n\n\n") //nolint:all`
`64`	`64`	`f.WriteString("-- +migrate Down\n\n") //nolint:all`
`@@ -109,7 +109,7 @@ func executeSeedFile(db *sql.DB, filePath string) error {`
`109`	`109`	`if err != nil {`
`110`	`110`	`return err`
`111`	`111`	`}`
`112`		`- defer file.Close()`
	`112`	`+ defer func() { _ = file.Close() }()`
`113`	`113`
`114`	`114`	`var queries []string`
`115`	`115`	`var currentQuery strings.Builder`
`@@ -133,8 +133,8 @@ func executeSeedFile(db *sql.DB, filePath string) error {`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
`136`		`- if err := scanner.Err(); err != nil {`
`137`		`- return err`
	`136`	`+ if scanErr := scanner.Err(); scanErr != nil {`
	`137`	`+ return scanErr`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`// トランザクション内でクエリを実行`
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ func (m *MonHunTools) getMonsters(ctx context.Context, args GetMonstersInput) (s`
`209`	`209`	`Limit: limit,`
`210`	`210`	`Offset: calculatedOffset,`
`211`	`211`	`}`
`212`		`- ctx = context.WithValue(ctx, "param", param)`
	`212`	`+ ctx = context.WithValue(ctx, request.CtxParamKey, param)`
`213`	`213`
`214`	`214`	`monsters, err := m.monsterService.FetchMonsterDetail(ctx, "")`
`215`	`215`	`if err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -63,22 +63,22 @@ func createTestArmors(t testing.T, ctx context.Context) []Armor {`
`63`	`63`	`{ArmorId: "armor003", ItemId: "ITM0019", ItemName: "リオレウスの鱗"},`
`64`	`64`	`}`
`65`	`65`
`66`		`- db := CtxFromTestDB(ctx)`
	`66`	`+ gormDB := CtxFromTestDB(ctx)`
`67`	`67`
`68`	`68`	`for _, armor := range testArmors {`
`69`		`- if err := db.Create(armor).Error; err != nil {`
	`69`	`+ if err := gormDB.Create(armor).Error; err != nil {`
`70`	`70`	`t.Fatalf("failed to create test armor: %v", err)`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`for _, skill := range testSkills {`
`75`		`- if err := db.Create(skill).Error; err != nil {`
	`75`	`+ if err := gormDB.Create(skill).Error; err != nil {`
`76`	`76`	`t.Fatalf("failed to create test armor skill: %v", err)`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`for _, item := range testRequiredItems {`
`81`		`- if err := db.Create(item).Error; err != nil {`
	`81`	`+ if err := gormDB.Create(item).Error; err != nil {`
`82`	`82`	`t.Fatalf("failed to create test armor required item: %v", err)`
`83`	`83`	`}`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,11 +12,11 @@ func NewHealthRepository() *healthRepository {`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`func (h *healthRepository) GetStatus(ctx context.Context) error {`
`15`		`- db := CtxFromDB(ctx)`
`16`		`- if db == nil {`
	`15`	`+ gormDB := CtxFromDB(ctx)`
	`16`	`+ if gormDB == nil {`
`17`	`17`	`return errors.New("database connection not found")`
`18`	`18`	`}`
`19`		`- conn, err := db.DB()`
	`19`	`+ conn, err := gormDB.DB()`
`20`	`20`	`if err != nil {`
`21`	`21`	`return err`
`22`	`22`	`}`