Refactor-test

backend/cmd/server/main.go

@@ -6,7 +6,6 @@ import (
 	"net/http"
 	"os"
 	"os/signal"
-	"strings"
 	"syscall"
 	"time"
 
@@ -23,52 +22,9 @@ import (
 
 	"log/slog"
 
-	sloggin "github.com/samber/slog-gin"
-
-	"github.com/gin-contrib/cors"
-
 	"github.com/paularynty/transcendence/auth-service-go/internal/dependency"
-	"github.com/paularynty/transcendence/auth-service-go/internal/middleware"
 )
 
-func SetupRouter(dep *dependency.Dependency) *gin.Engine {
-	r := gin.New()
-
-	logConfig := sloggin.Config{
-		DefaultLevel:     slog.LevelInfo,
-		ClientErrorLevel: slog.LevelWarn,
-		ServerErrorLevel: slog.LevelError,
-	}
-
-	// A rough CORS
-	r.Use(cors.New(cors.Config{
-		AllowOriginFunc: func(origin string) bool {
-			if origin == "http://localhost:5173" ||
-				origin == "http://localhost:4173" {
-				return true
-			}
-			if strings.HasSuffix(origin, ".vercel.app") {
-				return true
-			}
-			return false
-		},
-		AllowMethods:     []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"},
-		AllowHeaders:     []string{"Origin", "Content-Length", "Content-Type", "Authorization"},
-		ExposeHeaders:    []string{"Content-Length"},
-		AllowCredentials: true,
-		MaxAge:           12 * time.Hour,
-	}))
-
-	rateLimiter := middleware.NewRateLimiter(time.Duration(dep.Cfg.RateLimiterDurationInSec)*time.Second, dep.Cfg.RateLimiterRequestLimit, time.Duration(dep.Cfg.RateLimiterCleanupIntervalInSec)*time.Second)
-	r.Use(rateLimiter.RateLimit())
-
-	r.Use(middleware.PanicHandler())
-	r.Use(sloggin.NewWithConfig(dep.Logger, logConfig))
-	r.Use(middleware.ErrorHandler())
-
-	return r
-}
-
 // @title Auth Service API
 // @version 1.0
 // @description Auth service
@@ -97,7 +53,7 @@ func main() {
 	}
 
 	// router
-	r := SetupRouter(dep)
+	r := routers.SetupRouter(dep)
 	routers.UsersRouter(r.Group("/api/users"), userService)
 
 	// Health check

backend/internal/config/config_test.go

@@ -1,84 +1,216 @@
 package config
 
 import (
+	"fmt"
 	"testing"
 )
 
-func assertError(t *testing.T, err error, name string) {
+const testKey = "TEST_KEY"
+const notSet = "notSet"
+
+func setEnv(t *testing.T, v string) {
 	t.Helper()
-	if err == nil {
-		t.Fatalf("expected error for %s", name)
+
+	if v == notSet {
+		return
 	}
+
+	t.Setenv(testKey, v)
 }
 
-func assertNoError(t *testing.T, err error, name string) {
-	t.Helper()
-	if err != nil {
-		t.Fatalf("unexpected error for %s: %v", name, err)
+func TestGetEnvStrOrDefault(t *testing.T) {
+	const validValue = "v1"
+	const defaultValue = "v"
+	const emptyValue = ""
+
+	testCases := []struct {
+		name     string
+		envValue string
+		expected string
+	}{
+		{
+			name:     "valid env string",
+			envValue: validValue,
+			expected: validValue,
+		},
+		{
+			name:     "empty env string",
+			envValue: emptyValue,
+			expected: defaultValue,
+		},
+		{
+			name:     "env not set",
+			envValue: notSet,
+			expected: defaultValue,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			setEnv(t, tc.envValue)
+
+			if got := getEnvStrOrDefault(testKey, defaultValue); got != tc.expected {
+				t.Fatalf("expect: %q, got %q", tc.expected, got)
+			}
+		})
 	}
 }
 
-func TestGetEnvStrOrDefault(t *testing.T) {
-	t.Setenv("TEST_STR", "")
-	if got := getEnvStrOrDefault("TEST_STR", "fallback"); got != "fallback" {
-		t.Fatalf("expected default value, got %q", got)
+func TestGetEnvIntOrDefault(t *testing.T) {
+	const validValue = "10"
+	const validExpected = 10
+	const defaultValue = 22
+	const invalidValue = "a"
+
+	testCases := []struct {
+		name     string
+		envValue string
+		expected int
+	}{
+		{
+			name:     "valid env (int)",
+			envValue: validValue,
+			expected: validExpected,
+		},
+		{
+			name:     "env not set (int)",
+			envValue: notSet,
+			expected: defaultValue,
+		},
+		{
+			name:     "invalid env (int)",
+			envValue: invalidValue,
+			expected: defaultValue,
+		},
 	}
 
-	t.Setenv("TEST_STR", "value")
-	if got := getEnvStrOrDefault("TEST_STR", "fallback"); got != "value" {
-		t.Fatalf("expected env value, got %q", got)
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			setEnv(t, tc.envValue)
+
+			if got := getEnvIntOrDefault(testKey, defaultValue); got != tc.expected {
+				t.Fatalf("expected: %d, got: %d", tc.expected, got)
+			}
+		})
 	}
 }
 
 func TestGetEnvStrOrError(t *testing.T) {
-	t.Setenv("TEST_PANIC", "")
-	_, err := getEnvStrOrError("TEST_PANIC")
-	assertError(t, err, "empty env")
-
-	t.Setenv("TEST_PANIC", "value")
-	got, err := getEnvStrOrError("TEST_PANIC")
-	assertNoError(t, err, "set env")
-	if got != "value" {
-		t.Fatalf("expected env value, got %q", got)
+	const validValue = "v1"
+	const emptyValue = ""
+	const errorValue = "error"
+
+	testCases := []struct {
+		name      string
+		envValue  string
+		expected  string
+		expectErr bool
+	}{
+		{
+			name:      "valid env string",
+			envValue:  validValue,
+			expected:  validValue,
+			expectErr: false,
+		},
+		{
+			name:      "empty env string",
+			envValue:  emptyValue,
+			expected:  errorValue,
+			expectErr: true,
+		},
+		{
+			name:      "env not set",
+			envValue:  notSet,
+			expected:  errorValue,
+			expectErr: true,
+		},
 	}
-}
 
-func TestGetEnvIntOrDefault(t *testing.T) {
-	t.Setenv("TEST_INT", "")
-	if got := getEnvIntOrDefault("TEST_INT", 7); got != 7 {
-		t.Fatalf("expected default value, got %d", got)
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			setEnv(t, tc.envValue)
+
+			got, err := getEnvStrOrError(testKey)
+
+			if tc.expectErr && err == nil {
+				t.Fatalf("expected error, got %q", got)
+			}
+
+			if !tc.expectErr && err != nil {
+				t.Fatalf("expected %q, got error %v", tc.expected, err)
+			}
+
+			if !tc.expectErr && got != tc.expected {
+				t.Fatalf("expected %q, got %q", tc.expected, got)
+			}
+		})
 	}
+}
+
+var mandatoryItems = []string{
+	"JWT_SECRET",
+	"GOOGLE_CLIENT_ID",
+	"GOOGLE_CLIENT_SECRET",
+}
+
+func setEnvForMandatoryItem(t *testing.T, keys []string) {
+	t.Helper()
 
-	t.Setenv("TEST_INT", "42")
-	if got := getEnvIntOrDefault("TEST_INT", 7); got != 42 {
-		t.Fatalf("expected env value, got %d", got)
+	for _, key := range mandatoryItems {
+		t.Setenv(key, "")
 	}
 
-	t.Setenv("TEST_INT", "not-an-int")
-	if got := getEnvIntOrDefault("TEST_INT", 7); got != 7 {
-		t.Fatalf("expected default value for invalid int, got %d", got)
+	for _, key := range keys {
+		t.Setenv(key, "test_value")
 	}
 }
 
-func TestLoadConfigFromEnv_ErrsOnMissingRequired(t *testing.T) {
-	t.Setenv("JWT_SECRET", "jwt")
-	t.Setenv("GOOGLE_CLIENT_ID", "client")
-	t.Setenv("GOOGLE_CLIENT_SECRET", "secret")
+func TestLoadConfigFromEnv_MissingMandatory(t *testing.T) {
+	type testCase struct {
+		name      string
+		expectErr bool
+		keys      []string
+	}
+
+	testCases := []testCase{
+		{
+			name:      "normal case",
+			expectErr: false,
+			keys:      mandatoryItems,
+		},
+	}
+
+	for i, item := range mandatoryItems {
+		keys := make([]string, 0, len(mandatoryItems)-1)
+		keys = append(keys, mandatoryItems[:i]...)
+		keys = append(keys, mandatoryItems[i+1:]...)
 
-	_, err := LoadConfigFromEnv()
-	assertNoError(t, err, "all required set")
+		tc := testCase{
+			name:      fmt.Sprintf("missing %s", item),
+			expectErr: true,
+			keys:      keys,
+		}
+		testCases = append(testCases, tc)
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
 
-	t.Setenv("JWT_SECRET", "")
-	_, err = LoadConfigFromEnv()
-	assertError(t, err, "JWT_SECRET unset")
+			setEnvForMandatoryItem(t, tc.keys)
+			cfg, err := LoadConfigFromEnv()
 
-	t.Setenv("JWT_SECRET", "jwt")
-	t.Setenv("GOOGLE_CLIENT_ID", "")
-	_, err = LoadConfigFromEnv()
-	assertError(t, err, "GOOGLE_CLIENT_ID unset")
+			if tc.expectErr && err == nil {
+				t.Fatalf("expected error, but got cfg: %v.", cfg)
+			}
 
-	t.Setenv("GOOGLE_CLIENT_ID", "client")
-	t.Setenv("GOOGLE_CLIENT_SECRET", "")
-	_, err = LoadConfigFromEnv()
-	assertError(t, err, "GOOGLE_CLIENT_SECRET unset")
+			if !tc.expectErr && cfg == nil {
+				t.Fatalf("expected cfg, but got nil")
+			}
+
+			if !tc.expectErr && err != nil {
+				t.Fatalf("expected cfg, but got err: %v", err)
+			}
+		})
+	}
 }

backend/internal/dto/schemas.go

@@ -29,6 +29,7 @@ func InitValidator() {
 	_ = Validate.RegisterValidation("username", validateUsername)
 	_ = Validate.RegisterValidation("password", validatePassword)
 	_ = Validate.RegisterValidation("identifier", validateIdentifier)
+	Validate.RegisterAlias("passwordField", "required,trim,min=6,max=20,password")
 	registerUsernameTranslation(Validate, Trans)
 	registerPasswordTranslation(Validate, Trans)
 	registerIdentifierTranslation(Validate, Trans)
@@ -80,15 +81,15 @@ func registerUsernameTranslation(v *validator.Validate, trans ut.Translator) {
 // Password
 
 type Password struct {
-	Password string `json:"password" validate:"required,trim,min=6,max=20,password"`
+	Password string `json:"password" validate:"passwordField"`
 }
 
 type OldPassword struct {
-	OldPassword string `json:"oldPassword" validate:"required,trim,password,min=6,max=20"`
+	OldPassword string `json:"oldPassword" validate:"passwordField"`
 }
 
 type NewPassword struct {
-	NewPassword string `json:"newPassword" validate:"required,trim,password,min=6,max=20"`
+	NewPassword string `json:"newPassword" validate:"passwordField"`
 }
 
 // Contains only letters, numbers, ".", "_" or "-"