testza

package module
v0.2.12 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 3, 2021 License: MIT Imports: 19 Imported by: 0

README

testza 🍕

Testza is like pizza for Go - you could live without it, but why should you?

Latest Release Tests Coverage Unit test count Go Reference Go report

Get The Module | Documentation | Contributing | Code of Conduct

Screenshot of an example test message

Installation

# Execute this command inside your project
go get github.com/MarvinJWendt/testza

Description

Testza 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.

Getting Started

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!

Documentation

Module Methods
Settings
Click to expand
Assert
Click to expand
Capture
Click to expand
Mock Input Bool
Click to expand
Mock Input String
Click to expand
Mock Input Float64
Click to expand
Mock Input Int
Click to expand
Snapshot
Click to expand

Assert

AssertCompletesIn
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
AssertContains
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")
AssertDecreasing
func AssertDecreasing(t testRunner, object interface{}, msg ...interface{})

AssertDecreasing asserts that the values in a slice are decreasing. the test fails if the values are not in a slice or if the values are not comparable.

Valid input kinds are: []int, []int8, []int16, []int32, []int64, []uint, []uint8, []uint16, []uint32, []uint64, []float32, []float64.

Example:

testza.AssertDecreasing(t, []int{1000, 137, 2, 1})
testza.AssertDecreasing(t, []float32{13.5, 7, 0.1, -10.3})
AssertDirEmpty
func AssertDirEmpty(t testRunner, dir string, msg ...interface{})

AssertDirEmpty asserts that a directory is empty. The test will pass when the directory is empty or does not exist.

Example:

testza.AssertDirEmpty(t, "FolderName")
AssertDirExist
func AssertDirExist(t testRunner, dir string, msg ...interface{})

AssertDirExist asserts that a directory exists. The test will pass when the directory exists, and it's visible to the current user. The test will fail, if the path points to a file.

Example:

testza.AssertDirExist(t, "FolderName")
AssertDirNotEmpty
func AssertDirNotEmpty(t testRunner, dir string, msg ...interface{})

AssertDirNotEmpty asserts that a directory is not empty

Example:

testza.AssertDirNotEmpty(t, "FolderName")
AssertEqual
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)
AssertEqualValues
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)
AssertErrorIs
func AssertErrorIs(t testRunner, err, target error, msg ...interface{})

AssertErrorIs asserts that target is inside the error chain of err.

Example:

var testErr = errors.New("hello world")
var testErrWrapped = fmt.Errorf("test err: %w", testErr)
testza.AssertErrorIs(t, testErrWrapped ,testErr)
AssertFalse
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)
AssertFileExists
func AssertFileExists(t testRunner, file string, msg ...interface{})

AssertFileExists asserts that a file exists.

Example:

testza.AssertFileExists(t, "./test.txt")
testza.AssertFileExists(t, "./config.yaml", "the config file is missing")
AssertGreater
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)
AssertImplements
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
AssertIncreasing
func AssertIncreasing(t testRunner, object interface{}, msg ...interface{})

AssertIncreasing asserts that the values in a slice are increasing. the test fails if the values are not in a slice or if the values are not comparable.

Valid input kinds are: []int, []int8, []int16, []int32, []int64, []uint, []uint8, []uint16, []uint32, []uint64, []float32, []float64.

Example:

testza.AssertIncreasing(t, []int{1, 2, 137, 1000})
testza.AssertIncreasing(t, []float32{-10.3, 0.1, 7, 13.5})
AssertKindOf
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{})
AssertLen
func AssertLen(t testRunner, object interface{}, length int, msg ...interface{})

AssertLen asserts that the length of an object is equal to the given length.

Example:

testza.AssertLen(t, "abc", 3)
testza.AssertLen(t, "Assert", 6)
testza.AssertLen(t, []int{1, 2, 1337, 25}, 4)
testza.AssertLen(t, map[string]int{"asd": 1, "test": 1337}, 2)
AssertLess
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)
AssertNil
func AssertNil(t testRunner, object interface{}, msg ...interface{})

