package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/gin-gonic/gin"
    "golang-app/internal/config"
    "golang-app/internal/handlers"
    "golang-app/internal/middleware"
    "golang-app/internal/repository"
    "golang-app/internal/service"
)

func main() {
    // Load configuration
    cfg, err := config.Load()
    if err != nil {
        log.Fatal("Failed to load config:", err)
    }

    // Initialize repository layer
    repo := repository.NewMemoryRepository()

    // Initialize service layer
    svc := service.New(repo)

    // Initialize handlers
    h := handlers.New(svc)

    // Setup Gin router
    if cfg.Environment == "production" {
        gin.SetMode(gin.ReleaseMode)
    }

    router := gin.New()
    router.Use(gin.Logger())
    router.Use(gin.Recovery())
    router.Use(middleware.CORS())
    router.Use(middleware.RequestID())

    // Health check endpoint
    router.GET("/health", h.HealthCheck)

    // API routes
    v1 := router.Group("/api/v1")
    {
        v1.GET("/users", h.GetUsers)
        v1.POST("/users", h.CreateUser)
        v1.GET("/users/:id", h.GetUser)
        v1.PUT("/users/:id", h.UpdateUser)
        v1.DELETE("/users/:id", h.DeleteUser)
    }

    // Create HTTP server
    server := &http.Server{
        Addr:         fmt.Sprintf(":%s", cfg.Port),
        Handler:      router,
        ReadTimeout:  15 * time.Second,
        WriteTimeout: 15 * time.Second,
        IdleTimeout:  60 * time.Second,
    }

    // Start server in a goroutine
    go func() {
        log.Printf("Server starting on port %s", cfg.Port)
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatal("Failed to start server:", err)
        }
    }()

    // Wait for interrupt signal to gracefully shutdown the server
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    log.Println("Shutting down server...")

    // Graceful shutdown with timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := server.Shutdown(ctx); err != nil {
        log.Fatal("Server forced to shutdown:", err)
    }

    log.Println("Server exited")
}

package config

import (
    "os"
    "strconv"
)

// Config holds the application configuration
type Config struct {
    Port        string
    Environment string
    LogLevel    string
    Database    DatabaseConfig
}

// DatabaseConfig holds database configuration
type DatabaseConfig struct {
    Host     string
    Port     int
    Username string
    Password string
    Database string
    SSLMode  string
}

// Load loads configuration from environment variables with defaults
func Load() (*Config, error) {
    cfg := &Config{
        Port:        getEnv("PORT", "8080"),
        Environment: getEnv("ENVIRONMENT", "development"),
        LogLevel:    getEnv("LOG_LEVEL", "info"),
        Database: DatabaseConfig{
            Host:     getEnv("DB_HOST", "localhost"),
            Port:     getEnvAsInt("DB_PORT", 5432),
            Username: getEnv("DB_USERNAME", "postgres"),
            Password: getEnv("DB_PASSWORD", ""),
            Database: getEnv("DB_DATABASE", "golang_app"),
            SSLMode:  getEnv("DB_SSL_MODE", "disable"),
        },
    }

    return cfg, nil
}

// getEnv gets an environment variable or returns a default value
func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

// getEnvAsInt gets an environment variable as integer or returns a default value
func getEnvAsInt(key string, defaultValue int) int {
    if valueStr := os.Getenv(key); valueStr != "" {
        if value, err := strconv.Atoi(valueStr); err == nil {
            return value
        }
    }
    return defaultValue
}

package models

import (
    "time"
    "github.com/google/uuid"
)

// User represents a user in the system
type User struct {
    ID        string    `json:"id" validate:"required,uuid"`
    FirstName string    `json:"first_name" validate:"required,min=2,max=50"`
    LastName  string    `json:"last_name" validate:"required,min=2,max=50"`
    Email     string    `json:"email" validate:"required,email"`
    Age       int       `json:"age" validate:"required,min=1,max=120"`
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}

// CreateUserRequest represents the request payload for creating a user
type CreateUserRequest struct {
    FirstName string `json:"first_name" validate:"required,min=2,max=50"`
    LastName  string `json:"last_name" validate:"required,min=2,max=50"`
    Email     string `json:"email" validate:"required,email"`
    Age       int    `json:"age" validate:"required,min=1,max=120"`
}

