Go Testing by Example [video]

I like the txtar file format mentioned in this video. (Described below.) I’ve worked with teams who would have rejected this idea from a junior dev because it might sound too simple. It’s easy to forget the inherent value of simplicity, which is at odds with impressive-sounding features, or demonstrating hard-won coding sophistication.

This is the complete txtar file format: One or more comment lines followed by zero or more virtual files. Each virtual file begins with a line like “-- filename --“ and ends at the next such line. Specifically, these filename lines are those beginning with dash dash space and ending with space dash dash. That’s the whole format.

It avoids the need to have multiple real files all over the place when you want just one real file but you want your code to think in terms of multiple files. (Eg have one txtar file that combines different blocks of test data.)

Agreed with most of this but I’m skeptical of the rsc.io/script dsl approach. I’ll try it, though, because Russ is often right.

shameless advert: do you wish testify was implemented with generics and go-cmp, and had a more understandable surface area? Check out my small library, testy https://github.com/peterldowns/testy

shameless advert: do you want to write tests against your postgres database, but each new test adds seconds to your test suite? Check out pgtestdb, the marginal cost of each test is measured in tens of milliseconds, and each test gets a unique and isolated postgres instance — with all your migrations applied. https://github.com/peterldowns/pgtestdb

Wow! Someone brought up and demonstrated go's "example tests" just yesterday to me and a group. He praised them highly for tech-adjacent fields where people don't have familiarity with software engineering practices for modular, tested, or ready to share projects. We discuss infrastructure, and it was enlightening to be reminded of the tech-adjacent fields that could benefit greatly from a few more of the practices common in the tech industry. I suppose the Joel test and 12 Factor app would be indicative guides.

A huge time-saver for me when adding table-driven test boilerplate in Go has been using gotests[0] to generate the template.

If you use VSCode with the Go extension it's already available there as a command "Go: Generate Unit Tests for Function/Package".

[0] https://github.com/cweill/gotests

I worked on a team with a metric and associated goal of x% code coverage. So of course, even negotiating what x should be resulted in a week's worth of meetings over a quarter. And the "branch coverage versus line coverage" war was long and ugly. When the metric was finally in place, it was of course immediately gamed to test getters and setters and to avoid the hard to test, sensitive integrated parts of the code.

This, in the same organization where another team was told by it's VP, "don't schedule time for unit tests, we are too far behind schedule for a luxury like that".

All this to say, #3 "coverage is not a substitute for thinking" really hit me in the (grumpy) feels.

Separating test data and test logic is exactly how we have built our test infrastructure to satisfy the FDA; making clear test data that you can then query and report on gives you tons of nice features for free!

It also really helps you to properly model your problem by breaking things out into their simplest possible components, and makes porting to a new implementation a breeze; reproduce a quick test data parser and some simple case logic, and you're well on your way to having two totally matching, but also totally separate, implementations!

...all of this without reinventing Lisp, of course ;)

It's hard to do a lively presentation like this without an audience. I'm a little jealous of how well he does it.

See also Advanced Testing with Go by Mitchell Hashimoto[0]

---

0: https://www.youtube.com/watch?v=8hQG7QlcLBk

Some similar resources I like:

"Learn Go with Tests" book: https://quii.gitbook.io/learn-go-with-tests

"Go by Example": https://gobyexample.com/

Test code doesn't have tests of its own, so we must rely on inspection to establish that it is correct. This means that test code must be extremely readable.

It would make me uncomfortable to rely on tests like some of the examples in this talk, that have such a degree of complexity without explicit tests. Code such as to parse a text file should be in its own package. The package should expose an extremely readable API, and it should have its own suite of tests.

Similarly, writing formatting code for error messages and diffs inline makes the tests less readable and therefore less reliable. The golang standard library should include testing helpers such as in `testify`, which would allow tests to be concise, less buggy, and extremely readable.

Long time Go user, recently using rust as well. One of the things I miss most in rust are subtests and t.Errorf as opposed to t.Fatal.

But perhaps I don't know how to do it. In most of the rust codebases I worked with tests contain sequences of asserts (the failure of which causes the whole test to fail). Procedural macros are often employed to create many smaller tests that seem to address the use case of table driven tests + t.Error or subtests.

Macros in rust are ... adequate, but there is something bout being able to just express your logic in your main language instead of having to fiddle with a macro language and effectively code generation.

Does anybody have good tips for bringing some of the enjoyable testing patterns from Go into Rust?

Go tests are fantastic. Fast, easy to write and just works. Another reason we moved to Go when moving off of Common Lisp.

I do like Go tests. Would love to have ability to find out untested parts of the code base though to increase coverage, but I do not think there is a way to measure this with available tools just yet.

Although I have yet to make integration tests that require live database and other dependencies. That will be fun...

Anyway, my main gripe with tests or TDD is that even if the code base is 95% finished, not talking libraries here, even small code changes can cause a cascade of changes that need to be addressed and tests essentially multiply the work load by a factor of 10, easy. And I am not talking about big changes. It might be a simple addition of a new struct field which suddenly breaks half of your test suite. Hence teste should be, in my experience, written as the absolutely last step before going live. Otherwise they might impose massive costs on time, and potentially money(if we're talking actual business and not one man shot type of project).

Having not really written many tests before due to having worked moreso as a data scientist (a smidgen of pytest here and there), it's so nice writing tests in Go. Definitely a considered and well implemented part of the language

I have a package that makes it easier to do the “use a glob of files as golden test cases” thing mentioned in the middle of the talk: https://pkg.go.dev/github.com/carlmjohnson/be@v0.23.2/testfi...

Russ Cox has fully imbibed his $DAYJOB into his life to the extent it feels unhealthy. Golang Shirt; multiple golang wall paintings; countless golang soft toys in the background and on his side. I am sure he has a few golang tattoos as well!