Config

package main

import (
    "fmt"
    "log"
    
    "go.fork.vn/di"
    "go.fork.vn/config"
)

func main() {
    // Initialize application with DI container
    app := di.New()
    
    // Register config service provider
    app.Register(config.NewServiceProvider())
    
    // Get config manager from container
    container := app.Container()
    cfg := container.MustMake("config").(config.Manager)
    
    // Configure and read config file
    cfg.SetConfigName("config")
    cfg.AddConfigPath(".")
    cfg.AddConfigPath("./configs")
    
    // Set some default values
    cfg.SetDefault("app.name", "MyApp")
    cfg.SetDefault("app.port", 8080)
    
    // Read configuration
    if err := cfg.ReadInConfig(); err != nil {
        log.Printf("Warning: Could not read config file: %v\n", err)
        log.Println("Continuing with defaults and environment variables...")
    }
    
    // Enable environment variables
    cfg.SetEnvPrefix("MYAPP")
    cfg.AutomaticEnv()
    
    // Use configuration
    if appName, ok := cfg.GetString("app.name"); ok {
        fmt.Printf("Application Name: %s\n", appName)
    }
    
    if port, ok := cfg.GetInt("app.port"); ok {
        fmt.Printf("Port: %d\n", port)
    }
}

package main

import (
	"fmt"
	"log"

	"go.fork.vn/di"
	"go.fork.vn/config"
)

func main() {
	// Khởi tạo ứng dụng với DI container
	app := di.New()
	
	// Đăng ký config service provider
	app.Register(config.NewServiceProvider())
	
	// Lấy config manager từ container
	container := app.Container()
	cfg := container.Get("config").(config.Manager)
	
	// Cấu hình và đọc file config
	cfg.SetConfigName("config")
	cfg.AddConfigPath(".")
	cfg.AddConfigPath("./configs")
	
	// Thiết lập một số giá trị mặc định
	cfg.SetDefault("app.name", "MyApp")
	cfg.SetDefault("app.port", 8080)
	cfg.SetDefault("database.timeout", "30s")
	
	// Đọc cấu hình từ file
	err := cfg.ReadInConfig()
	if err != nil {
		log.Printf("Cảnh báo: Không thể đọc file cấu hình: %v\n", err)
		log.Println("Tiếp tục với cấu hình mặc định và biến môi trường...")
	}
	
	// Kích hoạt hỗ trợ biến môi trường
	cfg.SetEnvPrefix("MYAPP")
	cfg.AutomaticEnv()
	
	// Sử dụng cấu hình
	if appName, ok := cfg.GetString("app.name"); ok {
		fmt.Printf("Tên ứng dụng: %s\n", appName)
	}
	
	if port, ok := cfg.GetInt("app.port"); ok {
		fmt.Printf("Cổng: %d\n", port)
	}
	
	// Khởi động các dịch vụ với cấu hình đã đọc...
}

// Đọc từ file chính
cfg.SetConfigName("config")
cfg.AddConfigPath(".")
cfg.ReadInConfig()

// Gộp với file cấu hình môi trường
cfg.SetConfigName("config.development")
err := cfg.MergeInConfig()
if err != nil {
	log.Printf("Cảnh báo: Không tìm thấy file cấu hình môi trường: %v", err)
}

// Gộp với file cấu hình local (không theo dõi bởi git)
cfg.SetConfigName("config.local")
cfg.MergeInConfig() // Bỏ qua lỗi nếu không có

// Định nghĩa struct cho cấu hình
type AppConfig struct {
	Name    string `mapstructure:"name"`
	Version string `mapstructure:"version"`
	Server  struct {
		Host string `mapstructure:"host"`
		Port int    `mapstructure:"port"`
		TLS  struct {
			Enabled  bool   `mapstructure:"enabled"`
			CertFile string `mapstructure:"cert_file"`
			KeyFile  string `mapstructure:"key_file"`
		} `mapstructure:"tls"`
	} `mapstructure:"server"`
	Database struct {
		Driver   string `mapstructure:"driver"`
		Host     string `mapstructure:"host"`
		Port     int    `mapstructure:"port"`
		Name     string `mapstructure:"name"`
		User     string `mapstructure:"user"`
		Password string `mapstructure:"password"`
		Options  struct {
			MaxOpenConns int           `mapstructure:"max_open_conns"`
			MaxIdleConns int           `mapstructure:"max_idle_conns"`
			MaxLifetime  time.Duration `mapstructure:"max_lifetime"`
		} `mapstructure:"options"`
	} `mapstructure:"database"`
}

// Ánh xạ toàn bộ cấu hình vào struct
var appConfig AppConfig
err := cfg.Unmarshal(&appConfig)
if err != nil {
	log.Fatalf("Không thể ánh xạ cấu hình: %v", err)
}

fmt.Printf("Tên ứng dụng: %s\n", appConfig.Name)
fmt.Printf("Server sẽ chạy tại: %s:%d\n", appConfig.Server.Host, appConfig.Server.Port)