AssertNil asserts that an object is nil.

Example:

testza.AssertNil(t, nil)
AssertNoDirExists
func AssertNoDirExists(t testRunner, dir string, msg ...interface{})

AssertNoDirExists asserts that a directory does not exists. The test will pass, if the path points to a file, as a directory with the same name, cannot exist.

Example:

testza.AssertNoDirExists(t, "FolderName")
AssertNoError
func AssertNoError(t testRunner, err error, msg ...interface{})

AssertNoError asserts that an error is nil.

Example:

err := nil
testza.AssertNoError(t, err)
AssertNoFileExists
func AssertNoFileExists(t testRunner, file string, msg ...interface{})
AssertNotCompletesIn
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
AssertNotContains
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")
AssertNotEqual
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")
AssertNotEqualValues
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)
AssertNotErrorIs
func AssertNotErrorIs(t testRunner, err, target error, msg ...interface{})

AssertNotErrorIs

Example:

var testErr = errors.New("hello world")
var test2Err = errors.New("hello world 2")
var testErrWrapped = fmt.Errorf("test err: %w", testErr)
testza.AssertNotErrorIs(t, testErrWrapped, test2Err)
AssertNotImplements
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.
AssertNotKindOf
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)
AssertNotNil
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)
AssertNotNumeric
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")
AssertNotPanics
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
AssertNotRegexp
func AssertNotRegexp(t testRunner, regex interface{}, txt interface{}, msg ...interface{})

AssertNotRegexp asserts that a string does not match a given regexp.

Example:

testza.AssertNotRegexp(t, "ab.*", "Hello, World!")
AssertNotZero
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")
AssertNumeric
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))
AssertPanics
func AssertPanics(t testRunner, f func(), msg ...interface{})

AssertPanics asserts that a function panics.

Example:

testza.AssertPanics(t, func() {
	// ...
	panic("some panic")
}) // => PASS
AssertRegexp
func AssertRegexp(t testRunner, regex interface{}, txt interface{}, msg ...interface{})

AssertRegexp asserts that a string matches a given regexp.

Example:

testza.AssertRegexp(t, "^a.*c$", "abc")
AssertTestFails
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
AssertTrue
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)
AssertZero
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, "")

Capture

CaptureStderr
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)
CaptureStdout
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)
CaptureStdoutAndStderr
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)

Mock Input Bool

MockInputBoolFull
func MockInputBoolFull() []bool

MockInputBoolFull returns true and false in a boolean slice.

MockInputBoolModify
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
})
MockInputBoolRunTests
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)
	// ...
})

Mock Input Float64

MockInputFloat64Full
func MockInputFloat64Full() (floats []float64)

MockInputFloat64Full returns a combination of every float64 testset and some random float64s (positive and negative).

MockInputFloat64GenerateRandomNegative
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.

MockInputFloat64GenerateRandomPositive
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.

MockInputFloat64GenerateRandomRange
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.

MockInputFloat64Modify
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
})
MockInputFloat64RunTests
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)
	// ...
})

Mock Input Int

MockInputIntFull
func MockInputIntFull() (ints []int)

MockInputIntFull returns a combination of every integer testset and some random integers (positive and negative).

MockInputIntGenerateRandomNegative
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.

MockInputIntGenerateRandomPositive
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.

MockInputIntGenerateRandomRange
func MockInputIntGenerateRandomRange(count, min, max int) (ints []int)

MockInputIntGenerateRandomRange generates random integers with a range of min to max.

MockInputIntModify
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
})
MockInputIntRunTests
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)
	// ...
})

Mock Input String

MockInputStringEmailAddresses
func MockInputStringEmailAddresses() []string

MockInputStringEmailAddresses returns a test set with valid email addresses. The addresses may look like they are invalid, but they are all conform to RFC 2822 and could be used. You can use this test set to test your email validation process.

