Go言語で学ぶDRY原則：コピペコードが招く保守性の悪夢と統一化による解決策

// ❌ 悪い例：1つ目のJWTトークン抽出処理
package utils

import "strings"

func ExtractToken(authHeader string) string {
	if authHeader == "" {
		return ""
	}
	parts := strings.Split(authHeader, " ")
	if len(parts) != 2 || !strings.EqualFold(parts[0], "bearer") {
		return ""
	}
	return parts[1]
}

// ❌ 悪い例：2つ目のJWTトークン抽出処理（ほぼ同じだが、エラー処理が異なる）
package middleware

import (
	"errors"
	"net/http"
	"strings"
)

func validateAuthHeader(header string) (string, error) {
	if header == "" {
		return "", errors.New("missing authorization header")
	}
	parts := strings.Split(header, " ")
	if len(parts) != 2 || !strings.EqualFold(parts[0], "bearer") {
		return "", errors.New("invalid authorization header format")
	}
	return parts[1], nil
}

// ✅ 改善案：pkg/utils/auth.go に統一された実装を作成
package utils

import (
	"errors"
	"fmt"
	"strings"
)

// ExtractBearerToken はAuthorizationヘッダーからJWTトークンを安全に抽出します。
// この関数が「単一の真実の源」となります。
func ExtractBearerToken(authHeader string) (string, error) {
	if authHeader == "" {
		return "", errors.New("authorization header is missing")
	}

	// 連続した空白にも対応できる `strings.Fields` を使用
	parts := strings.Fields(authHeader)
	if len(parts) != 2 {
		return "", fmt.Errorf("invalid authorization header format: expected 'Bearer <token>', but got %d parts", len(parts))
	}

	if !strings.EqualFold(parts[0], "bearer") {
		return "", errors.New("authorization header must start with 'Bearer'")
	}

	token := parts[1]
	if token == "" {
		return "", errors.New("bearer token is empty")
	}

	return token, nil
}

// ✅ 改善案：ミドルウェアで共通関数を利用
package middleware

import (
	"net/http"
	"your-project/pkg/utils" // 共通処理をインポート
)

func AuthMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		authHeader := r.Header.Get("Authorization")

		// 🚨 統一された共通関数を呼び出す
		token, err := utils.ExtractBearerToken(authHeader)
		if err != nil {
			http.Error(w, fmt.Sprintf("Authentication failed: %s", err.Error()), http.StatusUnauthorized)
			return
		}
		// ... トークン検証処理 ...
		next.ServeHTTP(w, r)
	})
}

// ✅ pkg/utils/auth.go にラッパー関数を追加

// ExtractTokenは後方互換性のために残されたラッパー関数です。
// 新しいコードではExtractBearerTokenの使用を推奨します。
// @deprecated
func ExtractToken(authHeader string) string {
	token, err := ExtractBearerToken(authHeader)
	if err != nil {
		return "" // 既存の挙動（エラー時に空文字列を返す）を維持
	}
	return token
}

// ✅ pkg/utils/auth_test.go - 統一されたテスト
func TestExtractBearerToken(t *testing.T) {
	testCases := []struct {
		name       string
		authHeader string
		wantToken  string
		wantErrMsg string
	}{
		{"valid token", "Bearer eyJhbGci...", "eyJhbGci...", ""},
		{"lowercase bearer", "bearer token123", "token123", ""},
		{"extra spaces", "Bearer   token123  ", "token123", ""},
		{"empty header", "", "", "authorization header is missing"},
		{"missing bearer keyword", "Token token123", "", "must start with 'Bearer'"},
		{"empty token", "Bearer ", "", "bearer token is empty"},
		{"malformed header", "Bearer t1 t2", "", "invalid authorization header format"},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			token, err := ExtractBearerToken(tc.authHeader)
			assert.Equal(t, tc.wantToken, token)
			if tc.wantErrMsg != "" {
				assert.Error(t, err)
				assert.Contains(t, err.Error(), tc.wantErrMsg)
			} else {
				assert.NoError(t, err)
			}
		})
	}
}