51Testing软件测试论坛

标题: Go中的高级单元测试模式（下） [打印本页]
作者: lsekfe    时间: 2022-3-4 10:10
标题: Go中的高级单元测试模式（下）
　　在测试中使用外部数据
　　在Go中，你应该把测试的外部数据放在一个叫做testdata 的目录中。当你为你的程序构建二进制文件时，testdata 目录会被忽略，所以你可以使用这种方法来存储你想测试程序的输入。
　　例如，让我们写一个函数，从一个二进制文件生成base64 编码。
  1. func getBase64Encoding(b []byte) string {
  2. 　　    return base64.StdEncoding.EncodeToString(b)
  3. 　　}
复制代码
　为了测试这个函数产生正确的输出，让我们把一些样本文件和它们相应的base64 编码放在我们项目根部的testdata 目录下。
  1. 　$ ls testdata
  2. 　　img1.jpg img1_base64.txt img2.jpg img2_base64.txt img3.jpg img3_base64.txt
复制代码
为了测试我们的getBase64Encoding() 功能，运行下面的代码。
  1. func TestGetBase64Encoding(t *testing.T) {
  2. 　　    cases := []string{"img1", "img2", "img3"}
  3. 　　    for _, v := range cases {
  4. 　　        t.Run(v, func(t *testing.T) {
  5. 　　            b, err := os.ReadFile(filepath.Join("testdata", v+".jpg"))
  6. 　　            if err != nil {
  7. 　　                t.Fatal(err)
  8. 　　            }
  9. 　　            expected, err := os.ReadFile(filepath.Join("testdata", v+"_base64.txt"))
  10. 　　            if err != nil {
  11. 　　                t.Fatal(err)
  12. 　　            }
  13. 　　            got := getBase64Encoding(b)
  14. 　　            if string(expected) != got {
  15. 　　                t.Fatalf("Expected output to be: '%s', but got: '%s'", string(expected), got)
  16. 　　            }
  17. 　　        })
  18. 　　    }
  19. 　　}
复制代码
　从文件系统中读取每个样本文件的字节，然后送入getBase64Encoding() 函数。随后将输出与预期输出进行比较，预期输出也是从testdata 目录中获取的。
　　让我们通过在testdata 中创建一个子目录，使测试更容易维护。在我们的子目录中，我们将添加所有的输入文件，允许我们简单地迭代每个二进制文件，并比较实际输出和预期输出。
　　现在，我们可以添加更多的测试案例，而不需要接触源代码。
  1. 　$ go test -v
  2. 　　=== RUN   TestGetBase64Encoding
  3. 　　=== RUN   TestGetBase64Encoding/img1
  4. 　　=== RUN   TestGetBase64Encoding/img2
  5. 　　=== RUN   TestGetBase64Encoding/img3
  6. 　　--- PASS: TestGetBase64Encoding (0.04s)
  7. 　　    --- PASS: TestGetBase64Encoding/img1 (0.01s)
  8. 　　    --- PASS: TestGetBase64Encoding/img2 (0.01s)
  9. 　　    --- PASS: TestGetBase64Encoding/img3 (0.01s)
  10. 　　PASS
  11. 　　ok      github.com/ayoisaiah/random     0.044s
复制代码
　使用黄金文件
　　如果你在使用Go模板，最好是测试一下生成的输出与预期的输出，以确认模板是否按预期工作。Go模板通常比较大，所以不建议像我们在本教程中迄今为止所做的那样在源代码中硬编码预期输出。
　　让我们来探讨一下Go模板的另一种方法，它可以在项目的整个生命周期内简化测试的编写和维护。
　　黄金文件是一种特殊类型的文件，包含测试的预期输出。测试函数从黄金文件中读取，将其内容与测试的预期输出进行比较。
　　在下面的例子中，我们将使用html/template ，生成一个HTML表格，其中包含库存中每本书的一行。
  1. 　　type Book struct {
  2. 　　    Name          string
  3. 　　    Author        string
  4. 　　    Publisher     string
  5. 　　    Pages         int
  6. 　　    PublishedYear int
  7. 　　    Price         int
  8. 　　}
  9. 　　var tmpl = `<table class="table">
  10. 　　  <thead>
  11. 　　    <tr>
  12. 　　      <th>Name</th>
  13. 　　      <th>Author</th>
  14. 　　      <th>Publisher</th>
  15. 　　      <th>Pages</th>
  16. 　　      <th>Year</th>
  17. 　　      <th>Price</th>
  18. 　　    </tr>
  19. 　　  </thead>
  20. 　　  <tbody>
  21. 　　    {{ range . }}<tr>
  22. 　　      <td>{{ .Name }}</td>
  23. 　　      <td>{{ .Author }}</td>
  24. 　　      <td>{{ .Publisher }}</td>
  25. 　　      <td>{{ .Pages }}</td>
  26. 　　      <td>{{ .PublishedYear }}</td>
  27. 　　      <td>${{ .Price }}</td>
  28. 　　    </tr>{{ end }}
  29. 　　  </tbody>
  30. 　　</table>
  31. 　　`
  32. 　　var tpl = template.Must(template.New("table").Parse(tmpl))
  33. 　　func generateTable(books []Book, w io.Writer) error {
  34. 　　    return tpl.Execute(w, books)
  35. 　　}
  36. 　　func main() {
  37. 　　    books := []Book{
  38. 　　        {
  39. 　　            Name:          "The Odessa File",
  40. 　　            Author:        "Frederick Forsyth",
  41. 　　            Pages:         334,
  42. 　　            PublishedYear: 1979,
  43. 　　            Publisher:     "Bantam",
  44. 　　            Price:         15,
  45. 　　        },
  46. 　　    }
  47. 　　    err := generateTable(books, os.Stdout)
  48. 　　    if err != nil {
  49. 　　        log.Fatal(err)
  50. 　　    }
  51. 　　}