MockInputStringEmpty
func MockInputStringEmpty() []string

MockInputStringEmpty returns a test set with a single empty string.

MockInputStringFull
func MockInputStringFull() (ret []string)

MockInputStringFull contains all string test sets plus ten generated random strings. This test set is huge and should only be used if you want to make sure that no string, at all, can crash a process.

MockInputStringGenerateRandom
func MockInputStringGenerateRandom(count, length int) (result []string)

MockInputStringGenerateRandom returns random strings in a test set.

MockInputStringHtmlTags
func MockInputStringHtmlTags() []string

MockInputStringHtmlTags returns a test set with different html tags.

Example:

- <script>
- <script>alert('XSS')</script>
- <a href="https://github.com/MarvinJWendt/testza">link</a>
MockInputStringLimit
func MockInputStringLimit(testSet []string, max int) []string

MockInputStringLimit limits a test set in size.

MockInputStringLong
func MockInputStringLong() (testSet []string)

MockInputStringLong returns a test set with long random strings. Returns: [0]: Random string (length: 25) [1]: Random string (length: 50) [2]: Random string (length: 100) [3]: Random string (length: 1,000) [4]: Random string (length: 100,000)

MockInputStringModify
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"
})
MockInputStringNumeric
func MockInputStringNumeric() []string

MockInputStringNumeric returns a test set with strings that are numeric. The highest number in here is "9223372036854775807", which is equal to the maxmim int64.

MockInputStringRunTests
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)
	// ...
})
MockInputStringUsernames
func MockInputStringUsernames() []string

MockInputStringUsernames returns a test set with usernames.

Settings

SetColorsEnabled
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
}
SetLineNumbersEnabled
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
}
SetRandomSeed
func SetRandomSeed(seed int64)

SetRandomSeed sets the seed for the random generator used in testza. Using the same seed will result in the same random sequences each time and guarantee a reproducible test run. Use this setting, if you want a 100% deterministic test. You should use this in the init() method of the package, which contains your tests.

Example:

init() {
  testza.SetRandomSeed(1337) // Set the seed to 1337
  testza.SetRandomSeed(time.Now().UnixNano()) // Set the seed back to the current time (default | non-deterministic)
}

Snapshot

SnapshotCreate
func SnapshotCreate(name string, snapshotObject interface{}) error

SnapshotCreate 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)
SnapshotCreateOrValidate
func SnapshotCreateOrValidate(t testRunner, name string, object interface{}, msg ...interface{}) error

SnapshotCreateOrValidate 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")
SnapshotValidate
func SnapshotValidate(t testRunner, name string, actual interface{}, msg ...interface{}) error

SnapshotValidate 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

Documentation

Overview

Package testza 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.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AssertCompletesIn 

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 

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 AssertDecreasing 

func AssertDecreasing(t testRunner, object interface{}, msg ...interface{})

AssertDecreasing asserts that the values in a slice are decreasing. the test fails if the values are not in a slice or if the values are not comparable.

Valid input kinds are: []int, []int8, []int16, []int32, []int64, []uint, []uint8, []uint16, []uint32, []uint64, []float32, []float64.

Example: 

testza.AssertDecreasing(t, []int{1000, 137, 2, 1})
testza.AssertDecreasing(t, []float32{13.5, 7, 0.1, -10.3})

func AssertDirEmpty 

func AssertDirEmpty(t testRunner, dir string, msg ...interface{})

AssertDirEmpty asserts that a directory is empty. The test will pass when the directory is empty or does not exist.

Example: 

testza.AssertDirEmpty(t, "FolderName")

func AssertDirExist 

func AssertDirExist(t testRunner, dir string, msg ...interface{})

AssertDirExist asserts that a directory exists. The test will pass when the directory exists, and it's visible to the current user. The test will fail, if the path points to a file.

Example: 

testza.AssertDirExist(t, "FolderName")

func AssertDirNotEmpty 

func AssertDirNotEmpty(t testRunner, dir string, msg ...interface{})

