README

Build Status Code Coverage Go Report Card GoDoc

Documentation

Overview

    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.

    https://smartystreets.com

    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)

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    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 usage 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 they 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 ShouldBeError

                  func ShouldBeError(actual interface{}, expected ...interface{}) string

                    ShouldBeError asserts that the first argument implements the error interface. It also compares the first argument against the second argument if provided (which must be an error message string or another error value).

                    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 using the following semantics: 1. If the expected and actual values implement an Equal method in the form `func (this T) Equal(that T) bool` then call the method. If true, they are equal. 2. The expected and actual values are judged equal or not by oglematchers.Equals.

                                                func ShouldEqualJSON

                                                func ShouldEqualJSON(actual interface{}, expected ...interface{}) string

                                                  ShouldEqualJSON receives exactly two parameters and does an equality check by marshalling to JSON

                                                  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 ShouldNotBeChronological

                                                                                  func ShouldNotBeChronological(actual interface{}, expected ...interface{}) string

                                                                                    ShouldNotBeChronological receives a []time.Time slice and asserts that they are NOT in chronological order.

                                                                                    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 ShouldNotBeZeroValue

                                                                                          func ShouldNotBeZeroValue(actual interface{}, expected ...interface{}) string

                                                                                            ShouldBeZeroValue receives a single parameter and ensures that it is NOT the Go equivalent of the default value, or "zero" value.

                                                                                            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. See ShouldEqual for details on how equality is determined.

                                                                                                      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. If the expected value is an error and the recovered value is an error, errors.Is is used to compare them.

                                                                                                                  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. If the expected value is an error and the recovered value is an error, errors.Is is used to compare them.

                                                                                                                            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 ShouldWrap

                                                                                                                                  func ShouldWrap(actual interface{}, expected ...interface{}) string

                                                                                                                                    ShouldWrap asserts that the first argument (which must be an error value) 'wraps' the second/final argument (which must also be an error value). It relies on errors.Is to make the determination (https://golang.org/pkg/errors/#Is).

                                                                                                                                    func So

                                                                                                                                    func So(actual interface{}, assert SoFunc, 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)
                                                                                                                                      }
                                                                                                                                      

                                                                                                                                      For an alternative implementation of So (that provides more flexible return options) see the `So` function in the package at github.com/smartystreets/assertions/assert.

                                                                                                                                      Types

                                                                                                                                      type Assertion

                                                                                                                                      type Assertion struct {
                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                      }

                                                                                                                                      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 SoFunc, 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
                                                                                                                                              }

                                                                                                                                              type SoFunc

                                                                                                                                              type SoFunc func(actual interface{}, expected ...interface{}) string

                                                                                                                                                SoFunc is an alias for a function with a signature that the So() function can handle. Any future or custom assertions should conform to this method signature. The return value should be an empty string if the SoFunc passes and a well-formed failure message if not.

                                                                                                                                                Directories

                                                                                                                                                Path Synopsis
                                                                                                                                                package should is simply a rewording of the assertion functions in the assertions package.
                                                                                                                                                package should is simply a rewording of the assertion functions in the assertions package.
                                                                                                                                                internal
                                                                                                                                                go-diff/diffmatchpatch
                                                                                                                                                Package diffmatchpatch offers robust algorithms to perform the operations required for synchronizing plain text.
                                                                                                                                                Package diffmatchpatch offers robust algorithms to perform the operations required for synchronizing plain text.
                                                                                                                                                oglematchers
                                                                                                                                                Package oglematchers provides a set of matchers useful in a testing or mocking framework.
                                                                                                                                                Package oglematchers provides a set of matchers useful in a testing or mocking framework.
                                                                                                                                                unit
                                                                                                                                                package unit implements a light-weight x-Unit style testing framework.
                                                                                                                                                package unit implements a light-weight x-Unit style testing framework.