// Ánh xạ một phần cụ thể của cấu hình
var dbConfig struct {
	Driver   string `mapstructure:"driver"`
	Host     string `mapstructure:"host"`
	Port     int    `mapstructure:"port"`
	Name     string `mapstructure:"name"`
	User     string `mapstructure:"user"`
	Password string `mapstructure:"password"`
}

err = cfg.UnmarshalKey("database", &dbConfig)
if err != nil {
	log.Fatalf("Không thể ánh xạ cấu hình database: %v", err)
}

// Thiết lập callback để xử lý khi cấu hình thay đổi
cfg.OnConfigChange(func(e fsnotify.Event) {
	fmt.Printf("Phát hiện thay đổi cấu hình: %s\n", e.Name)
	
	// Tải lại cấu hình vào struct
	var appConfig AppConfig
	err := cfg.Unmarshal(&appConfig)
	if err != nil {
		log.Printf("Lỗi khi tải lại cấu hình: %v", err)
		return
	}
	
	// Tái khởi tạo các dịch vụ với cấu hình mới
	restartServices(appConfig)
	
	fmt.Println("Đã tải lại cấu hình thành công.")
})

// Bắt đầu theo dõi file cấu hình
cfg.WatchConfig()

// Ví dụ với cấu hình phân cấp trong YAML:
// 
// services:
//   auth:
//     enabled: true
//     providers:
//       - name: oauth
//         config:
//           client_id: '12345'
//           client_secret: 'secret'
//       - name: local
//         config:
//           password_policy:
//             min_length: 8
//             require_symbols: true

// Truy cập các giá trị cấu hình phân cấp
if authEnabled, ok := cfg.GetBool("services.auth.enabled"); ok && authEnabled {
	// Lấy danh sách các providers
	if providers, ok := cfg.GetSlice("services.auth.providers"); ok {
		for i, provider := range providers {
			if providerMap, ok := provider.(map[string]interface{}); ok {
				name := providerMap["name"].(string)
				fmt.Printf("Provider %d: %s\n", i+1, name)
				
				// Truy cập cấu hình cụ thể của provider
				configKey := fmt.Sprintf("services.auth.providers.%d.config", i)
				if providerConfig, ok := cfg.GetMap(configKey); ok {
					// Xử lý cấu hình provider
					fmt.Printf("  Cấu hình: %v\n", providerConfig)
				}
			}
		}
	}
}

import (
	"testing"
	
	"go.fork.vn/config/mocks"
	"github.com/stretchr/testify/assert"
)

func TestServiceWithConfig(t *testing.T) {
	// Tạo mock manager
	mockCfg := &mocks.MockManager{}
	
	// Thiết lập expectations sử dụng EXPECT()
	mockCfg.EXPECT().GetBool("service.enabled").Return(true, true)
	mockCfg.EXPECT().GetInt("service.port").Return(8080, true)
	mockCfg.EXPECT().GetDuration("service.timeout").Return(30*time.Second, true)
	
	// Khởi tạo service với mock config
	service := NewService(mockCfg)
	
	// Kiểm tra kết quả
	assert.True(t, service.IsEnabled())
	assert.Equal(t, 8080, service.Port())
	
	// Xác thực tất cả expectations đã được gọi
	mockCfg.AssertExpectations(t)
}

func TestServiceWithTraditionalMock(t *testing.T) {
	mockCfg := &mocks.MockManager{}
	
	// Thiết lập mock responses với On()
	mockCfg.On("GetString", "app.name").Return("TestApp", true)
	mockCfg.On("Has", "feature.enabled").Return(true)
	mockCfg.On("Set", "runtime.status", mock.Anything).Return(nil)
	
	// Test code
	name, exists := mockCfg.GetString("app.name")
	assert.True(t, exists)
	assert.Equal(t, "TestApp", name)
	
	hasFeature := mockCfg.Has("feature.enabled")
	assert.True(t, hasFeature)
	
	err := mockCfg.Set("runtime.status", "running")
	assert.NoError(t, err)
	
	// Xác thực expectations
	mockCfg.AssertExpectations(t)
}

func TestErrorHandling(t *testing.T) {
	mockCfg := &mocks.MockManager{}
	
	// Mock trả về lỗi cho Unmarshal
	expectedErr := errors.New("unmarshal failed")
	mockCfg.EXPECT().Unmarshal(mock.Anything).Return(expectedErr)
	
	// Mock trả về key không tồn tại
	mockCfg.EXPECT().GetString("nonexistent.key").Return("", false)
	
	// Test error cases
	var config struct{}
	err := mockCfg.Unmarshal(&config)
	assert.Error(t, err)
	assert.Equal(t, expectedErr, err)
	
	value, exists := mockCfg.GetString("nonexistent.key")
	assert.False(t, exists)
	assert.Empty(t, value)
	
	mockCfg.AssertExpectations(t)
}