Go App Engine Memcache 服务故障测试：挑战与限制

package myapp_test

import (
    "context"
    "testing"

    "google.golang.org/appengine/v2/memcache" // 使用v2兼容包
    "google.golang.org/appengine/v2/aetest"
)

func TestMemcacheInteraction(t *testing.T) {
    inst, err := aetest.NewInstance(nil)
    if err != nil {
        t.Fatalf("Failed to create aetest instance: %v", err)
    }
    defer inst.Close()

    req, err := inst.NewRequest("GET", "/", nil)
    if err != nil {
        t.Fatalf("Failed to create request: %v", err)
    }
    ctx := aetest.With =Context(req) // 获取带有App Engine上下文的context

    // 尝试向Memcache写入数据
    item := &memcache.Item{
        Key:   "my-key",
        Value: []byte("my-value"),
    }
    if err := memcache.Set(ctx, item); err != nil {
        t.Errorf("Failed to set item in memcache: %v", err)
    }

    // 尝试从Memcache读取数据
    retrievedItem, err := memcache.Get(ctx, "my-key")
    if err != nil {
        t.Errorf("Failed to get item from memcache: %v", err)
    }
    if string(retrievedItem.Value) != "my-value" {
        t.Errorf("Retrieved value mismatch, got %s, want %s", string(retrievedItem.Value), "my-value")
    }
}

// 接口定义
type MemcacheClient interface {
    Set(ctx context.Context, item *memcache.Item) error
    Get(ctx context.Context, key string) (*memcache.Item, error)
    // ... 其他Memcache操作
}

// 生产环境中的实现
type appEngineMemcacheClient struct{}

func (c *appEngineMemcacheClient) Set(ctx context.Context, item *memcache.Item) error {
    return memcache.Set(ctx, item)
}

func (c *appEngineMemcacheClient) Get(ctx context.Context, key string) (*memcache.Item, error) {
    return memcache.Get(ctx, key)
}

// 应用程序代码中使用接口
type MyService struct {
    cacheClient MemcacheClient
}

func NewMyService(client MemcacheClient) *MyService {
    return &MyService{cacheClient: client}
}

func (s *MyService) GetData(ctx context.Context, key string) (string, error) {
    item, err := s.cacheClient.Get(ctx, key)
    if err != nil && err != memcache.ErrCacheMiss {
        // 模拟这里处理Memcache服务故障
        return "", fmt.Errorf("memcache service error: %w", err)
    }
    if item != nil {
        return string(item.Value), nil
    }
    // 从数据库获取数据并缓存
    data := "data from db" // 假设从数据库获取
    s.cacheClient.Set(ctx, &memcache.Item{Key: key, Value: []byte(data)})
    return data, nil
}

// 测试中的Mock实现
type MockMemcacheClient struct {
    SetFunc func(ctx context.Context, item *memcache.Item) error
    GetFunc func(ctx context.Context, key string) (*memcache.Item, error)
}

func (m *MockMemcacheClient) Set(ctx context.Context, item *memcache.Item) error {
    return m.SetFunc(ctx, item)
}

func (m *MockMemcacheClient) Get(ctx context.Context, key string) (*memcache.Item, error) {
    return m.GetFunc(ctx, key)
}

func TestMyService_GetData_MemcacheFailure(t *testing.T) {
    mockClient := &MockMemcacheClient{
        GetFunc: func(ctx context.Context, key string) (*memcache.Item, error) {
            return nil, errors.New("simulated memcache service failure") // 模拟故障
        },
        SetFunc: func(ctx context.Context, item *memcache.Item) error {
            return nil // 不关心Set的模拟
        },
    }
    service := NewMyService(mockClient)

    // 注意：这里不再需要aetest实例，因为我们mocked了MemcacheClient接口
    // 但是，如果MyService内部还直接使用了App Engine的其他API，仍然需要aetest上下文
    // 对于纯粹测试Memcache故障路径，此方法更灵活
    ctx := context.Background() // 或者使用aetest的上下文

    data, err := service.GetData(ctx, "test-key")
    if err == nil {
        t.Errorf("Expected an error due to memcache failure, got nil")
    }
    if !strings.Contains(err.Error(), "memcache service error") {
        t.Errorf("Expected 'memcache service error', got %v", err)
    }
    _ = data // 忽略数据
}