AssertDirNotEmpty asserts that a directory is not empty

Example: 

testza.AssertDirNotEmpty(t, "FolderName")

func AssertEqual 

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 

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 AssertErrorIs 

func AssertErrorIs(t testRunner, err, target error, msg ...interface{})

AssertErrorIs asserts that target is inside the error chain of err.

Example: 

var testErr = errors.New("hello world")
var testErrWrapped = fmt.Errorf("test err: %w", testErr)
testza.AssertErrorIs(t, testErrWrapped ,testErr)

func AssertFalse 

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 AssertFileExists 

func AssertFileExists(t testRunner, file string, msg ...interface{})

AssertFileExists asserts that a file exists.

Example: 

testza.AssertFileExists(t, "./test.txt")
testza.AssertFileExists(t, "./config.yaml", "the config file is missing")

func AssertGreater 

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 

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 AssertIncreasing 

func AssertIncreasing(t testRunner, object interface{}, msg ...interface{})

AssertIncreasing asserts that the values in a slice are increasing. the test fails if the values are not in a slice or if the values are not comparable.

Valid input kinds are: []int, []int8, []int16, []int32, []int64, []uint, []uint8, []uint16, []uint32, []uint64, []float32, []float64.

Example: 

testza.AssertIncreasing(t, []int{1, 2, 137, 1000})
testza.AssertIncreasing(t, []float32{-10.3, 0.1, 7, 13.5})

func AssertKindOf 

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 AssertLen 

func AssertLen(t testRunner, object interface{}, length int, msg ...interface{})

AssertLen asserts that the length of an object is equal to the given length.

Example: 

testza.AssertLen(t, "abc", 3)
testza.AssertLen(t, "Assert", 6)
testza.AssertLen(t, []int{1, 2, 1337, 25}, 4)
testza.AssertLen(t, map[string]int{"asd": 1, "test": 1337}, 2)

func AssertLess 

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 

func AssertNil(t testRunner, object interface{}, msg ...interface{})

AssertNil asserts that an object is nil.

Example: 

testza.AssertNil(t, nil)

func AssertNoDirExists 

func AssertNoDirExists(t testRunner, dir string, msg ...interface{})

AssertNoDirExists asserts that a directory does not exists. The test will pass, if the path points to a file, as a directory with the same name, cannot exist.

Example: 

testza.AssertNoDirExists(t, "FolderName")

func AssertNoError 

func AssertNoError(t testRunner, err error, msg ...interface{})

AssertNoError asserts that an error is nil.

Example: 

err := nil
testza.AssertNoError(t, err)

func AssertNoFileExists 

func AssertNoFileExists(t testRunner, file string, msg ...interface{})

func AssertNotCompletesIn 

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 

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 

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 

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 AssertNotErrorIs 

func AssertNotErrorIs(t testRunner, err, target error, msg ...interface{})

AssertNotErrorIs

Example: 

var testErr = errors.New("hello world")
var test2Err = errors.New("hello world 2")
var testErrWrapped = fmt.Errorf("test err: %w", testErr)
testza.AssertNotErrorIs(t, testErrWrapped, test2Err)

func AssertNotImplements 

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 

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 

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 

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 

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 AssertNotRegexp 

func AssertNotRegexp(t testRunner, regex interface{}, txt interface{}, msg ...interface{})

AssertNotRegexp asserts that a string does not match a given regexp.

Example: 

testza.AssertNotRegexp(t, "ab.*", "Hello, World!")

func AssertNotZero 

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 

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 

func AssertPanics(t testRunner, f func(), msg ...interface{})

AssertPanics asserts that a function panics.

Example: 

testza.AssertPanics(t, func() {
	// ...
	panic("some panic")
}) // => PASS

func AssertRegexp 

func AssertRegexp(t testRunner, regex interface{}, txt interface{}, msg ...interface{})

AssertRegexp asserts that a string matches a given regexp.

Example: 

