如何测试 Golang 命令行输出？

huangapple
go评论111阅读模式
英文:

how do you test golang command line output

问题

我想测试一个使用golang命令行应用程序的输出，但我不太确定如何使用go的测试库来做到这一点。

假设我有一个像这样的程序：

  1. package main
  3. import (
  4. 	"flag"
  5. 	"fmt"
  6. )
  8. func main() {
  9. 	const (
  10. 		cityDefault = "San Francisco"
  11. 		cityDoc     = "the city you want the forecast for"
  12. 	)
  13. 	var city string
  14. 	flag.StringVar(&city, "city", cityDefault, cityDoc)
  15. 	flag.StringVar(&city, "c", cityDefault, cityDoc)
  16. 	flag.Parse()
  18. 	fmt.Println(city)
  19. }

我想测试这两个命令的输出：

  1. $ ./myapp -c "Los Angeles"
  2. $ ./myapp -city "Los Angeles"

...输出应该是 Lost Angeles。所以，我猜问题是，你如何进行集成测试来测试golang命令行应用程序的输出？

英文:

I'd like to test the output of a golang command line app, but I'm not quite sure how to do that with go's testing library.

Let's say I have a program like this:

  1. package main
  3. import (
  4. 	"flag"
  5. 	"fmt"
  6. )
  8. func main() {
  9. 	const (
  10. 		cityDefault = "San Francisco"
  11. 		cityDoc     = "the city you want the forecast for"
  12. 	)
  13. 	var city string
  14. 	flag.StringVar(&city, "city", cityDefault, cityDoc)
  15. 	flag.StringVar(&city, "c", cityDefault, cityDoc)
  16. 	flag.Parse()
  18. 	fmt.Println(city)
  19. }

I'd like to test that both of these:

  1. $ ./myapp -c "Los Angeles"
  2. $ ./myapp -city "Los Angeles"

... output Lost Angeles. So, I guess the question is, how do you go about integration testing the output of a golang command line app?

答案1

得分: 4

这是一个解析命令行参数的不好的示例，但它展示了我在应用程序中测试命令行参数时使用的框架。

main.go

  1. package main
  3. import (
  4. 	"log"
  5. 	"os"
  6. )
  8. func main() {
  9. 	var city string
  10. 	parseFlags(&city, os.Args)
  12. 	log.Println(city)
  13. }
  15. func parseFlags(result *string, args []string) {
  16. 	cityDefault := "San Francisco"
  18. 	switch len(args) {
  19. 	case 3:
  20. 		*result = args[2]
  21. 	default:
  22. 		*result = cityDefault
  23. 	}
  24. }

main_unit_test.go

  1. package main
  3. import (
  4. 	"log"
  5. 	"testing"
  6. )
  8. // TestParseFlags - test our command line flags
  9. func TestParseFlags(t *testing.T) {
  10. 	var parseFlagsTests = []struct {
  11. 		flags    []string // input flags to the command line
  12. 		expected string   // expected
  13. 	}{
  14. 		{[]string{"/fake/loc/main"}, "San Francisco"},
  15. 		{[]string{"/fake/loc/main", "-c", "Los Angeles"}, "Los Angeles"},
  16. 		{[]string{"/fake/loc/main", "--city", "Los Angeles"}, "Los Angeles"},
  17. 	}
  19. 	for _, tt := range parseFlagsTests {
  20. 		var output string
  21. 		parseFlags(&output, tt.flags)
  22. 		if output != tt.expected {
  23. 			t.Errorf("expected: %s, actual: %s", tt.expected, output)
  24. 		}
  25. 	}
  26. }

我通常使用这个包来解析我所有应用程序中的命令行参数。我会按照以下结构编写代码（未显示测试代码，但它们通常遵循上面示例的主要思路）：

main.go

  1. package main
  3. import (
  4. 	"log"
  5. 	"os"
  7. 	"myDir/cli"
  8. )
  10. func main() {
  11. 	// 获取用户输入的命令行标志
  12. 	cliFlags := cli.FlagsStruct{}
  13. 	cliErr := cli.StartCLI(&cliFlags, os.Args)
  14. 	if cliErr != nil {
  15. 		log.Println("获取命令行参数时出错")
  16. 		log.Fatal(cliErr)
  17. 	}
  19. 	// 做一些事情...
  20. }

