学习编写单元测试

Question

I am trying to learn how to write tests for my code in order to write better code, but I just seem to have the hardest time figuring out how to actually test some code I have written. I have read so many tutorials, most of which seem to only cover functions that add two numbers or mock some database or server.

I have a simple function I wrote below that takes a text template and a CSV file as input and executes the template using the values of the CSV. I have "tested" the code by trial and error, passing files, and printing values, but I would like to learn how to write proper tests for it. I feel that learning to test my own code will help me understand and learn faster and better. Any help is appreciated.

// generateCmds generates configuration commands from a text template using
// the values from a CSV file. Multiple commands in the text template must
// be delimited by a semicolon. The first row of the CSV file is assumed to
// be the header row and the header values are used for key access in the
// text template.
func generateCmds(cmdTmpl string, filename string) ([]string, error) {
    t, err := template.New("cmds").Parse(cmdTmpl)
    if err != nil {
        return nil, fmt.Errorf("parsing template: %v", err)
    }

    f, err := os.Open(filename)
    if err != nil {
        return nil, fmt.Errorf("reading file: %v", err)
    }
    defer f.Close()

    records, err := csv.NewReader(f).ReadAll()
    if err != nil {
        return nil, fmt.Errorf("reading records: %v", err)
    }
    if len(records) == 0 {
        return nil, errors.New("no records to process")
    }

    var (
        b    bytes.Buffer
        cmds []string
        keys = records[0]
        vals = make(map[string]string, len(keys))
    )

    for _, rec := range records[1:] {
        for k, v := range rec {
            vals[keys[k]] = v
        }
        if err := t.Execute(&b, vals); err != nil {
            return nil, fmt.Errorf("executing template: %v", err)
        }
        for _, s := range strings.Split(b.String(), ";") {
            if cmd := strings.TrimSpace(s); cmd != "" {
                cmds = append(cmds, cmd)
            }
        }
        b.Reset()
    }
    return cmds, nil
}

Edit: Thanks for all the suggestions so far! My question was flagged as being too broad, so I have some specific questions regarding my example.

1. Would a test table be useful in a function like this? And, if so, would the test struct need to include the returned cmds string slice and the value of err? For example:

type tmplTest struct {
    name     string   // test name
    tmpl     string   // the text template
    filename string   // CSV file with template values
    expected []string // expected configuration commands
    err      error    // expected error
}

1. How do you handle errors that are supposed to be returned for specific test cases? For example, os.Open() returns an error of type *PathError if an error is encountered. How do I initialize a *PathError that is equivalent to the one returned by os.Open()? Same idea for template.Parse(), template.Execute(), etc.

Edit 2: Below is a test function I came up with. My two question from the first edit still stand.

package cmd

import (
    "testing"
    "strings"
    "path/filepath"
)

type tmplTest struct {
    name     string   // test name
    tmpl     string   // text template to execute
    filename string   // CSV containing template text values
    cmds     []string // expected configuration commands
}

var tests = []tmplTest{
    {"empty_error", ``, "", nil},
    {"file_error", ``, "fake_file.csv", nil},
    {"file_empty_error", ``, "empty.csv", nil},
    {"file_fmt_error", ``, "fmt_err.csv", nil},
    {"template_fmt_error", `{{ }{{`, "test_values.csv", nil},
    {"template_key_error", `{{.InvalidKey}}`, "test_values.csv", nil},
}

func TestGenerateCmds(t *testing.T) {
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            cmds, err := generateCmds(tc.tmpl, filepath.Join("testdata", tc.filename))
            if err != nil {
                // Unexpected error. Fail the test.
                if !strings.Contains(tc.name, "error") {
                    t.Fatal(err)
                }
                // TODO: Otherwise, check that the function failed at the expected point.
            }
            if tc.cmds == nil && cmds != nil {
                t.Errorf("expected no commands; got %d", len(cmds))
            }
            if len(cmds) != len(tc.cmds) {
                t.Errorf("expected %d commands; got %d", len(tc.cmds), len(cmds))
            }
            for i := range cmds {
                if cmds[i] != tc.cmds[i] {
                    t.Errorf("expected %q; got %q", tc.cmds[i], cmds[i])
                }
            }
        })
    }
}

Answer 1

You basically need to have some sample files with the contents you want to test, then in your test code you can call the generateCmds function passing in the template string and the files to then verify that the results are what you expect.

It is not so much different as the examples you probably saw for simpler cases.

You can place the files under a testdata folder inside the same package (testdata is a special name that the Go tools will ignore during build).

Then you can do something like:

func TestCSVProcessing(t *testing.T) {
    templateStr := `<your template here>`
    testFile := "testdata/yourtestfile.csv"
    result, err := generateCmds(templateStr, testFile)
    if err != nil {
        // fail the test here, unless you expected an error with this file
    }
    // compare the "result" contents with what you expected
    // failing the test if it does not match
}

EDIT

About the specific questions you added later:

Would a test table be useful in a function like this? And, if so, would the test struct need to include the returned cmds string slice and the value of err?

Yes, it'd make sense to include both the expected strings to be returned as well as the expected error (if any).

How do you handle errors that are supposed to be returned for specific test cases? For example, os.Open() returns an error of type *PathError if an error is encountered. How do I initialize a *PathError that is equivalent to the one returned by os.Open()?

I don't think you'll be able to "initialize" an equivalent error for each case. Sometimes the libraries might use internal types for their errors making this impossible. Easiest would be to "initialize" a regular error with the same value returned in its Error() method, then just compare the returned error's Error() value with the expected one.