testza.AssertRegexp(t, "^a.*c$", "abc")

func AssertTestFails 

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 

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 

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 

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 

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 

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 

func MockInputBoolFull() []bool

MockInputBoolFull returns true and false in a boolean slice.

func MockInputBoolModify 

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 

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 

func MockInputFloat64Full() (floats []float64)

MockInputFloat64Full returns a combination of every float64 testset and some random float64s (positive and negative).

func MockInputFloat64GenerateRandomNegative 

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 

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 

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 

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 

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 

func MockInputIntFull() (ints []int)

MockInputIntFull returns a combination of every integer testset and some random integers (positive and negative).

func MockInputIntGenerateRandomNegative 

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 

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 

func MockInputIntGenerateRandomRange(count, min, max int) (ints []int)

MockInputIntGenerateRandomRange generates random integers with a range of min to max.

func MockInputIntModify 

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 

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 

func MockInputStringEmailAddresses() []string

MockInputStringEmailAddresses returns a test set with valid email addresses. The addresses may look like they are invalid, but they are all conform to RFC 2822 and could be used. You can use this test set to test your email validation process.

func MockInputStringEmpty 

func MockInputStringEmpty() []string

MockInputStringEmpty returns a test set with a single empty string.

func MockInputStringFull 

func MockInputStringFull() (ret []string)

MockInputStringFull contains all string test sets plus ten generated random strings. This test set is huge and should only be used if you want to make sure that no string, at all, can crash a process.

func MockInputStringGenerateRandom 

func MockInputStringGenerateRandom(count, length int) (result []string)

MockInputStringGenerateRandom returns random strings in a test set.

func MockInputStringHtmlTags 

func MockInputStringHtmlTags() []string

MockInputStringHtmlTags returns a test set with different html tags.

Example:

func MockInputStringLimit 

func MockInputStringLimit(testSet []string, max int) []string

MockInputStringLimit limits a test set in size.

func MockInputStringLong 

func MockInputStringLong() (testSet []string)

MockInputStringLong returns a test set with long random strings. Returns: [0]: Random string (length: 25) [1]: Random string (length: 50) [2]: Random string (length: 100) [3]: Random string (length: 1,000) [4]: Random string (length: 100,000)

func MockInputStringModify 

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 

func MockInputStringNumeric() []string

MockInputStringNumeric 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 

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 

func MockInputStringUsernames() []string

MockInputStringUsernames returns a test set with usernames.

func SetColorsEnabled 

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 

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 SetRandomSeed 

func SetRandomSeed(seed int64)

SetRandomSeed sets the seed for the random generator used in testza. Using the same seed will result in the same random sequences each time and guarantee a reproducible test run. Use this setting, if you want a 100% deterministic test. You should use this in the init() method of the package, which contains your tests.

Example: 

init() {
  testza.SetRandomSeed(1337) // Set the seed to 1337
  testza.SetRandomSeed(time.Now().UnixNano()) // Set the seed back to the current time (default | non-deterministic)
}

func SnapshotCreate 

func SnapshotCreate(name string, snapshotObject interface{}) error

SnapshotCreate 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 

func SnapshotCreateOrValidate(t testRunner, name string, object interface{}, msg ...interface{}) error

SnapshotCreateOrValidate 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 

func SnapshotValidate(t testRunner, name string, actual interface{}, msg ...interface{}) error

SnapshotValidate 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")

Types

type TestingPackageWithFailFunctions 

type TestingPackageWithFailFunctions interface {
	Error(args ...interface{})
	Errorf(format string, args ...interface{})
	Fail()
	FailNow()
	Fatal(args ...interface{})
	Fatalf(format string, args ...interface{})
}

TestingPackageWithFailFunctions contains every function that fails a test in testing.T.

Source Files

View all Source files

Directories

Path Synopsis
Custom CI-System for https://github.com/MarvinJWendt/testza.
 Custom CI-System for https://github.com/MarvinJWendt/testza.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.