// UpdateUserRequest represents the request payload for updating a user
type UpdateUserRequest struct {
    FirstName *string `json:"first_name,omitempty" validate:"omitempty,min=2,max=50"`
    LastName  *string `json:"last_name,omitempty" validate:"omitempty,min=2,max=50"`
    Email     *string `json:"email,omitempty" validate:"omitempty,email"`
    Age       *int    `json:"age,omitempty" validate:"omitempty,min=1,max=120"`
}

// NewUser creates a new user with generated ID and timestamps
func NewUser(req CreateUserRequest) *User {
    now := time.Now()
    return &User{
        ID:        uuid.New().String(),
        FirstName: req.FirstName,
        LastName:  req.LastName,
        Email:     req.Email,
        Age:       req.Age,
        CreatedAt: now,
        UpdatedAt: now,
    }
}

// Update updates user fields from UpdateUserRequest
func (u *User) Update(req UpdateUserRequest) {
    if req.FirstName != nil {
        u.FirstName = *req.FirstName
    }
    if req.LastName != nil {
        u.LastName = *req.LastName
    }
    if req.Email != nil {
        u.Email = *req.Email
    }
    if req.Age != nil {
        u.Age = *req.Age
    }
    u.UpdatedAt = time.Now()
}

package repository

import (
    "errors"
    "sync"
    "golang-app/internal/models"
)

var (
    ErrUserNotFound     = errors.New("user not found")
    ErrUserAlreadyExists = errors.New("user already exists")
)

// UserRepository defines the interface for user data operations
type UserRepository interface {
    Create(user *models.User) error
    GetByID(id string) (*models.User, error)
    GetAll() ([]*models.User, error)
    Update(user *models.User) error
    Delete(id string) error
    ExistsByEmail(email string) bool
}

// MemoryRepository implements UserRepository using in-memory storage
type MemoryRepository struct {
    users map[string]*models.User
    mutex sync.RWMutex
}

// NewMemoryRepository creates a new in-memory repository
func NewMemoryRepository() UserRepository {
    return &MemoryRepository{
        users: make(map[string]*models.User),
        mutex: sync.RWMutex{},
    }
}

// Create adds a new user to the repository
func (r *MemoryRepository) Create(user *models.User) error {
    r.mutex.Lock()
    defer r.mutex.Unlock()

    if r.existsByEmail(user.Email) {
        return ErrUserAlreadyExists
    }

    r.users[user.ID] = user
    return nil
}

// GetByID retrieves a user by ID
func (r *MemoryRepository) GetByID(id string) (*models.User, error) {
    r.mutex.RLock()
    defer r.mutex.RUnlock()

    user, exists := r.users[id]
    if !exists {
        return nil, ErrUserNotFound
    }

    // Return a copy to prevent external modifications
    userCopy := *user
    return &userCopy, nil
}

// GetAll retrieves all users
func (r *MemoryRepository) GetAll() ([]*models.User, error) {
    r.mutex.RLock()
    defer r.mutex.RUnlock()

    users := make([]*models.User, 0, len(r.users))
    for _, user := range r.users {
        userCopy := *user
        users = append(users, &userCopy)
    }

    return users, nil
}

// Update updates an existing user
func (r *MemoryRepository) Update(user *models.User) error {
    r.mutex.Lock()
    defer r.mutex.Unlock()

    if _, exists := r.users[user.ID]; !exists {
        return ErrUserNotFound
    }

    r.users[user.ID] = user
    return nil
}

// Delete removes a user from the repository
func (r *MemoryRepository) Delete(id string) error {
    r.mutex.Lock()
    defer r.mutex.Unlock()

    if _, exists := r.users[id]; !exists {
        return ErrUserNotFound
    }

    delete(r.users, id)
    return nil
}

// ExistsByEmail checks if a user with the given email exists
func (r *MemoryRepository) ExistsByEmail(email string) bool {
    r.mutex.RLock()
    defer r.mutex.RUnlock()
    return r.existsByEmail(email)
}

// existsByEmail is the internal method without locking
func (r *MemoryRepository) existsByEmail(email string) bool {
    for _, user := range r.users {
        if user.Email == email {
            return true
        }
    }
    return false
}

package service

import (
    "errors"
    "golang-app/internal/models"
    "golang-app/internal/repository"
)

var (
    ErrInvalidUserData = errors.New("invalid user data")
    ErrDuplicateEmail  = errors.New("email already exists")
)

