如何在Terraform Provider测试中避免硬编码TypeSet哈希索引？

在基于Terraform Provider Go SDK开发自定义Provider时，TypeSet类型的资源属性在状态存储中会基于元素值生成哈希索引。测试过程中硬编码这些索引值会导致维护成本高（比如元素值变更时需要同步修改测试代码），如何避免这种情况？

Terraform官方文档说明：

TypeSet项在状态中存储的索引值由集合属性的哈希值计算而来。

例如状态中TypeSet的存储格式：

"ingress.#": "2",
"ingress.1061987227.cidr_blocks.#": "1",
"ingress.1061987227.cidr_blocks.0": "10.0.0.0/8",
"ingress.493694946.cidr_blocks.#": "2",
"ingress.493694946.cidr_blocks.0": "0.0.0.0/0"

当前测试中硬编码索引的示例：

resource.TestCheckResourceAttr(resourceName, "workspace_configs.368698502.client_ip_header", "Fastly-Client-IP"),
resource.TestCheckResourceAttr(resourceName, "workspace_configs.368698502.listener_protocols.1552086545", "https"),

解决方案 #

方法一：使用官方内置的TestCheckTypeSetElemAttrs（推荐） #

Terraform SDK v2提供了专门用于验证TypeSet元素的函数，无需关心哈希索引，直接指定预期的属性键值对即可，这是最简洁且官方推荐的方式。

示例代码

resource.Test(t, resource.TestCase{
    // 省略其他测试配置（如Providers、Steps等）
    Check: resource.ComposeTestCheckFunc(
        // 验证顶层TypeSet元素属性
        resource.TestCheckTypeSetElemAttrs(
            "sigsci_corp_cloudwaf_instance.test",
            "workspace_configs",
            map[string]string{
                "client_ip_header":  "Fastly-Client-IP",
                "instance_location": "advanced",
                "listener_protocols.#": "1",
            },
        ),
        // 验证嵌套TypeSet元素的属性
        resource.TestCheckTypeSetElemNestedAttrs(
            "sigsci_corp_cloudwaf_instance.test",
            "workspace_configs.*.routes",
            map[string]string{
                "connection_pooling": "true",
                "certificate_ids.#":  "0",
            },
        ),
    ),
})

该函数会自动遍历TypeSet中的所有元素，检查是否存在完全匹配指定属性的项，无需手动处理哈希索引。

方法二：动态计算哈希索引 #

如果需要精准定位某个特定元素，可以调用Terraform SDK的哈希计算函数，动态生成索引值，替代硬编码。

示例代码

import (
    "fmt"
    "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

// 计算给定配置对应的TypeSet哈希索引
func calculateConfigHash(schema *schema.Schema, config map[string]interface{}) int {
    // 模拟ResourceData结构用于哈希计算
    data := schema.TestResourceDataRaw(nil, schema, config)
    hash, err := schema.HashResource(schema)(data)
    if err != nil {
        panic(fmt.Sprintf("failed to calculate hash: %v", err))
    }
    return hash
}

// 在测试中使用动态生成的索引
func TestAccCorpCloudWAFInstance(t *testing.T) {
    // 定义预期的配置结构
    expectedWorkspaceConfig := map[string]interface{}{
        "client_ip_header":  "Fastly-Client-IP",
        "instance_location": "advanced",
        "listener_protocols": []interface{}{"https"},
    }
    // 假设workspaceConfigsSchema是你定义的workspace_configs字段的schema
    configHash := calculateConfigHash(workspaceConfigsSchema, expectedWorkspaceConfig)

    resource.Test(t, resource.TestCase{
        // 省略其他测试配置
        Check: resource.ComposeTestCheckFunc(
            resource.TestCheckResourceAttr(
                "sigsci_corp_cloudwaf_instance.test",
                fmt.Sprintf("workspace_configs.%d.client_ip_header", configHash),
                "Fastly-Client-IP",
            ),
            // 其他动态生成的检查项
        ),
    })
}

注意：需要确保传入的schema与Provider中定义的workspace_configs字段的schema完全一致，才能计算出与Terraform状态中一致的哈希值。

方法三：自定义TestCheckResourceAttrWith函数 #

通过编写自定义检查逻辑，遍历TypeSet的所有元素，验证是否存在符合预期的项，适用于复杂的自定义验证场景。

示例代码

import (
    "fmt"
    "strings"
    "github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
)

// 自定义检查workspace_configs属性的函数
func checkWorkspaceConfig(expectedClientIP, expectedLocation string) resource.TestCheckFunc {
    return func(s *terraform.State) error {
        // 获取目标资源状态
        rs, ok := s.RootModule().Resources["sigsci_corp_cloudwaf_instance.test"]
        if !ok {
            return fmt.Errorf("target resource not found in state")
        }

        // 遍历状态中的所有属性，查找匹配的workspace_configs元素
        attributes := rs.Primary.Attributes
        for key, val := range attributes {
            // 筛选出client_ip_header属性
            if strings.HasPrefix(key, "workspace_configs.") && strings.HasSuffix(key, ".client_ip_header") {
                // 拼接对应的instance_location属性键
                locationKey := strings.Replace(key, ".client_ip_header", ".instance_location", 1)
                locationVal := attributes[locationKey]

                // 检查是否匹配预期值
                if val == expectedClientIP && locationVal == expectedLocation {
                    // 验证listener_protocols数量
                    protoCountKey := strings.Replace(key, ".client_ip_header", ".listener_protocols.#", 1)
                    if attributes[protoCountKey] != "1" {
                        return fmt.Errorf("listener_protocols count mismatch: expected 1, got %s", attributes[protoCountKey])
                    }
                    // 验证listener_protocols包含https
                    protoPrefix := strings.Replace(key, ".client_ip_header", ".listener_protocols.", 1)
                    hasHTTPS := false
                    for k, v := range attributes {
                        if strings.HasPrefix(k, protoPrefix) && v == "https" {
                            hasHTTPS = true
                            break
                        }
                    }
                    if !hasHTTPS {
                        return fmt.Errorf("https not found in listener_protocols")
                    }
                    // 所有验证通过，返回nil
                    return nil
                }
            }
        }
        return fmt.Errorf("no workspace_config matching expected attributes found")
    }
}

// 在测试中使用自定义检查函数
func TestAccCorpCloudWAFInstance(t *testing.T) {
    resource.Test(t, resource.TestCase{
        // 省略其他测试配置
        Check: resource.ComposeTestCheckFunc(
            checkWorkspaceConfig("Fastly-Client-IP", "advanced"),
            // 其他检查项
        ),
    })
}

内容的提问来源于stack exchange，提问作者Grokify