Documentation

Overview

    Package assertions is designed to be a collection of `.` importable, goconvey compatible testing assertions, in the style of "github.com/smartystreets/assertions".

    Due to a bug/feature in goconvey[1], files in this package end in `_tests.go`.

    This is a signal to goconvey's internal stack traversal logic (used to print helpful assertion messages) that the assertions in this package should be considered 'testing code' and not 'tested code', and so should be skipped over when searching for the first stack frame containing the code under test.

    [1]: https://github.com/smartystreets/goconvey/pull/316

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func ShouldBeLikeStatus

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

      ShouldBeLikeStatus asserts that *status.Status `actual` has code `expected[0]`, that the actual message has a substring `expected[1]` and that the status details in expected[2:] as present in the actual status.

      len(expected) must be at least 1.

      Example:

      // err must have a NotFound status
      So(s, ShouldBeLikeStatus, codes.NotFound)
      
      // and its message must contain "item not found"
      So(s, ShouldBeLikeStatus, codes.NotFound, "item not found")
      
      // and it must have a DebugInfo detail.
      So(s, ShouldBeLikeStatus, codes.NotFound, "item not found", &errdetails.DebugInfo{Details: "x"})
      

      func ShouldBeRPCAborted

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

        ShouldBeRPCAborted asserts that "actual" is an error that has a gRPC code value of codes.Aborted.

        One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

        func ShouldBeRPCAlreadyExists

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

          ShouldBeRPCAlreadyExists asserts that "actual" is an error that has a gRPC code value of codes.AlreadyExists.

          One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

          func ShouldBeRPCFailedPrecondition

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

            ShouldBeRPCFailedPrecondition asserts that "actual" is an error that has a gRPC code value of codes.FailedPrecondition.

            One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

            func ShouldBeRPCInternal

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

              ShouldBeRPCInternal asserts that "actual" is an error that has a gRPC code value of codes.Internal.

              One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

              func ShouldBeRPCInvalidArgument

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

                ShouldBeRPCInvalidArgument asserts that "actual" is an error that has a gRPC code value of codes.InvalidArgument.

                One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

                func ShouldBeRPCNotFound

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

                  ShouldBeRPCNotFound asserts that "actual" is an error that has a gRPC code value of codes.NotFound.

                  One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

                  func ShouldBeRPCOK

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

                    ShouldBeRPCOK asserts that "actual" is an error that has a gRPC code value of codes.OK.

                    Note that "nil" has an codes.OK value.

                    One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

                    func ShouldBeRPCPermissionDenied

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

                      ShouldBeRPCPermissionDenied asserts that "actual" is an error that has a gRPC code value of codes.PermissionDenied.

                      One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

                      func ShouldBeRPCUnauthenticated

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

                        ShouldBeRPCUnauthenticated asserts that "actual" is an error that has a gRPC code value of codes.Unauthenticated.

                        One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

                        func ShouldBeRPCUnknown

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

                          ShouldBeRPCUnknown asserts that "actual" is an error that has a gRPC code value of codes.Unknown.

                          One additional "expected" string may be optionally included. If included, the gRPC error's message is asserted to contain the expected string.

                          func ShouldContainErr

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

                            ShouldContainErr checks if an `errors.MultiError` on the left side contains as one of its errors an `error` or `string` on the right side. If nothing is provided on the right, checks that the left side contains at least one non-nil error. If nil is provided on the right, checks that the left side contains at least one nil, even if it contains other errors.

                            Equivalent to calling ShouldErrLike on each `error` in an `errors.MultiError` and succeeding as long as one of the ShouldErrLike calls succeeds.

                            To avoid confusion, explicitly rejects the special case where the right side is an `errors.MultiError`.

                            func ShouldErrLike

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

                              ShouldErrLike compares an `error` or `string` on the left side, to `error`s or `string`s on the right side.

                              If multiple errors/strings are provided on the righthand side, they must all be contained in the stringified error on the lefthand side.

                              If the righthand side is the singluar `nil`, this expects the error to be nil.

                              Example:

                              // Usage                          Equivalent To
                              So(err, ShouldErrLike, "custom")    // `err.Error()` ShouldContainSubstring "custom"
                              So(err, ShouldErrLike, io.EOF)      // `err.Error()` ShouldContainSubstring io.EOF.Error()
                              So(err, ShouldErrLike, "EOF")       // `err.Error()` ShouldContainSubstring "EOF"
                              So(err, ShouldErrLike,
                                 "thing", "other", "etc.")        // `err.Error()` contains all of these substrings.
                              So(nilErr, ShouldErrLike, nil)      // nilErr ShouldBeNil
                              So(nonNilErr, ShouldErrLike, "")    // nonNilErr ShouldNotBeNil
                              

                              func ShouldHaveAppStatus

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

                                ShouldHaveAppStatus asserts that error `actual` has an application-specific status and it matches the expectations. See ShouldBeLikeStatus for the format of `expected`. See appstatus package for application-specific statuses.

                                func ShouldHaveGRPCStatus

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

                                  ShouldHaveGRPCStatus asserts that error `actual` has a GRPC status and it matches the expectations. See ShouldBeStatusLike for the format of `expected`. The status is extracted using status.FromError.

                                  func ShouldHaveRPCCode

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

                                    ShouldHaveRPCCode is a goconvey assertion, asserting that the supplied "actual" value has a gRPC code value and, optionally, errors like a supplied message string.

                                    If no "expected" arguments are supplied, ShouldHaveRPCCode will assert that the result is codes.OK.

                                    The first "expected" argument, if supplied, is the gRPC codes.Code to assert.

                                    A second "expected" string may be optionally included. If included, the gRPC error message is asserted to contain the expected string using convey.ShouldContainSubstring.

                                    func ShouldPanicLike

                                    func ShouldPanicLike(function interface{}, expected ...interface{}) (ret string)

                                      ShouldPanicLike is the same as ShouldErrLike, but with the exception that it takes a panic'ing func() as its first argument, instead of the error itself.

                                      func ShouldResembleProto

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

                                        ShouldResembleProto asserts that given two values that contain proto messages are equal by comparing their types and ensuring they serialize to the same text representation.

                                        Values can either each be a proto.Message or a slice of values that each implement proto.Message interface.

                                        func ShouldResembleProtoJSON

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

                                          ShouldResembleProtoJSON is like ShouldResembleProto, but expected is protobuf text. actual must be a message. A slice of messages is not supported.

                                          func ShouldResembleProtoText

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

                                            ShouldResembleProtoText is like ShouldResembleProto, but expected is protobuf text. actual must be a message. A slice of messages is not supported.

                                            func ShouldUnwrapTo

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

                                              ShouldUnwrapTo asserts that an error, when unwrapped, equals another error.

                                              The actual field will be unwrapped using errors.Unwrap and then compared to the error in expected.

                                              Types

                                              This section is empty.