// UserService defines the interface for user business logic
type UserService interface {
    CreateUser(req models.CreateUserRequest) (*models.User, error)
    GetUser(id string) (*models.User, error)
    GetAllUsers() ([]*models.User, error)
    UpdateUser(id string, req models.UpdateUserRequest) (*models.User, error)
    DeleteUser(id string) error
}

// Service implements UserService
type Service struct {
    repo repository.UserRepository
}

// New creates a new service instance
func New(repo repository.UserRepository) UserService {
    return &Service{
        repo: repo,
    }
}

// CreateUser creates a new user
func (s *Service) CreateUser(req models.CreateUserRequest) (*models.User, error) {
    // Check if user with email already exists
    if s.repo.ExistsByEmail(req.Email) {
        return nil, ErrDuplicateEmail
    }

    // Create new user
    user := models.NewUser(req)

    // Save to repository
    if err := s.repo.Create(user); err != nil {
        return nil, err
    }

    return user, nil
}

// GetUser retrieves a user by ID
func (s *Service) GetUser(id string) (*models.User, error) {
    if id == "" {
        return nil, ErrInvalidUserData
    }

    return s.repo.GetByID(id)
}

// GetAllUsers retrieves all users
func (s *Service) GetAllUsers() ([]*models.User, error) {
    return s.repo.GetAll()
}

// UpdateUser updates an existing user
func (s *Service) UpdateUser(id string, req models.UpdateUserRequest) (*models.User, error) {
    if id == "" {
        return nil, ErrInvalidUserData
    }

    // Get existing user
    user, err := s.repo.GetByID(id)
    if err != nil {
        return nil, err
    }

    // Check email uniqueness if email is being updated
    if req.Email != nil && *req.Email != user.Email {
        if s.repo.ExistsByEmail(*req.Email) {
            return nil, ErrDuplicateEmail
        }
    }

    // Update user
    user.Update(req)

    // Save changes
    if err := s.repo.Update(user); err != nil {
        return nil, err
    }

    return user, nil
}

// DeleteUser deletes a user
func (s *Service) DeleteUser(id string) error {
    if id == "" {
        return ErrInvalidUserData
    }

    return s.repo.Delete(id)
}

package handlers

import (
    "net/http"
    "golang-app/internal/service"
    "golang-app/internal/models"
    "golang-app/internal/repository"

    "github.com/gin-gonic/gin"
    "github.com/go-playground/validator/v10"
)

// Handler holds the service dependencies
type Handler struct {
    service   service.UserService
    validator *validator.Validate
}

// New creates a new handler instance
func New(service service.UserService) *Handler {
    return &Handler{
        service:   service,
        validator: validator.New(),
    }
}

// ErrorResponse represents an error response
type ErrorResponse struct {
    Error   string `json:"error"`
    Message string `json:"message,omitempty"`
}

// SuccessResponse represents a success response
type SuccessResponse struct {
    Data    interface{} `json:"data"`
    Message string      `json:"message,omitempty"`
}

// HealthCheck handles health check requests
func (h *Handler) HealthCheck(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "status":  "healthy",
        "service": "golang-app",
        "version": "1.0.0",
    })
}

// CreateUser handles user creation
func (h *Handler) CreateUser(c *gin.Context) {
    var req models.CreateUserRequest

    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, ErrorResponse{
            Error:   "invalid_request",
            Message: err.Error(),
        })
        return
    }

    if err := h.validator.Struct(req); err != nil {
        c.JSON(http.StatusBadRequest, ErrorResponse{
            Error:   "validation_error",
            Message: err.Error(),
        })
        return
    }

    user, err := h.service.CreateUser(req)
    if err != nil {
        switch err {
        case service.ErrDuplicateEmail:
            c.JSON(http.StatusConflict, ErrorResponse{
                Error:   "duplicate_email",
                Message: "User with this email already exists",
            })
        default:
            c.JSON(http.StatusInternalServerError, ErrorResponse{
                Error:   "internal_error",
                Message: "Failed to create user",
            })
        }
        return
    }

    c.JSON(http.StatusCreated, SuccessResponse{
        Data:    user,
        Message: "User created successfully",
    })
}

