On my journey into learning Go, after some time spent learning the basic concepts I came across the testing. Go has a built-in testing command with go test
and a testing package
which combined can be used for unit testing.
It is really useful having native testing capabilities but Go only provides the minimum for writing unit tests. There are no assertions like Mocha or Jest for javascript ( Equal
, toBe
), repeated steps (e.g. beforeEach
, afterEach
) or mocking/spying and as you would expect by now there is no snapshot testing.
The community has built libraries on top of the standard testing
package to provide some of the functionality like testify does.
Snapshot testing
Snapshot testing is mostly used when you want to test UIs, as stated in Jest Docs
Snapshot tests are a very useful tool whenever you want to make sure your UI does not change unexpectedly.
But snapshot testing can be useful in applications other than UI as well. Some examples could be
- Database clients, where you want to diff multiple rows of data
- Backend services, where you can diff API responses
and any application that can have a "state" and you would like to create a representation of it and compare it at a later time.
For more information around snapshot testing, there is a wide range of resources you could read for more specific applications and where it fits in unit testing.
Go snaps
So I decided to build a library that supports snapshot testing go-snaps
and practice my Go skills.
It's simple to use
// example_test.go
package example
import (
"testing"
"github.com/gkampitakis/go-snaps/snaps"
)
func TestExample(t *testing.T) {
snaps.MatchSnapshot(t ,"Hello World")
}
On the 1st run of your tests this will create a file __snapshots__/example_test.snap
containing your snapshot
[TestExample - 1]
Hello World
---
On every other run, it will compare this snapshot with the parameters provided.
So if we update the call with
snaps.MatchSnapshot(t,
"hello world",
"another value",
100,
)
our test will fail and return a message containing a diff view of the snapshot and params.
If we are sure this is not a regression in our code and we want to update the snapshots we can call again the go test
with either flag -snaps.update=true
or the env variable UPDATE_SNAPS=true
.
Detecting obsolete snapshots
Apart from the standard snapshot functionality that go-snaps
provides, it also can detect obsolete snapshots (snapshots that are no longer used). In order to enable this functionality you have to use TestMain and call the snaps.Clean()
.
func TestMain(t *testing.M) {
v := t.Run()
// After all tests have run `go-snaps` can check for not used snapshots
snaps.Clean()
os.Exit(v)
}
The reason for using TestMain
, is because go-snaps
needs to be sure that all tests have run so it can keep track of which snapshots were not called and mark them as obsolete.
Again you can remove obsolete tests and files by calling the -snaps.update=true
or UPDATE_SNAPS=true
.
Conclusion
In the repository, you can find examples and more information in README.
Hope you find go-snaps
useful, any feedback is welcome.
Acknowledgments
Go Snaps used Jest Snapshoting and Cupaloy as inspiration.
- Jest is a full-fledged Javascript testing framework and has robust snapshoting features.
- Cupaloy is a great and simple Go snapshoting solution.
If you liked or found go-snaps useful you can leave a ⭐️.
Top comments (0)