复制代码
上面的generateTable() 函数从Book 对象的片断中创建HTML表。上面的代码将产生以下输出。
  1. 　$ go run main.go
  2. 　　<table class="table">
  3. 　　  <thead>
  4. 　　    <tr>
  5. 　　      <th>Name</th>
  6. 　　      <th>Author</th>
  7. 　　      <th>Publisher</th>
  8. 　　      <th>Pages</th>
  9. 　　      <th>Year</th>
  10. 　　      <th>Price</th>
  11. 　　    </tr>
  12. 　　  </thead>
  13. 　　  <tbody>
  14. 　　    <tr>
  15. 　　      <td>The Odessa File</td>
  16. 　　      <td>Frederick Forsyth</td>
  17. 　　      <td>Bantam</td>
  18. 　　      <td>334</td>
  19. 　　      <td>1979</td>
  20. 　　      <td>$15</td>
  21. 　　    </tr>
  22. 　　  </tbody>
  23. 　　</table>
复制代码
　为了测试上面的函数，我们将捕获实际结果并与预期结果进行比较。我们将像上一节那样把预期结果存储在testdata 目录中，然而，我们必须做一些改变。
　　假设我们在一个库存中拥有以下的书籍列表。
  1. var inventory = []Book{
  2. 　　    {
  3. 　　        Name:          "The Solitare Mystery",
  4. 　　        Author:        "Jostein Gaarder",
  5. 　　        Publisher:     "Farrar Straus Giroux",
  6. 　　        Pages:         351,
  7. 　　        PublishedYear: 1990,
  8. 　　        Price:         12,
  9. 　　    },
  10. 　　    {
  11. 　　        Name:          "Also Known As",
  12. 　　        Author:        "Robin Benway",
  13. 　　        Publisher:     "Walker Books",
  14. 　　        Pages:         208,
  15. 　　        PublishedYear: 2013,
  16. 　　        Price:         10,
  17. 　　    },
  18. 　　    {
  19. 　　        Name:          "Ego Is the Enemy",
  20. 　　        Author:        "Ryan Holiday",
  21. 　　        Publisher:     "Portfolio",
  22. 　　        Pages:         226,
  23. 　　        PublishedYear: 2016,
  24. 　　        Price:         18,
  25. 　　    },
  26. 　　}
复制代码
这个图书清单的预期输出将跨越许多行，因此，很难将其作为一个字符串字面放在源代码内。
  1. <table class="table">
  2. 　　  <thead>
  3. 　　    <tr>
  4. 　　      <th>Name</th>
  5. 　　      <th>Author</th>
  6. 　　      <th>Publisher</th>
  7. 　　      <th>Pages</th>
  8. 　　      <th>Year</th>
  9. 　　      <th>Price</th>
  10. 　　    </tr>
  11. 　　  </thead>
  12. 　　  <tbody>
  13. 　　    <tr>
  14. 　　      <td>The Solitaire Mystery</td>
  15. 　　      <td>Jostein Gaarder</td>
  16. 　　      <td>Farrar Straus Giroux</td>
  17. 　　      <td>351</td>
  18. 　　      <td>1990</td>
  19. 　　      <td>$12</td>
  20. 　　    </tr>
  21. 　　    <tr>
  22. 　　      <td>Also Known As</td>
  23. 　　      <td>Robin Benway</td>
  24. 　　      <td>Walker Books</td>
  25. 　　      <td>308</td>
  26. 　　      <td>2013</td>
  27. 　　      <td>$10</td>
  28. 　　    </tr>
  29. 　　    <tr>
  30. 　　      <td>Ego Is The Enemy</td>
  31. 　　      <td>Ryan Holiday</td>
  32. 　　      <td>Portfolio</td>
  33. 　　      <td>226</td>
  34. 　　      <td>2016</td>
  35. 　　      <td>$18</td>
  36. 　　    </tr>
  37. 　　  </tbody>
  38. 　　</table>
