cupaloy alternatives and similar packages
Based on the "Testing Frameworks" category.
Alternatively, view cupaloy alternatives based on common mentions on social networks and blogs.
-
dockertest
Write better integration tests! Dockertest helps you boot up ephermal docker images for your Go tests with minimal work. -
gnomock
Test your code without writing mocks with ephemeral Docker containers ๐ฆ Setup popular services with just a couple lines of code โฑ๏ธ No bash, no yaml, only code ๐ป -
embedded-postgres
Run a real Postgres database locally on Linux, OSX or Windows as part of another Go application or test -
gotest.tools
A collection of packages to augment the go testing package and support common patterns. -
go-testdeep
Extremely flexible golang deep comparison, extends the go testing package, tests HTTP APIs and provides tests suite -
testza
Full-featured test framework for Go! Assertions, fuzzing, input testing, output capturing, and much more! ๐ -
jsonassert
A Go test assertion library for verifying that two representations of JSON are semantically equal -
GoSpec
Testing framework for Go. Allows writing self-documenting tests/specifications, and executes them concurrently and safely isolated. [UNMAINTAINED] -
assert
:exclamation:Basic Assertion Library used along side native go testing, with building blocks for custom assertions -
gogiven
gogiven - BDD testing framework for go that generates readable output directly from source code
CodeRabbit: AI Code Reviews for Developers
Do you think we are missing an alternative of cupaloy or a related project?
Popular Comparisons
README
Incredibly simple Go snapshot testing: cupaloy
takes a snapshot of your test output and compares it to a snapshot committed alongside your tests. If the values don't match then the test will be failed.
There's no need to manually manage snapshot files: just use the cupaloy.SnapshotT(t, value)
function in your tests and cupaloy
will automatically find the relevant snapshot file (based on the test name) and compare it with the given value.
Usage
Write a test
Firstly, write a test case generating some output and pass this output to cupaloy.SnapshotT
:
func TestParsing(t *testing.T) {
ast := ParseFile("test_input")
// check that the result is the same as the last time the snapshot was updated
// if the result has changed (e.g. because the behaviour of the parser has changed)
// then the test will be failed with an error containing a diff of the changes
cupaloy.SnapshotT(t, ast)
}
The first time this test is run, a snapshot will be automatically created (using the github.com/davecgh/go-spew package).
Update a snapshot
When the behaviour of your software changes causing the snapshot to change, this test will begin to fail with an error showing the difference between the old and new snapshots. Once you are happy that the new snapshot is correct (and hasn't just changed unexpectedly), you can save the new snapshot by setting the UPDATE_SNAPSHOTS
environment and re-running your tests:
UPDATE_SNAPSHOTS=true go test ./...
This will fail all tests where the snapshot was updated (to stop you accidentally updating snapshots in CI) but your snapshot files will now have been updated to reflect the current output of your code.
Supported formats
Snapshots of test output are generated using the github.com/davecgh/go-spew package which uses reflection to deep pretty-print your test result and so will support almost all the basic types (from simple strings, slices, and maps to deeply nested structs) without issue. The only types whose contents cannot be fully pretty-printed are functions and channels.
The most important property of your test output is that it is deterministic: if your output contains timestamps or other fields which will change on every run, then cupaloy
will detect this as a change and so fail the test.
Further Examples
Table driven tests
var testCases = map[string][]string{
"TestCaseOne": []string{......},
"AnotherTestCase": []string{......},
....
}
func TestCases(t *testing.T) {
for testName, args := range testCases {
t.Run(testName, func(t *testing.T) {
result := functionUnderTest(args...)
cupaloy.SnapshotT(t, result)
})
}
}
Changing output directory
func TestSubdirectory(t *testing.T) {
result := someFunction()
snapshotter := cupaloy.New(cupaloy.SnapshotSubdirectory("testdata"))
err := snapshotter.Snapshot(result)
if err != nil {
t.Fatalf("error: %s", err)
}
}
For further usage examples see basic_test.go and advanced_test.go in the examples/ directory which are both kept up to date and run on CI.