Cache Provider v0.1.1

package main

import (
    "context"
    "log"
    "time"
    
    "go.fork.vn/di"
    "go.fork.vn/config"
    "go.fork.vn/cache"
    "go.fork.vn/cache/driver"
)

func main() {
    // Tạo DI container
    container := di.New()
    
    // Đăng ký provider config (nếu sử dụng service config)
    configProvider := config.NewServiceProvider()
    container.Register(configProvider)
    
    // Đăng ký Cache provider
    cacheProvider := cache.NewServiceProvider()
    container.Register(cacheProvider)
    
    // Boot các service providers
    container.Boot()
    
    // Lấy Cache manager sử dụng MustMake
    // MustMake sẽ panic nếu service không tồn tại hoặc không thể tạo được
    cacheManager := container.MustMake("cache").(cache.Manager)
    
    // Tạo context với timeout
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    
    // Lưu dữ liệu vào cache
    err := cacheManager.Set("user:1", map[string]interface{}{
        "name":      "Nguyễn Văn A",
        "email":     "nguyen@example.com",
        "createdAt": time.Now(),
    }, 1*time.Hour)
    if err != nil {
        log.Fatal("Không thể lưu vào cache:", err)
    }
    
    // Lấy dữ liệu từ cache
    userData, exists := cacheManager.Get("user:1")
    if exists {
        log.Printf("Dữ liệu user từ cache: %+v\n", userData)
    }
    
    log.Println("Cache hoạt động thành công!")
}

// Khởi tạo context với timeout
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// Kiểm tra key có tồn tại không
exists := cacheManager.Has("user:1")
log.Printf("Key user:1 tồn tại: %v\n", exists)

// Remember pattern - lazy computation
userData, err := cacheManager.Remember("expensive_user:1", 1*time.Hour, func() (interface{}, error) {
    // Function này chỉ được gọi khi cache miss
    return fetchExpensiveUserData(1)
})
if err != nil {
    log.Fatal("Remember pattern thất bại:", err)
}

// Batch operations - lấy nhiều keys cùng lúc
userKeys := []string{"user:1", "user:2", "user:3"}
foundUsers, missingKeys := cacheManager.GetMultiple(userKeys)
log.Printf("Tìm thấy users: %v, thiếu keys: %v\n", len(foundUsers), missingKeys)

// Batch set - lưu nhiều values cùng lúc  
userDataMap := map[string]interface{}{
    "user:4": map[string]string{"name": "User 4"},
    "user:5": map[string]string{"name": "User 5"},
}
err = cacheManager.SetMultiple(userDataMap, 30*time.Minute)
if err != nil {
    log.Fatal("Batch set thất bại:", err)
}

// Xóa key
err = cacheManager.Delete("user:1")
if err != nil {
    log.Fatal("Không thể xóa key:", err)
}

// Xóa nhiều keys cùng lúc
err = cacheManager.DeleteMultiple([]string{"user:2", "user:3"})
if err != nil {
    log.Fatal("Batch delete thất bại:", err)
}

// Xóa toàn bộ cache
err = cacheManager.Clear()
if err != nil {
    log.Fatal("Không thể xóa toàn bộ cache:", err)
}

// Lấy Cache Manager
cacheManager := container.MustMake("cache").(cache.Manager)

// Lấy Cache Manager thông qua alias
manager := container.MustMake("cache.manager").(cache.Manager)

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

func TestYourFunction(t *testing.T) {
    // Tạo mock manager
    mockManager := mocks.NewMockManager(t)
    
    // Thiết lập expectations cơ bản
    mockManager.On("Get", "user:1").Return(userData, true)
    mockManager.On("Set", "user:1", mock.Anything, mock.Anything).Return(nil)
    mockManager.On("Has", "user:1").Return(true)
    mockManager.On("Delete", "user:1").Return(nil)
    
    // Mock cho Remember pattern
    mockManager.On("Remember", "expensive_key", mock.Anything, mock.AnythingOfType("func() (interface{}, error)")).
        Run(func(args mock.Arguments) {
            // Giả lập thực thi callback function
            callback := args.Get(2).(func() (interface{}, error))
            // Chạy callback
            callback()
        }).
        Return(mockData, nil)
    
    // Mock cho batch operations
    mockManager.On("GetMultiple", []string{"user:1", "user:2"}).
        Return(map[string]interface{}{"user:1": userData}, []string{"user:2"})
    
    mockManager.On("SetMultiple", mock.Anything, mock.Anything).Return(nil)
    mockManager.On("DeleteMultiple", mock.Anything).Return(nil)
    
    // Mock cho Clear và Close
    mockManager.On("Clear").Return(nil)
    mockManager.On("Close").Return(nil)
    
    // Sử dụng mock trong tests
    err := YourFunction(mockManager)
    
    // Kiểm tra kết quả
    assert.NoError(t, err)
    mockManager.AssertExpectations(t)
}

// Ví dụ về hàm sử dụng Cache Manager
func YourFunction(m cache.Manager) error {
    // Set cache
    if err := m.Set("test", "data", 1*time.Hour); err != nil {
        return err
    }
    
    // Get from cache
    data, exists := m.Get("test")
    if !exists {
        return fmt.Errorf("cache miss")
    }
    
    // Do something with data...
    
    return nil
}

// testHelper.go
package cache_test

import (
    "testing"
    "time"
    
    "go.fork.vn/cache"
    "go.fork.vn/cache/driver"
    "go.fork.vn/cache/config"
    "github.com/stretchr/testify/require"
)

func setupTestManager(t *testing.T) (cache.Manager, func()) {
    // Tạo manager cho test
    manager := cache.NewManager()
    
    // Thêm memory driver cho test
    memConfig := config.DriverMemoryConfig{
        DefaultTTL:      60, // 1 minute for fast test
        CleanupInterval: 10, // 10 seconds
        MaxItems:        100,
    }
    memDriver := driver.NewMemoryDriver(memConfig)
    manager.AddDriver("test_memory", memDriver)
    manager.SetDefaultDriver("test_memory")
    
    // Tạo cleanup function
    cleanup := func() {
        err := manager.Clear()
        require.NoError(t, err)
        err = manager.Close()
        require.NoError(t, err)
    }
    
    return manager, cleanup
}