// GetUser handles getting a single user
func (h *Handler) GetUser(c *gin.Context) {
    id := c.Param("id")

    user, err := h.service.GetUser(id)
    if err != nil {
        switch err {
        case repository.ErrUserNotFound:
            c.JSON(http.StatusNotFound, ErrorResponse{
                Error:   "user_not_found",
                Message: "User not found",
            })
        default:
            c.JSON(http.StatusInternalServerError, ErrorResponse{
                Error:   "internal_error",
                Message: "Failed to get user",
            })
        }
        return
    }

    c.JSON(http.StatusOK, SuccessResponse{
        Data: user,
    })
}

// GetUsers handles getting all users
func (h *Handler) GetUsers(c *gin.Context) {
    users, err := h.service.GetAllUsers()
    if err != nil {
        c.JSON(http.StatusInternalServerError, ErrorResponse{
            Error:   "internal_error",
            Message: "Failed to get users",
        })
        return
    }

    c.JSON(http.StatusOK, SuccessResponse{
        Data: users,
    })
}

// UpdateUser handles user updates
func (h *Handler) UpdateUser(c *gin.Context) {
    id := c.Param("id")
    var req models.UpdateUserRequest

    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, ErrorResponse{
            Error:   "invalid_request",
            Message: err.Error(),
        })
        return
    }

    if err := h.validator.Struct(req); err != nil {
        c.JSON(http.StatusBadRequest, ErrorResponse{
            Error:   "validation_error",
            Message: err.Error(),
        })
        return
    }

    user, err := h.service.UpdateUser(id, req)
    if err != nil {
        switch err {
        case repository.ErrUserNotFound:
            c.JSON(http.StatusNotFound, ErrorResponse{
                Error:   "user_not_found",
                Message: "User not found",
            })
        case service.ErrDuplicateEmail:
            c.JSON(http.StatusConflict, ErrorResponse{
                Error:   "duplicate_email",
                Message: "User with this email already exists",
            })
        default:
            c.JSON(http.StatusInternalServerError, ErrorResponse{
                Error:   "internal_error",
                Message: "Failed to update user",
            })
        }
        return
    }

    c.JSON(http.StatusOK, SuccessResponse{
        Data:    user,
        Message: "User updated successfully",
    })
}

// DeleteUser handles user deletion
func (h *Handler) DeleteUser(c *gin.Context) {
    id := c.Param("id")

    err := h.service.DeleteUser(id)
    if err != nil {
        switch err {
        case repository.ErrUserNotFound:
            c.JSON(http.StatusNotFound, ErrorResponse{
                Error:   "user_not_found",
                Message: "User not found",
            })
        default:
            c.JSON(http.StatusInternalServerError, ErrorResponse{
                Error:   "internal_error",
                Message: "Failed to delete user",
            })
        }
        return
    }

    c.JSON(http.StatusOK, SuccessResponse{
        Message: "User deleted successfully",
    })
}

package middleware

import (
    "fmt"
    "time"

    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
)

// CORS middleware for handling Cross-Origin Resource Sharing
func CORS() gin.HandlerFunc {
    return cors.New(cors.Config{
        AllowOrigins:     []string{"*"},
        AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
        AllowHeaders:     []string{"*"},
        ExposeHeaders:    []string{"Content-Length"},
        AllowCredentials: true,
        MaxAge:           12 * time.Hour,
    })
}

// RequestID middleware adds a unique request ID to each request
func RequestID() gin.HandlerFunc {
    return func(c *gin.Context) {
        requestID := c.GetHeader("X-Request-ID")
        if requestID == "" {
            requestID = uuid.New().String()
        }

        c.Header("X-Request-ID", requestID)
        c.Set("RequestID", requestID)
        c.Next()
    }
}

// Logger middleware for structured logging
func Logger() gin.HandlerFunc {
    return gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
        return fmt.Sprintf("%s - [%s] \"%s %s %s %d %s \"%s\" %s\"\n",
            param.ClientIP,
            param.TimeStamp.Format(time.RFC1123),
            param.Method,
            param.Path,
            param.Request.Proto,
            param.StatusCode,
            param.Latency,
            param.Request.UserAgent(),
            param.ErrorMessage,
        )
    })
}

module golang-app

go 1.23

require (
    github.com/gin-contrib/cors v1.7.0
    github.com/gin-gonic/gin v1.10.0
    github.com/go-playground/validator/v10 v10.23.0
    github.com/google/uuid v1.6.0
)

