Golang中如何进行文本模板的测试

Golang中如何进行文本模板的测试 大家好，我需要对一个文本模板进行测试，检查以下内容：

  • 参数是否传递
  • 传递的参数是否为有效类型

我使用嵌套结构体来为模板填充值

这是模板

package templates

//ConfigMapJSON 包含 configmap json 的变量
const ConfigMapJSON = `{ "apiVersion": "v1", "kind": "ConfigMap", "metadata": { "name": "{{.Name}}", "namespace": "{{.Namespace}}" }, "data": { "DB_HOST": "{{.DBHost}}", "DB_NAME": "{{.DBName}}", "ENV": "{{.ENV}}", "GIT_BRANCH_NAME": "{{.GitBranch}}", "INSTANCE_ENV": "{{.InstanceENV}}", "S3_BUCKET": "{{.S3Bucket}}", "S3_DOMAIN": "{{.S3Domain}}", "S3_REGION": "{{.S3Region}}", "SIMPLESAMLPHP_CONFIG_DIR": "{{.ConfigDir}}" } }`

我使用的结构体

//ConfigMaps 结构体
type ConfigMaps struct {
	Name        string `json:"name"`
	Namespace   string `json:"namespace"`
	DBHost      string `json:"dbhost"`
	DBName      string `json:"dbname"`
	ENV         string `json:"env"`
	GitBranch   string `json:"gitbranch"`
	InstanceENV string `json:"instanceenv"`
	S3Bucket    string `json:"s3bucket"`
	S3Domain    string `json:"s3domain"`
	S3Region    string `json:"s3region"`
	ConfigDir   string `json:"configdir"`
}

执行模板的控制器

//ConfigMapController 函数
func ConfigMapController(val []byte) string {
	var standardLogger = li.NewLogger()

	tmpl, err := template.New("configMap-tmpl").Parse(templates.ConfigMapJSON)
	if err != nil {
		standardLogger.ErrorArg(err)
	}
	err = json.Unmarshal(val, &configMap)
	if err != nil {
		standardLogger.ErrorArg(err)
	}
	var temp bytes.Buffer
	err = tmpl.Execute(&temp, configMap)
	if err != nil {
		standardLogger.ErrorArg(err)
	}
	result := temp.String()
	return result
}

非常感谢任何帮助。


更多关于Golang中如何进行文本模板的测试的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

感谢回复，

我同意你关于使用结构体替代模板的建议，因为我之前使用过结构体并且测试运行良好。 但如果我必须使用模板呢？

更多关于Golang中如何进行文本模板的测试的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


我建议在这种情况下完全不要使用模板，而是声明一个结构体，然后使用 json.Marshal 进行序列化。这样做有以下优势：

  • 无需担心参数类型错误，因为结构体字段是强类型的，不可能出现类型错误
  • 无需担心因模板问题而生成损坏的 JSON

在序列化之前验证结构体字段的正确性，要比验证模板输出容易得多。

在Golang中测试文本模板时，可以使用标准库的testing包和text/template包来验证参数传递和类型有效性。以下是针对你的场景的测试代码示例：

package main

import (
    "bytes"
    "encoding/json"
    "testing"
    "text/template"
)

// 测试模板参数传递和类型有效性
func TestConfigMapTemplate(t *testing.T) {
    // 准备测试数据
    testData := ConfigMaps{
        Name:        "test-config",
        Namespace:   "default",
        DBHost:      "localhost",
        DBName:      "testdb",
        ENV:         "production",
        GitBranch:   "main",
        InstanceENV: "staging",
        S3Bucket:    "my-bucket",
        S3Domain:    "s3.amazonaws.com",
        S3Region:    "us-east-1",
        ConfigDir:   "/etc/config",
    }

    // 将结构体转换为JSON字节
    val, err := json.Marshal(testData)
    if err != nil {
        t.Fatalf("Failed to marshal test data: %v", err)
    }

    // 执行模板控制器
    result := ConfigMapController(val)

    // 验证模板执行结果
    tmpl, err := template.New("configMap-tmpl").Parse(ConfigMapJSON)
    if err != nil {
        t.Fatalf("Failed to parse template: %v", err)
    }

    var expected bytes.Buffer
    err = tmpl.Execute(&expected, testData)
    if err != nil {
        t.Fatalf("Failed to execute template: %v", err)
    }

    if result != expected.String() {
        t.Errorf("Template output mismatch.\nExpected: %s\nGot: %s", expected.String(), result)
    }

    // 测试缺失字段的情况
    incompleteData := ConfigMaps{
        Name:      "incomplete-config",
        Namespace: "default",
        // 故意省略其他字段
    }

    valIncomplete, _ := json.Marshal(incompleteData)
    resultIncomplete := ConfigMapController(valIncomplete)

    // 验证模板能处理缺失字段（应该输出空字符串）
    var incompleteOutput bytes.Buffer
    tmpl.Execute(&incompleteOutput, incompleteData)
    if resultIncomplete != incompleteOutput.String() {
        t.Errorf("Incomplete data handling failed.\nExpected: %s\nGot: %s", incompleteOutput.String(), resultIncomplete)
    }
}

// 测试无效JSON输入
func TestConfigMapTemplate_InvalidJSON(t *testing.T) {
    invalidJSON := []byte(`{"name": 123}`) // 数字而不是字符串

    result := ConfigMapController(invalidJSON)
    
    // 检查是否返回了空结果或错误处理
    if result == "" {
        t.Log("Invalid JSON handled correctly")
    }
}

// 测试类型不匹配的情况
func TestConfigMapTemplate_TypeMismatch(t *testing.T) {
    type WrongType struct {
        Name int `json:"name"` // 错误的类型
    }
    
    wrongData := WrongType{Name: 123}
    val, _ := json.Marshal(wrongData)
    
    result := ConfigMapController(val)
    
    // 验证模板处理非字符串类型
    tmpl, _ := template.New("configMap-tmpl").Parse(ConfigMapJSON)
    var output bytes.Buffer
    tmpl.Execute(&output, wrongData)
    
    if result != output.String() {
        t.Errorf("Type mismatch handling failed.\nExpected: %s\nGot: %s", output.String(), result)
    }
}

这个测试套件包含以下测试：

  1. 正常情况测试：验证所有参数正确传递和渲染
  2. 缺失字段测试：检查模板对缺失字段的处理
  3. 无效JSON测试：验证控制器对无效JSON输入的处理
  4. 类型不匹配测试：测试当JSON包含错误类型时的行为

运行测试：

go test -v

这些测试会验证模板是否正确接收参数，并且能够处理各种数据类型和边界情况。模板引擎会自动处理类型转换，数字类型会被转换为字符串渲染到模板中。

回到顶部