assertions

package module
v1.13.1 Latest Latest
Warning

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

 Go to latest Published: Apr 3, 2023 License: MIT Imports: 11 Imported by: 0

README

SMARTY DISCLAIMER: Subject to the terms of the associated license agreement, this software is freely available for your use. This software is FREE, AS IN PUPPIES, and is a gift. Enjoy your new responsibility. This means that while we may consider enhancement requests, we may or may not choose to entertain requests at our sole and absolute discretion.

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 any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) string

ShouldBeBlank receives exactly 1 string parameter and ensures that it is equal to "".

func ShouldBeChronological 

func ShouldBeChronological(actual any, expected ...any) 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 any, expected ...any) string

ShouldBeEmpty receives a single parameter (actual) and determines whether 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 any, expected ...any) 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 any, expected ...any) string

ShouldBeFalse receives a single parameter and ensures that it is false.

func ShouldBeGreaterThan 

func ShouldBeGreaterThan(actual any, expected ...any) string

ShouldBeGreaterThan receives exactly two parameters and ensures that the first is greater than the second.

func ShouldBeGreaterThanOrEqualTo 

func ShouldBeGreaterThanOrEqualTo(actual any, expected ...any) string

ShouldBeGreaterThanOrEqualTo receives exactly two parameters and ensures that the first is greater than or equal to the second.

func ShouldBeIn 

func ShouldBeIn(actual any, expected ...any) 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 consists of all the remaining parameters. This assertion ensures that the proposed member is in the collection (using ShouldEqual).

func ShouldBeLessThan 

func ShouldBeLessThan(actual any, expected ...any) string

ShouldBeLessThan receives exactly two parameters and ensures that the first is less than the second.

func ShouldBeLessThanOrEqualTo 

func ShouldBeLessThanOrEqualTo(actual any, expected ...any) string

ShouldBeLessThanOrEqualTo receives exactly two parameters and ensures that the first is less than or equal to the second.

func ShouldBeNil 

func ShouldBeNil(actual any, expected ...any) string

ShouldBeNil receives a single parameter and ensures that it is nil.

func ShouldBeTrue 

func ShouldBeTrue(actual any, expected ...any) string

ShouldBeTrue receives a single parameter and ensures that it is true.

func ShouldBeZeroValue 

func ShouldBeZeroValue(actual any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) string

ShouldContainSubstring receives exactly 2 string parameters and ensures that the first contains the second as a substring.

func ShouldEndWith 

func ShouldEndWith(actual any, expected ...any) string

ShouldEndWith receives exactly 2 string parameters and ensures that the first ends with the second.

func ShouldEqual 

func ShouldEqual(actual any, expected ...any) 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 any, expected ...any) string

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

func ShouldEqualTrimSpace 

func ShouldEqualTrimSpace(actual any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) string

ShouldHappenAfter receives exactly 2 time.Time arguments and asserts that the first happens after the second.

func ShouldHappenBefore 

func ShouldHappenBefore(actual any, expected ...any) string

ShouldHappenBefore receives exactly 2 time.Time arguments and asserts that the first happens before the second.

func ShouldHappenBetween 

func ShouldHappenBetween(actual any, expected ...any) 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 any, expected ...any) string

ShouldHappenOnOrAfter receives exactly 2 time.Time arguments and asserts that the first happens on or after the second.

func ShouldHappenOnOrBefore 

func ShouldHappenOnOrBefore(actual any, expected ...any) string

ShouldHappenOnOrBefore receives exactly 2 time.Time arguments and asserts that the first happens on or before the second.

func ShouldHappenOnOrBetween 

func ShouldHappenOnOrBetween(actual any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) string

ShouldHaveSameTypeAs receives exactly two parameters and compares their underlying types for equality.

func ShouldImplement 

func ShouldImplement(actual any, expectedList ...any) string

ShouldImplement receives exactly two parameters and ensures that the first implements the interface type of the second.

func ShouldNotAlmostEqual 

func ShouldNotAlmostEqual(actual any, expected ...any) string

ShouldNotAlmostEqual is the inverse of ShouldAlmostEqual

func ShouldNotBeBetween 

func ShouldNotBeBetween(actual any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) string

ShouldNotBeBlank receives exactly 1 string parameter and ensures that it is not equal to "".

func ShouldNotBeChronological 

func ShouldNotBeChronological(actual any, expected ...any) string

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

func ShouldNotBeEmpty 

func ShouldNotBeEmpty(actual any, expected ...any) string

ShouldNotBeEmpty receives a single parameter (actual) and determines whether 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 any, expected ...any) 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 consists of all the remaining parameters. This assertion ensures that the proposed member is NOT in the collection (using ShouldEqual).

func ShouldNotBeNil 

func ShouldNotBeNil(actual any, expected ...any) string

ShouldNotBeNil receives a single parameter and ensures that it is not nil.

func ShouldNotBeZeroValue 

func ShouldNotBeZeroValue(actual any, expected ...any) string

ShouldNotBeZeroValue 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 any, expected ...any) string

ShouldNotContain receives exactly two parameters. The first is a slice and the second is a proposed member. Membership is determined using ShouldEqual.

func ShouldNotContainKey 

func ShouldNotContainKey(actual any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) string

ShouldNotEndWith receives exactly 2 string parameters and ensures that the first does not end with the second.

func ShouldNotEqual 

func ShouldNotEqual(actual any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) 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 any, expected ...any) string

ShouldNotHaveSameTypeAs receives exactly two parameters and compares their underlying types for inequality.

func ShouldNotImplement 

func ShouldNotImplement(actual any, expectedList ...any) 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 any, expected ...any) (message string)

ShouldNotPanic receives a void, niladic function and expects to execute the function without any panic.

func ShouldNotPanicWith 

func ShouldNotPanicWith(actual any, expected ...any) (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 will be used to compare them.

func ShouldNotPointTo 

func ShouldNotPointTo(actual any, expected ...any) string

ShouldNotPointTo receives exactly two parameters and checks to see that they point to different addresess.

func ShouldNotResemble 

func ShouldNotResemble(actual any, expected ...any) string

ShouldNotResemble receives exactly two parameters and does an inverse deep equal check (see reflect.DeepEqual)

func ShouldNotStartWith 

func ShouldNotStartWith(actual any, expected ...any) string

ShouldNotStartWith receives exactly 2 string parameters and ensures that the first does not start with the second.

func ShouldPanic 

func ShouldPanic(actual any, expected ...any) (message string)

ShouldPanic receives a void, niladic function and expects to recover a panic.

func ShouldPanicWith 

func ShouldPanicWith(actual any, expected ...any) (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 will be used to compare them.

func ShouldPointTo 

func ShouldPointTo(actual any, expected ...any) string

ShouldPointTo receives exactly two parameters and checks to see that they point to the same address.

func ShouldResemble 

func ShouldResemble(actual any, expected ...any) string

ShouldResemble receives exactly two parameters and does a deep equal check (see reflect.DeepEqual)

func ShouldStartWith 

func ShouldStartWith(actual any, expected ...any) string

ShouldStartWith receives exactly 2 string parameters and ensures that the first starts with the second.

func ShouldWrap added in v1.1.0 

func ShouldWrap(actual any, expected ...any) 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 any, assert SoFunc, expected ...any) (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 any, assert SoFunc, expected ...any) 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"`
}

FailureView 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 added in v1.2.0 

type SoFunc func(actual any, expected ...any) 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.

Source Files

View all Source files

Directories

Path Synopsis
example
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.
go-render/render
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.
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.

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.