require (
    github.com/bytedance/sonic v1.12.5 // indirect
    github.com/bytedance/sonic/loader v0.2.1 // indirect
    github.com/cloudwego/base64x v0.1.4 // indirect
    github.com/cloudwego/iasm v0.2.0 // indirect
    github.com/gabriel-vasile/mimetype v1.4.7 // indirect
    github.com/gin-contrib/sse v0.1.0 // indirect
    github.com/go-playground/locales v0.14.1 // indirect
    github.com/go-playground/universal-translator v0.18.1 // indirect
    github.com/goccy/go-json v0.10.4 // indirect
    github.com/json-iterator/go v1.1.12 // indirect
    github.com/klauspost/cpuid/v2 v2.2.9 // indirect
    github.com/leodido/go-urn v1.4.0 // indirect
    github.com/mattn/go-isatty v0.0.20 // indirect
    github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
    github.com/modern-go/reflect2 v1.0.2 // indirect
    github.com/pelletier/go-toml/v2 v2.2.3 // indirect
    github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
    github.com/ugorji/go/codec v1.2.12 // indirect
    golang.org/x/arch v0.12.0 // indirect
    golang.org/x/crypto v0.31.0 // indirect
    golang.org/x/net v0.33.0 // indirect
    golang.org/x/sys v0.28.0 // indirect
    golang.org/x/text v0.21.0 // indirect
    google.golang.org/protobuf v1.36.0 // indirect
    gopkg.in/yaml.v3 v3.0.1 // indirect
)

package handlers

import (
    "bytes"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/gin-gonic/gin"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
    "golang-app/internal/models"
    "golang-app/internal/service"
)

// MockUserService is a mock implementation of UserService
type MockUserService struct {
    mock.Mock
}

func (m *MockUserService) CreateUser(req models.CreateUserRequest) (*models.User, error) {
    args := m.Called(req)
    return args.Get(0).(*models.User), args.Error(1)
}

func (m *MockUserService) GetUser(id string) (*models.User, error) {
    args := m.Called(id)
    if args.Get(0) == nil {
        return nil, args.Error(1)
    }
    return args.Get(0).(*models.User), args.Error(1)
}

func (m *MockUserService) GetAllUsers() ([]*models.User, error) {
    args := m.Called()
    return args.Get(0).([]*models.User), args.Error(1)
}

func (m *MockUserService) UpdateUser(id string, req models.UpdateUserRequest) (*models.User, error) {
    args := m.Called(id, req)
    if args.Get(0) == nil {
        return nil, args.Error(1)
    }
    return args.Get(0).(*models.User), args.Error(1)
}

func (m *MockUserService) DeleteUser(id string) error {
    args := m.Called(id)
    return args.Error(0)
}

func setupRouter() *gin.Engine {
    gin.SetMode(gin.TestMode)
    return gin.New()
}

func TestHealthCheck(t *testing.T) {
    router := setupRouter()
    mockService := new(MockUserService)
    handler := New(mockService)

    router.GET("/health", handler.HealthCheck)

    req, _ := http.NewRequest("GET", "/health", nil)
    w := httptest.NewRecorder()
    router.ServeHTTP(w, req)

    assert.Equal(t, http.StatusOK, w.Code)

    var response map[string]interface{}
    err := json.Unmarshal(w.Body.Bytes(), &response)
    assert.NoError(t, err)
    assert.Equal(t, "healthy", response["status"])
    assert.Equal(t, "golang-app", response["service"])
}

func TestCreateUser(t *testing.T) {
    router := setupRouter()
    mockService := new(MockUserService)
    handler := New(mockService)

    router.POST("/users", handler.CreateUser)

    // Test successful creation
    user := &models.User{
        ID:        "123",
        FirstName: "John",
        LastName:  "Doe",
        Email:     "john.doe@example.com",
        Age:       25,
    }

    mockService.On("CreateUser", mock.AnythingOfType("models.CreateUserRequest")).Return(user, nil)

    reqBody := models.CreateUserRequest{
        FirstName: "John",
        LastName:  "Doe",
        Email:     "john.doe@example.com",
        Age:       25,
    }

    jsonBody, _ := json.Marshal(reqBody)
    req, _ := http.NewRequest("POST", "/users", bytes.NewBuffer(jsonBody))
    req.Header.Set("Content-Type", "application/json")
    w := httptest.NewRecorder()
    router.ServeHTTP(w, req)

    assert.Equal(t, http.StatusCreated, w.Code)
    mockService.AssertExpectations(t)
}

