| .. | ||
| internal | ||
| assertions.goconvey | ||
| collections.go | ||
| CONTRIBUTING.md | ||
| doc.go | ||
| equality.go | ||
| filter.go | ||
| LICENSE.md | ||
| messages.go | ||
| panic.go | ||
| quantity.go | ||
| README.md | ||
| serializer.go | ||
| strings.go | ||
| time.go | ||
| type.go | ||
assertions
-- import "github.com/smartystreets/assertions"
Package assertions contains the implementations for all assertions which are
referenced in goconvey's convey package
(github.com/smartystreets/goconvey/convey) and gunit
(github.com/smartystreets/gunit) for use with the So(...) method. They can also
be used in traditional Go test functions and even in applications.
Many of the assertions lean heavily on work done by Aaron Jacobs in his excellent oglematchers library. (https://github.com/jacobsa/oglematchers) The ShouldResemble assertion leans heavily on work done by Daniel Jacques in his very helpful go-render library. (https://github.com/luci/go-render)
Usage
func GoConveyMode
func GoConveyMode(yes bool)
GoConveyMode provides control over JSON serialization of failures. When using the assertions in this package from the convey package JSON results are very helpful and can be rendered in a DIFF view. In that case, this function will be called with a true value to enable the JSON serialization. By default, the assertions in this package will not serializer a JSON result, making standalone ussage more convenient.
func ShouldAlmostEqual
func ShouldAlmostEqual(actual interface{}, expected ...interface{}) string
ShouldAlmostEqual makes sure that two parameters are close enough to being equal. The acceptable delta may be specified with a third argument, or a very small default delta will be used.
func ShouldBeBetween
func ShouldBeBetween(actual interface{}, expected ...interface{}) string
ShouldBeBetween receives exactly three parameters: an actual value, a lower bound, and an upper bound. It ensures that the actual value is between both bounds (but not equal to either of them).
func ShouldBeBetweenOrEqual
func ShouldBeBetweenOrEqual(actual interface{}, expected ...interface{}) string
ShouldBeBetweenOrEqual receives exactly three parameters: an actual value, a lower bound, and an upper bound. It ensures that the actual value is between both bounds or equal to one of them.
func ShouldBeBlank
func ShouldBeBlank(actual interface{}, expected ...interface{}) string
ShouldBeBlank receives exactly 1 string parameter and ensures that it is equal to "".
func ShouldBeChronological
func ShouldBeChronological(actual interface{}, expected ...interface{}) string
ShouldBeChronological receives a []time.Time slice and asserts that the are in chronological order starting with the first time.Time as the earliest.
func ShouldBeEmpty
func ShouldBeEmpty(actual interface{}, expected ...interface{}) string
ShouldBeEmpty receives a single parameter (actual) and determines whether or not
calling len(actual) would return 0. It obeys the rules specified by the len
function for determining length: http://golang.org/pkg/builtin/#len
func ShouldBeFalse
func ShouldBeFalse(actual interface{}, expected ...interface{}) string
ShouldBeFalse receives a single parameter and ensures that it is false.
func ShouldBeGreaterThan
func ShouldBeGreaterThan(actual interface{}, expected ...interface{}) string
ShouldBeGreaterThan receives exactly two parameters and ensures that the first is greater than the second.
func ShouldBeGreaterThanOrEqualTo
func ShouldBeGreaterThanOrEqualTo(actual interface{}, expected ...interface{}) string
ShouldBeGreaterThanOrEqualTo receives exactly two parameters and ensures that the first is greater than or equal to the second.
func ShouldBeIn
func ShouldBeIn(actual interface{}, expected ...interface{}) string
ShouldBeIn receives at least 2 parameters. The first is a proposed member of the collection that is passed in either as the second parameter, or of the collection that is comprised of all the remaining parameters. This assertion ensures that the proposed member is in the collection (using ShouldEqual).
func ShouldBeLessThan
func ShouldBeLessThan(actual interface{}, expected ...interface{}) string
ShouldBeLessThan receives exactly two parameters and ensures that the first is less than the second.
func ShouldBeLessThanOrEqualTo
func ShouldBeLessThanOrEqualTo(actual interface{}, expected ...interface{}) string
ShouldBeLessThan receives exactly two parameters and ensures that the first is less than or equal to the second.
func ShouldBeNil
func ShouldBeNil(actual interface{}, expected ...interface{}) string
ShouldBeNil receives a single parameter and ensures that it is nil.
func ShouldBeTrue
func ShouldBeTrue(actual interface{}, expected ...interface{}) string
ShouldBeTrue receives a single parameter and ensures that it is true.
func ShouldBeZeroValue
func ShouldBeZeroValue(actual interface{}, expected ...interface{}) string
ShouldBeZeroValue receives a single parameter and ensures that it is the Go equivalent of the default value, or "zero" value.
func ShouldContain
func ShouldContain(actual interface{}, expected ...interface{}) string
ShouldContain receives exactly two parameters. The first is a slice and the second is a proposed member. Membership is determined using ShouldEqual.
func ShouldContainKey
func ShouldContainKey(actual interface{}, expected ...interface{}) string
ShouldContainKey receives exactly two parameters. The first is a map and the second is a proposed key. Keys are compared with a simple '=='.
func ShouldContainSubstring
func ShouldContainSubstring(actual interface{}, expected ...interface{}) string
ShouldContainSubstring receives exactly 2 string parameters and ensures that the first contains the second as a substring.
func ShouldEndWith
func ShouldEndWith(actual interface{}, expected ...interface{}) string
ShouldEndWith receives exactly 2 string parameters and ensures that the first ends with the second.
func ShouldEqual
func ShouldEqual(actual interface{}, expected ...interface{}) string
ShouldEqual receives exactly two parameters and does an equality check.
func ShouldEqualTrimSpace
func ShouldEqualTrimSpace(actual interface{}, expected ...interface{}) string
ShouldEqualTrimSpace receives exactly 2 string parameters and ensures that the first is equal to the second after removing all leading and trailing whitespace using strings.TrimSpace(first).
func ShouldEqualWithout
func ShouldEqualWithout(actual interface{}, expected ...interface{}) string
ShouldEqualWithout receives exactly 3 string parameters and ensures that the first is equal to the second after removing all instances of the third from the first using strings.Replace(first, third, "", -1).
func ShouldHappenAfter
func ShouldHappenAfter(actual interface{}, expected ...interface{}) string
ShouldHappenAfter receives exactly 2 time.Time arguments and asserts that the first happens after the second.
func ShouldHappenBefore
func ShouldHappenBefore(actual interface{}, expected ...interface{}) string
ShouldHappenBefore receives exactly 2 time.Time arguments and asserts that the first happens before the second.
func ShouldHappenBetween
func ShouldHappenBetween(actual interface{}, expected ...interface{}) string
ShouldHappenBetween receives exactly 3 time.Time arguments and asserts that the first happens between (not on) the second and third.
func ShouldHappenOnOrAfter
func ShouldHappenOnOrAfter(actual interface{}, expected ...interface{}) string
ShouldHappenOnOrAfter receives exactly 2 time.Time arguments and asserts that the first happens on or after the second.
func ShouldHappenOnOrBefore
func ShouldHappenOnOrBefore(actual interface{}, expected ...interface{}) string
ShouldHappenOnOrBefore receives exactly 2 time.Time arguments and asserts that the first happens on or before the second.
func ShouldHappenOnOrBetween
func ShouldHappenOnOrBetween(actual interface{}, expected ...interface{}) string
ShouldHappenOnOrBetween receives exactly 3 time.Time arguments and asserts that the first happens between or on the second and third.
func ShouldHappenWithin
func ShouldHappenWithin(actual interface{}, expected ...interface{}) string
ShouldHappenWithin receives a time.Time, a time.Duration, and a time.Time (3 arguments) and asserts that the first time.Time happens within or on the duration specified relative to the other time.Time.
func ShouldHaveLength
func ShouldHaveLength(actual interface{}, expected ...interface{}) string
ShouldHaveLength receives 2 parameters. The first is a collection to check the length of, the second being the expected length. It obeys the rules specified by the len function for determining length: http://golang.org/pkg/builtin/#len
func ShouldHaveSameTypeAs
func ShouldHaveSameTypeAs(actual interface{}, expected ...interface{}) string
ShouldHaveSameTypeAs receives exactly two parameters and compares their underlying types for equality.
func ShouldImplement
func ShouldImplement(actual interface{}, expectedList ...interface{}) string
ShouldImplement receives exactly two parameters and ensures that the first implements the interface type of the second.
func ShouldNotAlmostEqual
func ShouldNotAlmostEqual(actual interface{}, expected ...interface{}) string
ShouldNotAlmostEqual is the inverse of ShouldAlmostEqual
func ShouldNotBeBetween
func ShouldNotBeBetween(actual interface{}, expected ...interface{}) string
ShouldNotBeBetween receives exactly three parameters: an actual value, a lower bound, and an upper bound. It ensures that the actual value is NOT between both bounds.
func ShouldNotBeBetweenOrEqual
func ShouldNotBeBetweenOrEqual(actual interface{}, expected ...interface{}) string
ShouldNotBeBetweenOrEqual receives exactly three parameters: an actual value, a lower bound, and an upper bound. It ensures that the actual value is nopt between the bounds nor equal to either of them.
func ShouldNotBeBlank
func ShouldNotBeBlank(actual interface{}, expected ...interface{}) string
ShouldNotBeBlank receives exactly 1 string parameter and ensures that it is equal to "".
func ShouldNotBeEmpty
func ShouldNotBeEmpty(actual interface{}, expected ...interface{}) string
ShouldNotBeEmpty receives a single parameter (actual) and determines whether or
not calling len(actual) would return a value greater than zero. It obeys the
rules specified by the len function for determining length:
http://golang.org/pkg/builtin/#len
func ShouldNotBeIn
func ShouldNotBeIn(actual interface{}, expected ...interface{}) string
ShouldNotBeIn receives at least 2 parameters. The first is a proposed member of the collection that is passed in either as the second parameter, or of the collection that is comprised of all the remaining parameters. This assertion ensures that the proposed member is NOT in the collection (using ShouldEqual).
func ShouldNotBeNil
func ShouldNotBeNil(actual interface{}, expected ...interface{}) string
ShouldNotBeNil receives a single parameter and ensures that it is not nil.
func ShouldNotContain
func ShouldNotContain(actual interface{}, expected ...interface{}) string
ShouldNotContain receives exactly two parameters. The first is a slice and the second is a proposed member. Membership is determinied using ShouldEqual.
func ShouldNotContainKey
func ShouldNotContainKey(actual interface{}, expected ...interface{}) string
ShouldNotContainKey receives exactly two parameters. The first is a map and the second is a proposed absent key. Keys are compared with a simple '=='.
func ShouldNotContainSubstring
func ShouldNotContainSubstring(actual interface{}, expected ...interface{}) string
ShouldNotContainSubstring receives exactly 2 string parameters and ensures that the first does NOT contain the second as a substring.
func ShouldNotEndWith
func ShouldNotEndWith(actual interface{}, expected ...interface{}) string
ShouldEndWith receives exactly 2 string parameters and ensures that the first does not end with the second.
func ShouldNotEqual
func ShouldNotEqual(actual interface{}, expected ...interface{}) string
ShouldNotEqual receives exactly two parameters and does an inequality check.
func ShouldNotHappenOnOrBetween
func ShouldNotHappenOnOrBetween(actual interface{}, expected ...interface{}) string
ShouldNotHappenOnOrBetween receives exactly 3 time.Time arguments and asserts that the first does NOT happen between or on the second or third.
func ShouldNotHappenWithin
func ShouldNotHappenWithin(actual interface{}, expected ...interface{}) string
ShouldNotHappenWithin receives a time.Time, a time.Duration, and a time.Time (3 arguments) and asserts that the first time.Time does NOT happen within or on the duration specified relative to the other time.Time.
func ShouldNotHaveSameTypeAs
func ShouldNotHaveSameTypeAs(actual interface{}, expected ...interface{}) string
ShouldNotHaveSameTypeAs receives exactly two parameters and compares their underlying types for inequality.
func ShouldNotImplement
func ShouldNotImplement(actual interface{}, expectedList ...interface{}) string
ShouldNotImplement receives exactly two parameters and ensures that the first does NOT implement the interface type of the second.
func ShouldNotPanic
func ShouldNotPanic(actual interface{}, expected ...interface{}) (message string)
ShouldNotPanic receives a void, niladic function and expects to execute the function without any panic.
func ShouldNotPanicWith
func ShouldNotPanicWith(actual interface{}, expected ...interface{}) (message string)
ShouldNotPanicWith receives a void, niladic function and expects to recover a panic whose content differs from the second argument.
func ShouldNotPointTo
func ShouldNotPointTo(actual interface{}, expected ...interface{}) string
ShouldNotPointTo receives exactly two parameters and checks to see that they point to different addresess.
func ShouldNotResemble
func ShouldNotResemble(actual interface{}, expected ...interface{}) string
ShouldNotResemble receives exactly two parameters and does an inverse deep equal check (see reflect.DeepEqual)
func ShouldNotStartWith
func ShouldNotStartWith(actual interface{}, expected ...interface{}) string
ShouldNotStartWith receives exactly 2 string parameters and ensures that the first does not start with the second.
func ShouldPanic
func ShouldPanic(actual interface{}, expected ...interface{}) (message string)
ShouldPanic receives a void, niladic function and expects to recover a panic.
func ShouldPanicWith
func ShouldPanicWith(actual interface{}, expected ...interface{}) (message string)
ShouldPanicWith receives a void, niladic function and expects to recover a panic with the second argument as the content.
func ShouldPointTo
func ShouldPointTo(actual interface{}, expected ...interface{}) string
ShouldPointTo receives exactly two parameters and checks to see that they point to the same address.
func ShouldResemble
func ShouldResemble(actual interface{}, expected ...interface{}) string
ShouldResemble receives exactly two parameters and does a deep equal check (see reflect.DeepEqual)
func ShouldStartWith
func ShouldStartWith(actual interface{}, expected ...interface{}) string
ShouldStartWith receives exactly 2 string parameters and ensures that the first starts with the second.
func So
func So(actual interface{}, assert assertion, expected ...interface{}) (bool, string)
So is a convenience function (as opposed to an inconvenience function?) for
running assertions on arbitrary arguments in any context, be it for testing or
even application logging. It allows you to perform assertion-like behavior (and
get nicely formatted messages detailing discrepancies) but without the program
blowing up or panicking. All that is required is to import this package and call
So with one of the assertions exported by this package as the second
parameter. The first return parameter is a boolean indicating if the assertion
was true. The second return parameter is the well-formatted message showing why
an assertion was incorrect, or blank if the assertion was correct.
Example:
if ok, message := So(x, ShouldBeGreaterThan, y); !ok {
log.Println(message)
}
type Assertion
type Assertion struct {
}
func New
func New(t testingT) *Assertion
New swallows the *testing.T struct and prints failed assertions using t.Error. Example: assertions.New(t).So(1, should.Equal, 1)
func (*Assertion) Failed
func (this *Assertion) Failed() bool
Failed reports whether any calls to So (on this Assertion instance) have failed.
func (*Assertion) So
func (this *Assertion) So(actual interface{}, assert assertion, expected ...interface{}) bool
So calls the standalone So function and additionally, calls t.Error in failure scenarios.
type FailureView
type FailureView struct {
Message string `json:"Message"`
Expected string `json:"Expected"`
Actual string `json:"Actual"`
}
This struct is also declared in github.com/smartystreets/goconvey/convey/reporting. The json struct tags should be equal in both declarations.
type Serializer
type Serializer interface {
// contains filtered or unexported methods
}