Testza is like pizza for Go - you could live without it, but why should you?
Get The Module | Documentation | Contributing | Code of Conduct
# Execute this command inside your project
go get github.com/MarvinJWendt/testzaTestza is a full-featured testing framework for Go.
It integrates with the default test runner, so you can use it with the standard go test tool.
Testza contains easy to use methods, like assertions, output capturing, mocking, and much more.
The main goal of testza is to provide an easy and fun experience writing tests and providing a nice, user-friendly output. Even developers who never used testza, will get into it quickly.
See the examples below for a quick introduction!
// --- Some Examples ---
// - Some assertions -
testza.AssertTrue(t, true) // -> Pass
testza.AssertNoError(t, err) // -> Pass
testza.AssertEqual(t, object, object) // -> Pass
// ...
// - Testing console output -
// Test the output of your CLI tool easily!
terminalOutput, _ := testza.CaptureStdout(func(w io.Writer) error {fmt.Println("Hello"); return nil})
testza.AssertEqual(t, terminalOutput, "Hello\n") // -> Pass
// - Mocking -
// Testing a function that accepts email addresses as a parameter:
// Testset of many different email addresses
emailAddresses := testza.MockStringEmailAddresses()
// Run a test for every string in the test set
testza.MockStringRunTests(t, emailAddresses, func(t *testing.T, index int, str string) {
user, domain, err := internal.ParseEmailAddress(str) // Use your function
testza.AssertNoError(t, err) // Assert that your function does not return an error
testza.AssertNotZero(t, user) // Assert that the user is returned
testza.AssertNotZero(t, domain) // Assert that the domain is returned
})
// And that's just a few examples of what you can do with Testza!| Module | Methods |
|---|---|
| Settings |
Click to expand |
| Assert |
Click to expand
|
| Capture |
Click to expand |
| Mock Input Bool |
Click to expand |
| Mock Input String | |
| Mock Input Float64 | |
| Mock Input Int | |
| Snapshot |
Click to expand |
func AssertCompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{})AssertCompletesIn asserts that a function completes in a given time. Use this function to test that functions do not take too long to complete.
NOTE: Every system takes a different amount of time to complete a function. Do not set the duration too low, if you want consistent results.
Example:
testza.AssertCompletesIn(t, 2 * time.Second, func() {
// some code that should take less than 2 seconds...
}) // => PASS
func AssertContains(t testRunner, object, element interface{}, msg ...interface{})AssertContains asserts that a string/list/array/slice/map contains the specified element.
Example:
testza.AssertContains(t, []int{1,2,3}, 2)
testza.AssertContains(t, []string{"Hello", "World"}, "World")
testza.AssertContains(t, "Hello, World!", "World")
func AssertEqual(t testRunner, expected interface{}, actual interface{}, msg ...interface{})AssertEqual asserts that two objects are equal.
Example:
testza.AssertEqual(t, "Hello, World!", "Hello, World!")
testza.AssertEqual(t, true, true)
func AssertEqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{})AssertEqualValues asserts that two objects have equal values. The order of the values is also validated.
Example:
testza.AssertEqualValues(t, []string{"Hello", "World"}, []string{"Hello", "World"})
testza.AssertEqualValues(t, []int{1,2}, []int{1,2})
testza.AssertEqualValues(t, []int{1,2}, []int{2,1}) // FAILS (wrong order)
Comparing struct values:
person1 := Person{
Name: "Marvin Wendt",
Age: 20,
Gender: "male",
}
person2 := Person{
Name: "Marvin Wendt",
Age: 20,
Gender: "male",
}
testza.AssertEqualValues(t, person1, person2)
func AssertFalse(t testRunner, value interface{}, msg ...interface{})AssertFalse asserts that an expression or object resolves to false.
Example:
testza.AssertFalse(t, false)
testza.AssertFalse(t, 1 == 2)
testza.AssertFalse(t, 2 != 2)
testza.AssertFalse(t, 1 > 5 && 4 < 0)
func AssertGreater(t testRunner, object1, object2 interface{}, msg ...interface{})AssertGreater asserts that the first object is greater than the second.
Example:
testza.AssertGreater(t, 5, 1)
testza.AssertGreater(t, 10, -10)
func AssertImplements(t testRunner, interfaceObject, object interface{}, msg ...interface{})AssertImplements asserts that an objects implements an interface.
Example:
testza.AssertImplements(t, (*YourInterface)(nil), new(YourObject))
testza.AssertImplements(t, (*fmt.Stringer)(nil), new(types.Const)) => pass
func AssertKindOf(t testRunner, expectedKind reflect.Kind, object interface{}, msg ...interface{})AssertKindOf asserts that the object is a type of kind exptectedKind.
Example:
testza.AssertKindOf(t, reflect.Slice, []int{1,2,3})
testza.AssertKindOf(t, reflect.Slice, []string{"Hello", "World"})
testza.AssertKindOf(t, reflect.Int, 1337)
testza.AssertKindOf(t, reflect.Bool, true)
testza.AssertKindOf(t, reflect.Map, map[string]bool{})
func AssertLess(t testRunner, object1, object2 interface{}, msg ...interface{})AssertLess asserts that the first object is less than the second.
Example:
testza.AssertLess(t, 1, 5)
testza.AssertLess(t, -10, 10)
func AssertNil(t testRunner, object interface{}, msg ...interface{})AssertNil asserts that an object is nil.
Example:
testza.AssertNil(t, nil)
func AssertNoError(t testRunner, err interface{}, msg ...interface{})AssertNoError asserts that an error is nil.
Example:
err := nil
testza.AssertNoError(t, err)
func AssertNotCompletesIn(t testRunner, duration time.Duration, f func(), msg ...interface{})AssertNotCompletesIn asserts that a function does not complete in a given time. Use this function to test that functions do not complete to quickly. For example if your database connection completes in under a millisecond, there might be something wrong.
NOTE: Every system takes a different amount of time to complete a function. Do not set the duration too high, if you want consistent results.
Example:
testza.AssertNotCompletesIn(t, 2 * time.Second, func() {
// some code that should take more than 2 seconds...
time.Sleep(3 * time.Second)
}) // => PASS
func AssertNotContains(t testRunner, object, element interface{}, msg ...interface{})AssertNotContains asserts that a string/list/array/slice/map does not contain the specified element.
Example:
testza.AssertNotContains(t, []string{"Hello", "World"}, "Spaceship")
testza.AssertNotContains(t, "Hello, World!", "Spaceship")
func AssertNotEqual(t testRunner, expected interface{}, actual interface{}, msg ...interface{})AssertNotEqual asserts that two objects are not equal.
Example:
testza.AssertNotEqual(t, true, false)
testza.AssertNotEqual(t, "Hello", "World")
func AssertNotEqualValues(t testRunner, expected interface{}, actual interface{}, msg ...interface{})AssertNotEqualValues asserts that two objects do not have equal values.
Example:
testza.AssertNotEqualValues(t, []int{1,2}, []int{3,4})
Comparing struct values:
person1 := Person{
Name: "Marvin Wendt",
Age: 20,
Gender: "male",
}
person2 := Person{
Name: "Marvin Wendt",
Age: 20,
Gender: "female", // <-- CHANGED
}
testza.AssertNotEqualValues(t, person1, person2)
func AssertNotImplements(t testRunner, interfaceObject, object interface{}, msg ...interface{})AssertNotImplements asserts that an object does not implement an interface.
Example:
testza.AssertNotImplements(t, (*YourInterface)(nil), new(YourObject))
testza.AssertNotImplements(t, (*fmt.Stringer)(nil), new(types.Const)) => fail, because types.Const does implement fmt.Stringer.
func AssertNotKindOf(t testRunner, kind reflect.Kind, object interface{}, msg ...interface{})AssertNotKindOf asserts that the object is not a type of kind kind.
Example:
testza.AssertNotKindOf(t, reflect.Slice, "Hello, World")
testza.AssertNotKindOf(t, reflect.Slice, true)
testza.AssertNotKindOf(t, reflect.Int, 13.37)
testza.AssertNotKindOf(t, reflect.Bool, map[string]bool{})
testza.AssertNotKindOf(t, reflect.Map, false)
func AssertNotNil(t testRunner, object interface{}, msg ...interface{})AssertNotNil asserts that an object is not nil.
Example:
testza.AssertNotNil(t, true)
testza.AssertNotNil(t, "Hello, World!")
testza.AssertNotNil(t, 0)
func AssertNotNumeric(t testRunner, object interface{}, msg ...interface{})AssertNotNumeric checks if the object is not a numeric type. Numeric types are: Int, Int8, Int16, Int32, Int64, Float32, Float64, Uint, Uint8, Uint16, Uint32, Uint64, Complex64 and Complex128.
Example:
testza.AssertNotNumeric(t, true)
testza.AssertNotNumeric(t, "123")
func AssertNotPanics(t testRunner, f func(), msg ...interface{})AssertNotPanics asserts that a function does not panic.
Example:
testza.AssertNotPanics(t, func() {
// some code that does not call a panic...
}) // => PASS
func AssertNotZero(t testRunner, value interface{}, msg ...interface{})AssertNotZero asserts that the value is not the zero value for it's type.
Example:
testza.AssertNotZero(t, 1337)
testza.AssertNotZero(t, true)
testza.AssertNotZero(t, "Hello, World")
func AssertNumeric(t testRunner, object interface{}, msg ...interface{})AssertNumeric asserts that the object is a numeric type. Numeric types are: Int, Int8, Int16, Int32, Int64, Float32, Float64, Uint, Uint8, Uint16, Uint32, Uint64, Complex64 and Complex128.
Example:
testza.AssertNumeric(t, 123)
testza.AssertNumeric(t, 1.23)
testza.AssertNumeric(t, uint(123))
func AssertPanics(t testRunner, f func(), msg ...interface{})AssertPanics asserts that a function panics.
Example:
testza.AssertPanics(t, func() {
// ...
panic("some panic")
}) // => PASS
func AssertTestFails(t testRunner, test func(t TestingPackageWithFailFunctions), msg ...interface{})AssertTestFails asserts that a unit test fails. A unit test fails if one of the following methods is called in the test function: Error, Errorf, Fail, FailNow, Fatal, Fatalf
Example:
testza.AssertTestFails(t, func(t testza.TestingPackageWithFailFunctions) {
testza.AssertTrue(t, false)
}) // => Pass
testza.AssertTestFails(t, func(t testza.TestingPackageWithFailFunctions) {
// ...
t.Fail() // Or any other failing method.
}) // => Pass
func AssertTrue(t testRunner, value interface{}, msg ...interface{})AssertTrue asserts that an expression or object resolves to true.
Example:
testza.AssertTrue(t, true)
testza.AssertTrue(t, 1 == 1)
testza.AssertTrue(t, 2 != 3)
testza.AssertTrue(t, 1 > 0 && 4 < 5)
func AssertZero(t testRunner, value interface{}, msg ...interface{})AssertZero asserts that the value is the zero value for it's type.
Example:
testza.AssertZero(t, 0)
testza.AssertZero(t, false)
testza.AssertZero(t, "")
func CaptureStderr(capture func(w io.Writer) error) (string, error)CaptureStderr captures everything written to stderr from a specific function. You can use this method in tests, to validate that your functions writes a string to the terminal.
Example:
stderr, err := testza.CaptureStderr(func(w io.Writer) error {
_, err := fmt.Fprint(os.Stderr, "Hello, World!")
testza.AssertNoError(t, err)
return nil
})
testza.AssertNoError(t, err)
testza.AssertEqual(t, "Hello, World!", stderr)
func CaptureStdout(capture func(w io.Writer) error) (string, error)CaptureStdout captures everything written to stdout from a specific function. You can use this method in tests, to validate that your functions writes a string to the terminal.
Example:
stdout, err := testza.CaptureStdout(func(w io.Writer) error {
fmt.Println("Hello, World!")
return nil
})
testza.AssertNoError(t, err)
testza.AssertEqual(t, "Hello, World!", stdout)
func CaptureStdoutAndStderr(capture func(stdoutWriter, stderrWriter io.Writer) error) (stdout, stderr string, err error)CaptureStdoutAndStderr captures everything written to stdout and stderr from a specific function. You can use this method in tests, to validate that your functions writes a string to the terminal.
Example:
stdout, stderr, err := testza.CaptureStdoutAndStderr(func(stdoutWriter, stderrWriter io.Writer) error {
fmt.Fprint(os.Stdout, "Hello")
fmt.Fprint(os.Stderr, "World")
return nil
})
testza.AssertNoError(t, err)
testza.AssertEqual(t, "Hello", stdout)
testza.AssertEqual(t, "World", stderr)
func MockInputBoolFull() []boolMockInputBoolFull returns true and false in a boolean slice.
func MockInputBoolModify(inputSlice []bool, modifier func(index int, value bool) bool) (floats []bool)MockInputBoolModify returns a modified version of a test set.
Example:
testset := testza.MockInputBoolModify(testza.MockInputBoolFull(), func(index int, value bool) bool {
return !value
})
func MockInputBoolRunTests(t testRunner, testSet []bool, testFunc func(t *testing.T, index int, f bool))MockInputBoolRunTests runs a test for every value in a testset. You can use the value as input parameter for your functions, to sanity test against many different cases. This ensures that your functions have a correct error handling and enables you to test against hunderts of cases easily.
Example:
testza.MockInputBoolRunTests(t, testza.MockInputBoolFull(), func(t *testing.T, index int, b bool) {
// Test logic
// err := YourFunction(b)
// testza.AssertNoError(t, err)
// ...
})
func MockInputFloat64Full() (floats []float64)MockInputFloat64Full returns a combination of every float64 testset and some random float64s (positive and negative).
func MockInputFloat64GenerateRandomNegative(count int, min float64) (floats []float64)MockInputFloat64GenerateRandomNegative generates random negative integers with a minimum of min. If the minimum is positive, it will be converted to a negative number. If it is set to 0, there is no limit.
func MockInputFloat64GenerateRandomPositive(count int, max float64) (floats []float64)MockInputFloat64GenerateRandomPositive generates random positive integers with a maximum of max. If the maximum is 0, or below, the maximum will be set to math.MaxInt64.
func MockInputFloat64GenerateRandomRange(count int, min, max float64) (floats []float64)MockInputFloat64GenerateRandomRange generates random positive integers with a maximum of max. If the maximum is 0, or below, the maximum will be set to math.MaxInt64.
func MockInputFloat64Modify(inputSlice []float64, modifier func(index int, value float64) float64) (floats []float64)MockInputFloat64Modify returns a modified version of a test set.
Example:
testset := testza.MockInputFloat64Modify(testza.MockInputFloat64Full(), func(index int, value float64) float64 {
return value * 2
})
func MockInputFloat64RunTests(t testRunner, testSet []float64, testFunc func(t *testing.T, index int, f float64))MockInputFloat64RunTests runs a test for every value in a testset. You can use the value as input parameter for your functions, to sanity test against many different cases. This ensures that your functions have a correct error handling and enables you to test against hunderts of cases easily.
Example:
testza.MockInputFloat64RunTests(t, testza.MockInputFloat64Full(), func(t *testing.T, index int, f float64) {
// Test logic
// err := YourFunction(f)
// testza.AssertNoError(t, err)
// ...
})
func MockInputIntFull() (ints []int)MockInputIntFull returns a combination of every integer testset and some random integers (positive and negative).
func MockInputIntGenerateRandomNegative(count, min int) (ints []int)MockInputIntGenerateRandomNegative generates random negative integers with a minimum of min. If the minimum is 0, or above, the maximum will be set to math.MinInt64.
func MockInputIntGenerateRandomPositive(count, max int) (ints []int)MockInputIntGenerateRandomPositive generates random positive integers with a maximum of max. If the maximum is 0, or below, the maximum will be set to math.MaxInt64.
func MockInputIntGenerateRandomRange(count, min, max int) (ints []int)MockInputIntGenerateRandomRange generates random integers with a range of min to max.
func MockInputIntModify(inputSlice []int, modifier func(index int, value int) int) (ints []int)MockInputIntModify returns a modified version of a test set.
Example:
testset := testza.MockInputIntModify(testza.MockInputIntFull(), func(index int, value int) int {
return value * 2
})
func MockInputIntRunTests(t testRunner, testSet []int, testFunc func(t *testing.T, index int, i int))MockInputIntRunTests runs a test for every value in a testset. You can use the value as input parameter for your functions, to sanity test against many different cases. This ensures that your functions have a correct error handling and enables you to test against hunderts of cases easily.
Example:
testza.MockInputIntRunTests(t, testza.MockInputIntFull(), func(t *testing.T, index int, i int) {
// Test logic
// err := YourFunction(i)
// testza.AssertNoError(t, err)
// ...
})
func MockInputStringEmailAddresses() []stringMockInputStringEmailAddresses returns a test set with valid email addresses.
func MockInputStringEmpty() []stringMockInputStringEmpty returns a test set with a single empty string.
func MockInputStringFull() (ret []string)MockInputStringFull contains all string test sets plus ten generated random strings.
func MockInputStringGenerateRandom(count, length int) (result []string)MockInputStringGenerateRandom returns random StringsHelper in a test set.
func MockInputStringHtmlTags() []stringMockInputStringHtmlTags returns a test set with html tags.
func MockInputStringLimit(testSet []string, max int) []stringMockInputStringLimit limits a test set in size.
func MockInputStringLong() (testSet []string)MockInputStringLong returns a test set with long random strings. Returns: - Random string (length: 25) - Random string (length: 50) - Random string (length: 100) - Random string (length: 1,000) - Random string (length: 100,000)
func MockInputStringModify(inputSlice []string, modifier func(index int, value string) string) (ret []string)MockInputStringModify returns a modified version of a test set.
Example:
testset := testza.MockInputStringModify(testza.MockInputStringFull(), func(index int, value string) string {
return value + " some suffix"
})
func MockInputStringNumeric() []stringMockInputStringNumeric returns a test set with strings that are numeric. The highest number in here is "9223372036854775807", which is equal to the maxmim int64.
func MockInputStringRunTests(t testRunner, testSet []string, testFunc func(t *testing.T, index int, str string))MockInputStringRunTests runs a test for every value in a testset. You can use the value as input parameter for your functions, to sanity test against many different cases. This ensures that your functions have a correct error handling and enables you to test against hunderts of cases easily.
Example:
testza.MockInputStringRunTests(t, testza.MockInputStringFull(), func(t *testing.T, index int, str string) {
// Test logic
// err := YourFunction(str)
// testza.AssertNoError(t, err)
// ...
})
func MockInputStringUsernames() []stringMockInputStringUsernames returns a test set with usernames.
func SetColorsEnabled(enabled bool)SetColorsEnabled controls if testza should print colored output. You should use this in the init() method of the package, which contains your tests.
Example:
init() {
testza.SetColorsEnabled(false) // Disable colored output
testza.SetColorsEnabled(true) // Enable colored output
}
func SetLineNumbersEnabled(enabled bool)SetLineNumbersEnabled controls if line numbers should be printed in failing tests. You should use this in the init() method of the package, which contains your tests.
Example:
init() {
testza.SetLineNumbersEnabled(false) // Disable line numbers
testza.SetLineNumbersEnabled(true) // Enable line numbers
}
func SnapshotCreate(name string, snapshotObject interface{}) errorSnapshotCreate creates a snapshot of an object, which can be validated in future test runs. Using this function directly will override previous snapshots with the same name. You most likely want to use SnapshotCreateOrValidate.
NOTICE: \r\n will be replaced with \n to make the files consistent between operating systems.
Example:
testza.SnapshotCreate(t.Name(), objectToBeSnapshotted)
func SnapshotCreateOrValidate(t testRunner, name string, object interface{}, msg ...interface{}) errorSnapshotCreateOrValidate creates a snapshot of an object which can be used in future test runs. It is good practice to name your snapshots the same as the test they are created in. You can do that automatically by using t.Name() as the second parameter, if you are using the inbuilt test system of Go. If a snapshot already exists, the function will not create a new one, but validate the exisiting one. To re-create a snapshot, you can delete the according file in /testdata/snapshots/.
NOTICE: \r\n will be replaced with \n to make the files consistent between operating systems.
Example:
testza.SnapshotCreateOrValidate(t, t.Name(), object)
testza.SnapshotCreateOrValidate(t, t.Name(), object, "Optional Message")
func SnapshotValidate(t testRunner, name string, actual interface{}, msg ...interface{}) errorSnapshotValidate validates an already exisiting snapshot of an object. You most likely want to use SnapshotCreateOrValidate.
NOTICE: \r\n will be replaced with \n to make the files consistent between operating systems.
Example:
testza.SnapshotValidate(t, t.Name(), objectToBeValidated)
testza.SnapshotValidate(t, t.Name(), objectToBeValidated, "Optional message")
Made with ❤️ by @MarvinJWendt and contributors! | MarvinJWendt.com
![dependabot[bot] avatar](https://avatars.githubusercontent.com/in/29110?v=4 "dependabot[bot]")
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent