我想通过测试来确保，对于如下定义的每个 APIErrorCode 常量，映射 APIErrorCodeMessages 包含一个条目。如何在 Go 中枚举特定类型的所有常量？

// APIErrorCode represents the API error code
type APIErrorCode int

const (
    // APIErrorCodeAuthentication represents an authentication error and corresponds with HTTP 401
    APIErrorCodeAuthentication APIErrorCode = 1000
    // APIErrorCodeInternalError represents an unknown internal error and corresponds with HTTP 500
    APIErrorCodeInternalError APIErrorCode = 1001
)

// APIErrorCodeMessages holds all error messages for APIErrorCodes
var APIErrorCodeMessages = map[APIErrorCode]string{
    APIErrorCodeInternalError: "Internal Error",
}

我查看了 reflect 和 go/importer 并尝试了 tools/cmd/stringer 但没有成功。

最佳答案

基本概念

reflect包不提供对导出标识符的访问，因为不能保证它们将链接到可执行二进制文件(因此在运行时可用)；更多相关信息:Splitting client/server code ;和 How to remove unused code at compile time?

这是源代码级别的检查。我要做的是编写一个测试来检查错误代码常量的数量是否与映射长度匹配。下面的解决方案只会检查 map 长度。改进版本(见下文)还可以检查映射中的键是否也与常量声明的值匹配。

您可以使用 go/parser解析包含错误代码常量的 Go 文件，它给你一个 ast.File描述文件，包含常量声明。您只需要遍历它，并计算错误代码常量声明。

假设您的原始文件名为 "errcodes.go"，编写一个名为 "errcodes_test.go" 的测试文件。

这就是测试函数的样子:

func TestMap(t *testing.T) {
    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "errcodes.go", nil, 0)
    if err != nil {
        t.Errorf("Failed to parse file: %v", err)
        return
    }

    errCodeCount := 0
    // Range through declarations:
    for _, dd := range f.Decls {
        if gd, ok := dd.(*ast.GenDecl); ok {
            // Find constant declrations:
            if gd.Tok == token.CONST {
                for _, sp := range gd.Specs {
                    if valSp, ok := sp.(*ast.ValueSpec); ok {
                        for _, name := range valSp.Names {
                            // Count those that start with "APIErrorCode"
                            if strings.HasPrefix(name.Name, "APIErrorCode") {
                                errCodeCount++
                            }
                        }
                    }
                }
            }
        }
    }
    if exp, got := errCodeCount, len(APIErrorCodeMessages); exp != got {
        t.Errorf("Expected %d err codes, got: %d", exp, got)
    }
}

运行 go test 将导致:

--- FAIL: TestMap (0.00s)
    errcodes_test.go:39: Expected 2 err codes, got: 1

测试正确显示有 2 个常量错误代码声明，但 APIErrorCodeMessages 映射仅包含 1 个条目。

如果我们现在“完成” map :

var APIErrorCodeMessages = map[APIErrorCode]string{
    APIErrorCodeInternalError:  "Internal Error",
    APIErrorCodeAuthentication: "asdf",
}

然后再次运行go test:

PASS

注意:这是一个风格问题，但是大循环可以这样写以减少嵌套层次:

// Range through declarations:
for _, dd := range f.Decls {
    gd, ok := dd.(*ast.GenDecl)
    if !ok {
        continue
    }
    // Find constant declrations:
    if gd.Tok != token.CONST {
        continue
    }
    for _, sp := range gd.Specs {
        valSp, ok := sp.(*ast.ValueSpec)
        if !ok {
            continue
        }
        for _, name := range valSp.Names {
            // Count those that start with "APIErrorCode"
            if strings.HasPrefix(name.Name, "APIErrorCode") {
                errCodeCount++
            }
        }
    }
}

完整、改进的检测

这次我们将检查常量的确切类型，而不是它们的名称。我们还将收集所有常量值，最后我们将检查每个常量值是否在 map 中。如果缺少某些内容，我们将打印缺失代码的确切值。

这里是:

func TestMap(t *testing.T) {
    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "errcodes.go", nil, 0)
    if err != nil {
        t.Errorf("Failed to parse file: %v", err)
        return
    }

    var keys []APIErrorCode
    // Range through declarations:
    for _, dd := range f.Decls {
        gd, ok := dd.(*ast.GenDecl)
        if !ok {
            continue
        }
        // Find constant declrations:
        if gd.Tok != token.CONST {
            continue
        }
        for _, sp := range gd.Specs {
            // Filter by APIErrorCode type:
            valSp, ok := sp.(*ast.ValueSpec)
            if !ok {
                continue
            }
            if id, ok2 := valSp.Type.(*ast.Ident); !ok2 ||
                id.Name != "APIErrorCode" {
                continue
            }
            // And gather the constant values in keys:
            for _, value := range valSp.Values {
                bslit, ok := value.(*ast.BasicLit)
                if !ok {
                    continue
                }
                keyValue, err := strconv.Atoi(bslit.Value)
                if err != nil {
                    t.Errorf("Could not parse value from %v: %v",
                        bslit.Value, err)
                }
                keys = append(keys, APIErrorCode(keyValue))
            }
        }
    }

    for _, key := range keys {
        if _, found := APIErrorCodeMessages[key]; !found {
            t.Errorf("Could not found key in map: %v", key)
        }
    }
}

使用“不完整的”APIErrorCodeMessages 映射运行go test，我们得到以下输出:

--- FAIL: TestMap (0.00s)
    errcodes_test.go:58: Could not found key in map: 1000

关于testing - 如何枚举某种类型的常量，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43584377/