Golang中如何测试错误边界条件 使用fuzz测试验证错误处理逻辑

package configparser

import (
    "errors"
    "fmt"
    "strconv"
    "strings"
    "testing"
)

// ParseConfigValue 模拟一个解析配置值的函数，可能因各种非法输入而返回错误
// 期望输入格式为 "key=value"，其中 value 必须是有效的整数。
func ParseConfigValue(input string) (int, error) {
    parts := strings.Split(input, "=")
    if len(parts) != 2 {
        return 0, fmt.Errorf("invalid format: expected 'key=value', got '%s'", input)
    }

    key := strings.TrimSpace(parts[0])
    valueStr := strings.TrimSpace(parts[1])

    if key == "" {
        return 0, errors.New("config key cannot be empty")
    }

    val, err := strconv.Atoi(valueStr)
    if err != nil {
        // 包装原始错误，提供更多上下文信息
        return 0, fmt.Errorf("value '%s' is not a valid integer for key '%s': %w", valueStr, key, err)
    }
    return val, nil
}

// FuzzParseConfigValue 是针对 ParseConfigValue 的 Fuzz 测试
func FuzzParseConfigValue(f *testing.F) {
    // 添加一些种子语料（seed corpus），包括有效和无效的输入。
    // Fuzzer会基于这些种子生成更多变异的输入。
    f.Add("timeout=100")
    f.Add("retries=5")
    f.Add("max_connections=10000")
    f.Add("invalid_format")             // 缺少等号
    f.Add("key_only=")                  // 值为空
    f.Add("=value")                     // 键为空
    f.Add("malformed_value=abc")        // 值不是数字
    f.Add("long_key_name_with_some_data=1234567890") // 长字符串
    f.Add(" key = 123 ")                // 包含空格
    f.Add("key=1.23")                   // 浮点数
    f.Add("key=9223372036854775807")    // int64 max
    f.Add("key=-9223372036854775808")   // int64 min
    f.Add("key=9223372036854775808")    // 溢出 int64 max

    // Fuzz 函数的核心逻辑
    f.Fuzz(func(t *testing.T, input string) {
        val, err := ParseConfigValue(input)

        // 核心断言逻辑：根据输入特征判断预期行为
        parts := strings.Split(input, "=")

        // 1. 检查输入格式是否为 "key=value"
        if len(parts) != 2 {
            if err == nil {
                t.Errorf("For input '%s', expected 'invalid format' error, got nil", input)
            } else if !strings.Contains(err.Error(), "invalid format") {
                t.Errorf("For input '%s', expected 'invalid format' error, got %v", input, err)
            }
            return // 格式错误，后续检查无意义
        }

        key := strings.TrimSpace(parts[0])
        valueStr := strings.TrimSpace(parts[1])

        // 2. 检查键是否为空
        if key == "" {
            if err == nil {
                t.Errorf("For input '%s', expected 'config key cannot be empty' error, got nil", input)
            } else if !strings.Contains(err.Error(), "config key cannot be empty") {
                t.Errorf("For input '%s', expected 'config key cannot be empty' error, got %v", input, err)
            }
            return // 键为空，后续检查无意义
        }

        // 3. 尝试将值字符串转换为整数，判断其是否为有效整数
        _, parseErr := strconv.Atoi(valueStr)

        if parseErr != nil { // 预期值转换会失败
            if err == nil {
                t.Errorf("For input '%s', expected 'value is not a valid integer' error, got nil", input)
            } else if !strings.Contains(err.Error(), "value is not a valid integer") {
                // 使用 errors.As 检查是否是 strconv.NumError 类型
                var numErr *strconv.NumError
                if !errors.As(err, &numErr) {
                    t.Errorf("For input '%s', expected error to wrap a *strconv.NumError, got %T (%v)", input, err, err)
                }
            }
        } else { // 预期值转换成功，那么 ParseConfigValue 也应该成功
            if err != nil {
                t.Errorf("For input '%s', expected no error, got %v", input, err)
            }
            // 进一步验证解析出的值是否与预期一致
            expectedVal, _ := strconv.Atoi(valueStr)
            if val != expectedVal {
                t.Errorf("For input '%s', expected value %d, got %d", input, expectedVal, val)
            }
            // 还可以增加业务逻辑上的值范围检查，例如 val 必须大于0
            if val < 0 {
                t.Logf("For input '%s', value %d is negative, but no error reported. Consider adding business rule validation.", input, val)
            }
        }
    })
}