func TestGetUser(t *testing.T) {
    router := setupRouter()
    mockService := new(MockUserService)
    handler := New(mockService)

    router.GET("/users/:id", handler.GetUser)

    // Test successful retrieval
    user := &models.User{
        ID:        "123",
        FirstName: "John",
        LastName:  "Doe",
        Email:     "john.doe@example.com",
        Age:       25,
    }

    mockService.On("GetUser", "123").Return(user, nil)

    req, _ := http.NewRequest("GET", "/users/123", nil)
    w := httptest.NewRecorder()
    router.ServeHTTP(w, req)

    assert.Equal(t, http.StatusOK, w.Code)
    mockService.AssertExpectations(t)
}

package service

import (
    "testing"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
    "golang-app/internal/models"
    "golang-app/internal/repository"
)

// MockUserRepository is a mock implementation of UserRepository
type MockUserRepository struct {
    mock.Mock
}

func (m *MockUserRepository) Create(user *models.User) error {
    args := m.Called(user)
    return args.Error(0)
}

func (m *MockUserRepository) GetByID(id string) (*models.User, error) {
    args := m.Called(id)
    if args.Get(0) == nil {
        return nil, args.Error(1)
    }
    return args.Get(0).(*models.User), args.Error(1)
}

func (m *MockUserRepository) GetAll() ([]*models.User, error) {
    args := m.Called()
    return args.Get(0).([]*models.User), args.Error(1)
}

func (m *MockUserRepository) Update(user *models.User) error {
    args := m.Called(user)
    return args.Error(0)
}

func (m *MockUserRepository) Delete(id string) error {
    args := m.Called(id)
    return args.Error(0)
}

func (m *MockUserRepository) ExistsByEmail(email string) bool {
    args := m.Called(email)
    return args.Bool(0)
}

func TestCreateUser(t *testing.T) {
    mockRepo := new(MockUserRepository)
    service := New(mockRepo)

    req := models.CreateUserRequest{
        FirstName: "John",
        LastName:  "Doe",
        Email:     "john.doe@example.com",
        Age:       25,
    }

    // Test successful creation
    mockRepo.On("ExistsByEmail", req.Email).Return(false)
    mockRepo.On("Create", mock.AnythingOfType("*models.User")).Return(nil)

    user, err := service.CreateUser(req)

    assert.NoError(t, err)
    assert.NotNil(t, user)
    assert.Equal(t, req.FirstName, user.FirstName)
    assert.Equal(t, req.Email, user.Email)
    mockRepo.AssertExpectations(t)
}

func TestCreateUser_DuplicateEmail(t *testing.T) {
    mockRepo := new(MockUserRepository)
    service := New(mockRepo)

    req := models.CreateUserRequest{
        FirstName: "John",
        LastName:  "Doe",
        Email:     "john.doe@example.com",
        Age:       25,
    }

    // Test duplicate email
    mockRepo.On("ExistsByEmail", req.Email).Return(true)

    user, err := service.CreateUser(req)

    assert.Error(t, err)
    assert.Nil(t, user)
    assert.Equal(t, ErrDuplicateEmail, err)
    mockRepo.AssertExpectations(t)
}

func TestGetUser(t *testing.T) {
    mockRepo := new(MockUserRepository)
    service := New(mockRepo)

    expectedUser := &models.User{
        ID:        "123",
        FirstName: "John",
        LastName:  "Doe",
        Email:     "john.doe@example.com",
        Age:       25,
    }

    // Test successful retrieval
    mockRepo.On("GetByID", "123").Return(expectedUser, nil)

    user, err := service.GetUser("123")

    assert.NoError(t, err)
    assert.NotNil(t, user)
    assert.Equal(t, expectedUser.ID, user.ID)
    assert.Equal(t, expectedUser.Email, user.Email)
    mockRepo.AssertExpectations(t)
}

func TestGetUser_NotFound(t *testing.T) {
    mockRepo := new(MockUserRepository)
    service := New(mockRepo)

    // Test user not found
    mockRepo.On("GetByID", "nonexistent").Return(nil, repository.ErrUserNotFound)

    user, err := service.GetUser("nonexistent")

    assert.Error(t, err)
    assert.Nil(t, user)
    assert.Equal(t, repository.ErrUserNotFound, err)
    mockRepo.AssertExpectations(t)
}