assert

README

• testcase/assert

testcase/assert

This package meant to provide a small and dependency lightweight implementation for common assertion related requirements.

• Go pkg documentation

Example:

assert.Should(tb).True(true)
assert.Must(tb).Equal(expected, actual, "error message")
assert.Must(tb).NotEqual(true, false, "exp")
assert.Must(tb).Contain([]int{1, 2, 3}, 3, "exp")
assert.Must(tb).Contain([]int{1, 2, 3}, []int{1, 2}, "exp")
assert.Must(tb).Contain(map[string]int{"The Answer": 42, "oth": 13}, map[string]int{"The Answer": 42}, "exp")

For more examples, check out the example_test.go file.

Documentation

Index

• type AnyOf
  • func (ao *AnyOf) Finish(msg ...interface{})
  • func (ao *AnyOf) Test(blk func(it It))
• type Asserter
  • func Must(tb testing.TB) Asserter
  • func Should(tb testing.TB) Asserter
  • func (a Asserter) AnyOf(blk func(a *AnyOf), msg ...interface{})
  • func (a Asserter) Contain(src, has interface{}, msg ...interface{})
  • func (a Asserter) ContainExactly(expected, actual interface{}, msg ...interface{})
  • func (a Asserter) Empty(v interface{}, msg ...interface{})
  • func (a Asserter) Equal(expected, actually interface{}, msg ...interface{})
  • func (a Asserter) ErrorIs(expected, actual error, msg ...interface{})
  • func (a Asserter) False(v bool, msg ...interface{})
  • func (a Asserter) Nil(v interface{}, msg ...interface{})
  • func (a Asserter) NotContain(source, oth interface{}, msg ...interface{})
  • func (a Asserter) NotEmpty(v interface{}, msg ...interface{})
  • func (a Asserter) NotEqual(v, oth interface{}, msg ...interface{})
  • func (a Asserter) NotNil(v interface{}, msg ...interface{})
  • func (a Asserter) NotPanic(blk func(), msg ...interface{})
  • func (a Asserter) Panic(blk func(), msg ...interface{}) (panicValue interface{})
  • func (a Asserter) True(v bool, msg ...interface{})
• type It
  • func MakeIt(tb testing.TB) It

Examples

• AnyOf (FanOutPublishing)
• AnyOf (ListOfCompositedStructuresWhereOnlyTheEmbededValueIsRelevant)
• AnyOf (ListOfInterface)
• AnyOf (ListOfStructuresWithIrrelevantValues)
• AnyOf (StructWithManyAcceptableState)
• Asserter.AnyOf
• Asserter.Contain
• Asserter.ContainExactly
• Asserter.Empty
• Asserter.Equal
• Asserter.Equal (IsEqualFunctionThatSupportsErrorReturning)
• Asserter.Equal (IsEqualFunctionUsedForComparison)
• Asserter.ErrorIs
• Asserter.False
• Asserter.Nil
• Asserter.NotContain
• Asserter.NotEmpty
• Asserter.NotEqual
• Asserter.NotNil
• Asserter.NotPanic
• Asserter.Panic
• Asserter.True
• Must
• Should

Types

type AnyOf

type AnyOf struct {
	TB testing.TB
	Fn func(...interface{})
	// contains filtered or unexported fields
}

AnyOf is an assertion helper that allows you run AnyOf.Test assertion blocks, that can fail, as lone at least one of them succeeds. common usage use-cases:

• list of interface, where test order, or the underlying structure's implementation is irrelevant for the behavior.
• list of big structures, where not all field value relevant, only a subset, like a structure it wraps under a field.
• list of structures with fields that has dynamic state values, which is irrelevant for the given test.
• structure that can have various state scenario, and you want to check all of them, and you expect to find one match with the input.
• fan out scenario, where you need to check in parallel that at least one of the worker received the event.

Example (FanOutPublishing)

Example (ListOfCompositedStructuresWhereOnlyTheEmbededValueIsRelevant)

Example (ListOfInterface)

Example (ListOfStructuresWithIrrelevantValues)

Example (StructWithManyAcceptableState)

func (*AnyOf) Finish

func (ao *AnyOf) Finish(msg ...interface{})

Finish will check if any of the assertion succeeded.

func (*AnyOf) Test

func (ao *AnyOf) Test(blk func(it It))

Test will test a block of assertion that must succeed in order to make AnyOf pass. You can have as much AnyOf.Test calls as you need, but if any of them pass with success, the rest will be skipped. Using Test is safe for concurrently.

type Asserter

type Asserter struct {
	TB testing.TB
	Fn func(args ...interface{})
}

func Must

func Must(tb testing.TB) Asserter

Example

func Should

func Should(tb testing.TB) Asserter

Example

func (Asserter) AnyOf

func (a Asserter) AnyOf(blk func(a *AnyOf), msg ...interface{})

Example

func (Asserter) Contain

func (a Asserter) Contain(src, has interface{}, msg ...interface{})

Example

func (Asserter) ContainExactly

func (a Asserter) ContainExactly(expected, actual interface{}, msg ...interface{})

Example

func (Asserter) Empty

func (a Asserter) Empty(v interface{}, msg ...interface{})

Empty gets whether the specified value is considered empty.

Example

func (Asserter) Equal

func (a Asserter) Equal(expected, actually interface{}, msg ...interface{})

Example

Example (IsEqualFunctionThatSupportsErrorReturning)

Example (IsEqualFunctionUsedForComparison)

func (Asserter) ErrorIs

func (a Asserter) ErrorIs(expected, actual error, msg ...interface{})

ErrorIs allows you to assert an error value by an expectation. if the implementation of the test subject later changes, and for example, it starts to use wrapping, this should not be an issue as the IsEqualErr's error chain is also matched against the expectation.

Example

func (Asserter) False

func (a Asserter) False(v bool, msg ...interface{})

Example

func (Asserter) Nil

func (a Asserter) Nil(v interface{}, msg ...interface{})

Example

func (Asserter) NotContain

func (a Asserter) NotContain(source, oth interface{}, msg ...interface{})

Example

func (Asserter) NotEmpty

func (a Asserter) NotEmpty(v interface{}, msg ...interface{})

NotEmpty gets whether the specified value is considered empty.

Example

func (Asserter) NotEqual

func (a Asserter) NotEqual(v, oth interface{}, msg ...interface{})

Example

func (Asserter) NotNil

func (a Asserter) NotNil(v interface{}, msg ...interface{})

Example

func (Asserter) NotPanic

func (a Asserter) NotPanic(blk func(), msg ...interface{})

Example

func (Asserter) Panic

func (a Asserter) Panic(blk func(), msg ...interface{}) (panicValue interface{})

Example

func (Asserter) True

func (a Asserter) True(v bool, msg ...interface{})

Example

type It

type It struct {
	testing.TB
	// Must Asserter will use FailNow on a failed assertion.
	// This will make test exit early on.
	Must Asserter
	// Should Asserter's will allow to continue the test scenario,
	// but mark test failed on a failed assertion.
	Should Asserter
}

func MakeIt

func MakeIt(tb testing.TB) It