复制代码
除了对较大的输出实用外，一个黄金文件可以自动更新和生成。
　　虽然可以写一个辅助函数来创建和更新黄金文件，但我们可以利用goldie，一个专门为黄金文件创建的工具。
　　用下面的命令安装最新版本的goldie。
  1. 　$ go get -u github.com/sebdah/goldie/v2
复制代码
让我们继续使用goldie来测试generateTable() 函数。
  1. 　func TestGenerateTable(t *testing.T) {
  2. 　　    var buf bytes.Buffer
  3. 　　    err := generateTable(inventory, &buf)
  4. 　　    if err != nil {
  5. 　　        t.Fatal(err)
  6. 　　    }
  7. 　　    actual := buf.Bytes()
  8. 　　    g := goldie.New(t)
  9. 　　    g.Assert(t, "books", actual)
  10. 　　}
复制代码
　　上面的测试在一个字节的缓冲区中捕获了generateTable() 函数的输出。然后，它将缓冲区的内容传递给goldie 实例的Assert() 方法。缓冲区中的内容将与testdata 目录中的books.golden 文件的内容进行比较。
　　最初，运行该测试会失败，因为我们还没有创建books.golden 文件。
  1. $ go test -v
  2. 　　=== RUN   TestGenerateTable
  3. 　　    main_test.go:48: Golden fixture not found. Try running with -update flag.
  4. 　　--- FAIL: TestGenerateTable (0.00s)
  5. 　　FAIL
  6. 　　exit status 1
  7. 　　FAIL    github.com/ayoisaiah/random     0.006s
复制代码
错误信息建议我们添加-update 标志，这将用缓冲区的内容创建books.golden 文件。
  1. $ go test -v -update
  2. 　　=== RUN   TestGenerateTable
  3. 　　--- PASS: TestGenerateTable (0.00s)
  4. 　　PASS
  5. 　　ok      github.com/ayoisaiah/random     0.006s
复制代码
在随后的运行中，我们应该删除-update 标志，这样我们的黄金文件就不会被不断地更新。
　　对模板的任何改变都会导致测试失败。例如，如果你将价格字段更新为欧元而不是美元，你会立即收到一个错误。这些错误的发生是因为generateTable() 函数的输出不再符合黄金文件的内容。
　　Goldie提供了差异功能，以帮助你在这些错误发生时发现变化。
  1. $ go test -v
  2. 　　=== RUN   TestGenerateTable
  3. 　　    main_test.go:48: Result did not match the golden fixture. Diff is below:
  4. 　　        --- Expected
  5. 　　        +++ Actual
  6. 　　        [url=home.php?mod=space&uid=40658]@@[/url] -18,3 +18,3 @@
  7. 　　               <td>1990</td>
  8. 　　        -      <td>$12</td>
  9. 　　        +      <td>�12</td>
  10. 　　             </tr><tr>
  11. 　　        @@ -25,3 +25,3 @@
  12. 　　               <td>2013</td>
  13. 　　        -      <td>$10</td>
  14. 　　        +      <td>�10</td>
  15. 　　             </tr><tr>
  16. 　　        @@ -32,3 +32,3 @@
  17. 　　               <td>2016</td>
  18. 　　        -      <td>$18</td>
  19. 　　        +      <td>�18</td>
  20. 　　             </tr>
  21. 　　--- FAIL: TestGenerateTable (0.00s)
  22. 　　FAIL
  23. 　　exit status 1
  24. 　　FAIL    github.com/ayoisaiah/random     0.007s
复制代码
在上面的输出中，该变化被清楚地突出显示。这些变化是故意的，所以我们可以通过使用-update 标志更新黄金文件，使我们的测试再次通过。
  1. 　$ go test -v -update
  2. 　　=== RUN   TestGenerateTable
  3. 　　--- PASS: TestGenerateTable (0.00s)
  4. 　　PASS
  5. 　　ok      github.com/ayoisaiah/random     0.006s
复制代码
结论
　　在本教程中，我们研究了Go中的一些高级测试技术。首先，我们深入研究了我们的HTTP包，并学习了如何用自定义接口模拟我们的HTTP客户端。然后，我们回顾了如何在测试中使用外部数据并使用goldie创建黄金文件。











欢迎光临 51Testing软件测试论坛 (http://bbs.51testing.com/) Powered by Discuz! X3.2