/myDir/cli.go

  1. package cli
  3. import "github.com/urfave/cli"
  5. // FlagsStruct - 保存命令行参数
  6. type FlagsStruct struct {
  7. 	MyFlag string
  8. }
  10. // StartCLI - 收集命令行参数
  11. func StartCLI(cliFlags *FlagsStruct, args []string) error {
  12. 	app := cli.NewApp()
  13. 	app.Action = func(ctx *cli.Context) error {
  14. 		MyFlag := ctx.GlobalString("my-flag")
  16. 		// 构建要发送回主函数的 cli 结构体
  17. 		cliFlags.MyFlag = MyFlag
  18. 		return nil
  19. 	}
  20. 	app.Authors = []cli.Author{
  21. 		{
  22. 			Email: "my@email.com",
  23. 			Name:  "Adam Hanna",
  24. 		},
  25. 	}
  26. 	app.Flags = []cli.Flag{
  27. 		cli.StringFlag{
  28. 			Name:  "my-flag, f",
  29. 			Usage: "这里是我的标志用法",
  30. 			Value: "myDefault",
  31. 		},
  32. 	}
  33. 	app.Name = "myAppName"
  34. 	app.Usage = "我的应用程序的用法"
  35. 	app.Version = "0.0.1"
  36. 	return app.Run(args)
  37. }
英文:

This is a bad example of parsing command line args, but it shows the framework I use to test command line args in my apps.

main.go

  1. package main
  3. import (
  4. 	"log"
  5. 	"os"
  6. )
  8. func main() {
  9. 	var city string
  10. 	parseFlags(&city, os.Args)
  12. 	log.Println(city)
  13. }
  15. func parseFlags(result *string, args []string) {
  16. 	cityDefault := "San Francisco"
  18. 	switch len(args) {
  19. 	case 3:
  20. 		*result = args[2]
  21. 	default:
  22. 		*result = cityDefault
  23. 	}
  24. }

main_unit_test.go

  1. package main
  3. import (
  4. 	"log"
  5. 	"testing"
  6. )
  8. // TestParseFlags - test our command line flags
  9. func TestParseFlags(t *testing.T) {
  10. 	var parseFlagsTests = []struct {
  11. 		flags    []string // input flags to the command line
  12. 		expected string   // expected
  13. 	}{
  14. 		{[]string{"/fake/loc/main"}, "San Francisco"},
  15. 		{[]string{"/fake/loc/main", "-c", "Los Angeles"}, "Los Angeles"},
  16. 		{[]string{"/fake/loc/main", "--city", "Los Angeles"}, "Los Angeles"},
  17. 	}
  19. 	for _, tt := range parseFlagsTests {
  20. 		var output string
  21. 		parseFlags(&output, tt.flags)
  22. 		if output != tt.expected {
  23. 			t.Errorf("expected: %s, actual: %s", tt.expected, output)
  24. 		}
  25. 	}
  26. }

I typically use this package to parse command line args in all of my apps. And I'll structure my code as follows (tests not shown, but they generally follow the gist of the test shown above):

main.go

  1. package main
  3. import (
  4. 	"log"
  5. 	"os"
  7.     "myDir/cli"
  8. )
  10. func main() {
  11. 	// Grab the user inputed CLI flags
  12. 	cliFlags := cli.FlagsStruct{}
  13. 	cliErr := cli.StartCLI(&cliFlags, os.Args)
  14. 	if cliErr != nil {
  15. 		log.Println("Error grabbing command line args")
  16. 		log.Fatal(cliErr)
  17. 	}
  19.     // Do stuff ...
  20. }

/myDir/cli.go

  1. package cli
  3. import "github.com/urfave/cli"
  5. // FlagsStruct - holds command line args
  6. type FlagsStruct struct {
  7. 	MyFlag string
  8. }
  10. // StartCLI - gathers command line args
  11. func StartCLI(cliFlags *FlagsStruct, args []string) error {
  12. 	app := cli.NewApp()
  13. 	app.Action = func(ctx *cli.Context) error {
  14. 		MyFlag := ctx.GlobalString("my-flag")
  16.         // build the cli struct to send back to main
  17. 		cliFlags.MyFlag = MyFlag
  18.         return nil
  19. 	}
  20. 	app.Authors = []cli.Author{
  21. 		{
  22. 			Email: "my@email.com",
  23. 			Name:  "Adam Hanna",
  24. 		},
  25. 	}
  26. 	app.Flags = []cli.Flag{
  27. 		cli.StringFlag{
  28. 			Name:  "my-flag, f",
  29. 			Usage: "My flag usage goes here",
  30. 			Value: "myDefault",
  31. 		},
  32.     }
  33. 	app.Name = "myAppName"
  34. 	app.Usage = "My App's Usage"
  35. 	app.Version = "0.0.1"
  36. 	return app.Run(args)
  37. }

答案2

得分: 2

如何使用 test "$(./myapp -c "洛杉矶")" = "洛杉矶" 进行测试？
对于 -city 参数也是一样。这与 Go 无关，只需让你的集成测试套件执行测试即可。

英文:

How about test "$(./myapp -c "Los Angeles")" = "Los Angeles"
and the same for -city. This has nothing to do with Go, just let your integration test suite do the test.

huangapple
  • 本文由 发表于 2014年12月4日 01:26:06
  • 转载请务必保留本文链接：https://go.coder-hub.com/27277917.html
  • go
  • testing
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定