bdd

package
v0.0.0-...-603556f Latest Latest
Warning

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

 Go to latest Published: Aug 4, 2022 License: MIT Imports: 13 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func OptReport 

func OptReport(m map[int]interface{}) report.Reporter

Types

type Assertions 

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

func (*Assertions) Condition 

func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{})

Condition uses a Comparison to assert a complex condition.

func (*Assertions) Contains 

func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{})

Contains asserts that the specified string, list(array, slice...) or map contains the specified substring or element. 

a.Contains("Hello World", "World")
a.Contains(["Hello", "World"], "World")
a.Contains({"Hello": "World"}, "Hello")

func (*Assertions) DirExists 

func (a *Assertions) DirExists(path string, msgAndArgs ...interface{})

DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists.

func (*Assertions) ElementsMatch 

func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{})

ElementsMatch asserts that the specified listA(array, slice...) is equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should match.

a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2])

func (*Assertions) Empty 

func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{})

Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either a slice or a channel with len == 0. 

a.Empty(obj)

func (*Assertions) Equal 

func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{})

Equal asserts that two objects are equal. 

a.Equal(123, 123)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses). Function equality cannot be determined and will always fail.

func (*Assertions) EqualError 

func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{})

EqualError asserts that a function returned an error (i.e. not `nil`) and that it is equal to the provided error. 

actualObj, err := SomeFunction()
a.EqualError(err,  expectedErrorString)

func (*Assertions) EqualValues 

func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{})

EqualValues asserts that two objects are equal or convertable to the same types and equal. 

a.EqualValues(uint32(123), int32(123))

func (*Assertions) Error 

func (a *Assertions) Error(err error, msgAndArgs ...interface{})

Error asserts that a function returned an error (i.e. not `nil`). 

  actualObj, err := SomeFunction()
  if a.Error(err) {
	   assert.Equal(t, expectedError, err)
  }

func (*Assertions) ErrorAs 

func (a *Assertions) ErrorAs(err error, target interface{}, msgAndArgs ...interface{})

ErrorAs asserts that at least one of the errors in err's chain matches target, and if so, sets target to that error value. This is a wrapper for errors.As.

func (*Assertions) ErrorContains 

func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs ...interface{})

ErrorContains asserts that a function returned an error (i.e. not `nil`) and that the error contains the specified substring. 

actualObj, err := SomeFunction()
a.ErrorContains(err,  expectedErrorSubString)

func (*Assertions) ErrorIs 

func (a *Assertions) ErrorIs(err error, target error, msgAndArgs ...interface{})

ErrorIs asserts that at least one of the errors in err's chain matches target. This is a wrapper for errors.Is.

func (*Assertions) Eventually 

func (a *Assertions) Eventually(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{})

Eventually asserts that given condition will be met in waitFor time, periodically checking target function each tick. 

a.Eventually(func() bool { return true; }, time.Second, 10*time.Millisecond)

func (*Assertions) Exactly 

func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{})

Exactly asserts that two objects are equal in value and type. 

a.Exactly(int32(123), int64(123))

func (*Assertions) Fail 

func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{})

Fail reports a failure through

func (*Assertions) FailNow 

func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{})

FailNow fails test

func (*Assertions) False 

func (a *Assertions) False(value bool, msgAndArgs ...interface{})

False asserts that the specified value is false. 

a.False(myBool)

func (*Assertions) FileExists 

func (a *Assertions) FileExists(path string, msgAndArgs ...interface{})

FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file.

func (*Assertions) Greater 

func (a *Assertions) Greater(e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

Greater asserts that the first element is greater than the second 

a.Greater(2, 1)
a.Greater(float64(2), float64(1))
a.Greater("b", "a")

func (*Assertions) GreaterOrEqual 

func (a *Assertions) GreaterOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

GreaterOrEqual asserts that the first element is greater than or equal to the second 

a.GreaterOrEqual(2, 1)
a.GreaterOrEqual(2, 2)
a.GreaterOrEqual("b", "a")
a.GreaterOrEqual("b", "b")

func (*Assertions) HTTPBodyContains 

func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{})

HTTPBodyContains asserts that a specified handler returns a body that contains a string. 

a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPBodyNotContains 

func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{})

HTTPBodyNotContains asserts that a specified handler returns a body that does not contain a string. 

a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPError 

func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{})

HTTPError asserts that a specified handler returns an error status code. 

a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPRedirect 

func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{})

HTTPRedirect asserts that a specified handler returns a redirect status code. 

a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPStatusCode 

func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{})

HTTPStatusCode asserts that a specified handler returns a specified status code. 

a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) HTTPSuccess 

func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{})

HTTPSuccess asserts that a specified handler returns a success status code. 

a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)

Returns whether the assertion was successful (true) or not (false).

func (*Assertions) Implements 

func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{})

Implements asserts that an object is implemented by the specified interface. 

a.Implements((*MyInterface)(nil), new(MyObject))

func (*Assertions) InDelta 

func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

InDelta asserts that the two numerals are within delta of each other. 

a.InDelta(math.Pi, 22/7.0, 0.01)

func (*Assertions) InDeltaMapValues 

func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.

func (*Assertions) InDeltaSlice 

func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{})

InDeltaSlice is the same as InDelta, except it compares two slices.

func (*Assertions) InEpsilon 

func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{})

InEpsilon asserts that expected and actual have a relative error less than epsilon

func (*Assertions) InEpsilonSlice 

func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{})

InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.

func (*Assertions) IsDecreasing 

func (a *Assertions) IsDecreasing(object interface{}, msgAndArgs ...interface{})

IsDecreasing asserts that the collection is decreasing 

a.IsDecreasing([]int{2, 1, 0})
a.IsDecreasing([]float{2, 1})
a.IsDecreasing([]string{"b", "a"})

func (*Assertions) IsIncreasing 

func (a *Assertions) IsIncreasing(object interface{}, msgAndArgs ...interface{})

IsIncreasing asserts that the collection is increasing 

a.IsIncreasing([]int{1, 2, 3})
a.IsIncreasing([]float{1, 2})
a.IsIncreasing([]string{"a", "b"})

func (*Assertions) IsNonDecreasing 

func (a *Assertions) IsNonDecreasing(object interface{}, msgAndArgs ...interface{})

IsNonDecreasing asserts that the collection is not decreasing 

a.IsNonDecreasing([]int{1, 1, 2})
a.IsNonDecreasing([]float{1, 2})
a.IsNonDecreasing([]string{"a", "b"})

func (*Assertions) IsNonIncreasing 

func (a *Assertions) IsNonIncreasing(object interface{}, msgAndArgs ...interface{})

IsNonIncreasing asserts that the collection is not increasing 

a.IsNonIncreasing([]int{2, 1, 1})
a.IsNonIncreasing([]float{2, 1})
a.IsNonIncreasing([]string{"b", "a"})

func (*Assertions) IsType 

func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{})

IsType asserts that the specified objects are of the same type.

func (*Assertions) JSONEq 

func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{})

JSONEq asserts that two JSON strings are equivalent. 

a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

func (*Assertions) Len 

func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{})

Len asserts that the specified object has specific length. Len also fails if the object has a type that len() not accept. 

a.Len(mySlice, 3)

func (*Assertions) Less 

func (a *Assertions) Less(e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

Less asserts that the first element is less than the second 

a.Less(1, 2)
a.Less(float64(1), float64(2))
a.Less("a", "b")

func (*Assertions) LessOrEqual 

func (a *Assertions) LessOrEqual(e1 interface{}, e2 interface{}, msgAndArgs ...interface{})

LessOrEqual asserts that the first element is less than or equal to the second 

a.LessOrEqual(1, 2)
a.LessOrEqual(2, 2)
a.LessOrEqual("a", "b")
a.LessOrEqual("b", "b")

func (*Assertions) Negative 

func (a *Assertions) Negative(e interface{}, msgAndArgs ...interface{})

Negative asserts that the specified element is negative 

a.Negative(-1)
a.Negative(-1.23)

func (*Assertions) Never 

func (a *Assertions) Never(condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{})

Never asserts that the given condition doesn't satisfy in waitFor time, periodically checking the target function each tick. 

a.Never(func() bool { return false; }, time.Second, 10*time.Millisecond)

func (*Assertions) Nil 

func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{})

Nil asserts that the specified object is nil. 

a.Nil(err)

func (*Assertions) NoDirExists 

func (a *Assertions) NoDirExists(path string, msgAndArgs ...interface{})

NoDirExists checks whether a directory does not exist in the given path. It fails if the path points to an existing _directory_ only.

func (*Assertions) NoError 

func (a *Assertions) NoError(err error, msgAndArgs ...interface{})

NoError asserts that a function returned no error (i.e. `nil`). 

  actualObj, err := SomeFunction()
  if a.NoError(err) {
	   assert.Equal(t, expectedObj, actualObj)
  }

func (*Assertions) NoFileExists 

func (a *Assertions) NoFileExists(path string, msgAndArgs ...interface{})

NoFileExists checks whether a file does not exist in a given path. It fails if the path points to an existing _file_ only.

func (*Assertions) NotContains 

func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{})

NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the specified substring or element. 

a.NotContains("Hello World", "Earth")
a.NotContains(["Hello", "World"], "Earth")
a.NotContains({"Hello": "World"}, "Earth")

func (*Assertions) NotEmpty 

func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{})

NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either a slice or a channel with len == 0. 

if a.NotEmpty(obj) {
  assert.Equal(t, "two", obj[1])
}

func (*Assertions) NotEqual 

func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{})

NotEqual asserts that the specified values are NOT equal. 

a.NotEqual(obj1, obj2)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

func (*Assertions) NotEqualValues 

func (a *Assertions) NotEqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{})

NotEqualValues asserts that two objects are not equal even when converted to the same type 

a.NotEqualValues(obj1, obj2)

func (*Assertions) NotErrorIs 

func (a *Assertions) NotErrorIs(err error, target error, msgAndArgs ...interface{})

NotErrorIs asserts that at none of the errors in err's chain matches target. This is a wrapper for errors.Is.

func (*Assertions) NotNil 

func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{})

NotNil asserts that the specified object is not nil. 

a.NotNil(err)

func (*Assertions) NotPanics 

func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{})

NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. 

a.NotPanics(func(){ RemainCalm() })

func (*Assertions) NotRegexp 

func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{})

NotRegexp asserts that a specified regexp does not match a string. 

a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
a.NotRegexp("^start", "it's not starting")

func (*Assertions) NotSame 

func (a *Assertions) NotSame(expected interface{}, actual interface{}, msgAndArgs ...interface{})

NotSame asserts that two pointers do not reference the same object. 

a.NotSame(ptr1, ptr2)

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

func (*Assertions) NotSubset 

func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{})

NotSubset asserts that the specified list(array, slice...) contains not all elements given in the specified subset(array, slice...). 

a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")

func (*Assertions) NotZero 

func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{})

NotZero asserts that i is not the zero value for its type.

func (*Assertions) Panics 

func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{})

Panics asserts that the code inside the specified PanicTestFunc panics. 

a.Panics(func(){ GoCrazy() })

func (*Assertions) PanicsWithError 

func (a *Assertions) PanicsWithError(errString string, f assert.PanicTestFunc, msgAndArgs ...interface{})

PanicsWithError asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value is an error that satisfies the EqualError comparison. 

a.PanicsWithError("crazy error", func(){ GoCrazy() })

func (*Assertions) PanicsWithValue 

func (a *Assertions) PanicsWithValue(expected interface{}, f assert.PanicTestFunc, msgAndArgs ...interface{})

PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value equals the expected panic value. 

a.PanicsWithValue("crazy error", func(){ GoCrazy() })

func (*Assertions) Positive 

func (a *Assertions) Positive(e interface{}, msgAndArgs ...interface{})

Positive asserts that the specified element is positive 

a.Positive(1)
a.Positive(1.23)

func (*Assertions) Regexp 

func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{})

Regexp asserts that a specified regexp matches a string. 

a.Regexp(regexp.MustCompile("start"), "it's starting")
a.Regexp("start...$", "it's not starting")

func (*Assertions) Report 

func (a *Assertions) Report() []string

func (*Assertions) Reset 

func (a *Assertions) Reset()

func (*Assertions) Same 

func (a *Assertions) Same(expected interface{}, actual interface{}, msgAndArgs ...interface{})

Same asserts that two pointers reference the same object. 

a.Same(ptr1, ptr2)

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

func (*Assertions) Subset 

func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{})

Subset asserts that the specified list(array, slice...) contains all elements given in the specified subset(array, slice...). 

a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")

func (*Assertions) True 

func (a *Assertions) True(value bool, msgAndArgs ...interface{})

True asserts that the specified value is true. 

a.True(myBool)

func (*Assertions) WithinDuration 

func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{})

WithinDuration asserts that the two times are within duration delta of each other. 

a.WithinDuration(time.Now(), time.Now(), 10*time.Second)

func (*Assertions) WithinRange 

func (a *Assertions) WithinRange(actual time.Time, start time.Time, end time.Time, msgAndArgs ...interface{})

WithinRange asserts that a time is within a time range (inclusive). 

a.WithinRange(time.Now(), time.Now().Add(-time.Second), time.Now().Add(time.Second))

func (*Assertions) YAMLEq 

func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interface{})

YAMLEq asserts that two YAML strings are equivalent.

func (*Assertions) Zero 

func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{})

Zero asserts that i is the zero value for its type.

type ContextErr 

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

func (*ContextErr) Err 

func (e *ContextErr) Err() error

func (*ContextErr) Error 

func (e *ContextErr) Error() string

type Decorator 

type Decorator interface {
	// contains filtered or unexported methods
}

func OptDecorator 

func OptDecorator(m map[int]interface{}) Decorator

type FeatureReport 

type FeatureReport struct {
	Name            string
	ScenarioReports []*ScenarioReport
}

type Featurer 

type Featurer interface {
	Test()
	Before(fn func()) Featurer
	Scenario(name string) Scenery
}

func Feature 

func Feature(name string, t *testing.T, opts ...Option) Featurer

Feature creates a test feature that contains a list of scenarios

type Givener 

type Givener interface {
	fmt.Stringer
	And(name string, fn func()) Givener
	But(name string, fn func()) Givener
	When(name string, fn func()) *whenStep
}

func Given 

func Given(name string, t *testing.T, fn func(), opts ...Option) Givener

Given creates a Given step

type HTMLDecorator 

type HTMLDecorator struct{}

func NewHTMLDecorator 

func NewHTMLDecorator() *HTMLDecorator

type MarkdownDecorator 

type MarkdownDecorator struct{}

func NewMarkdownDecorator 

func NewMarkdownDecorator() *MarkdownDecorator

type Option 

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

func WithDecorator 

func WithDecorator(d Decorator) Option

func WithEmojiDecorator 

func WithEmojiDecorator() Option

func WithReport 

func WithReport(r report.Reporter) Option

type PlainTextDecorator 

type PlainTextDecorator struct{}

func NewPlainTextDecorator 

func NewPlainTextDecorator() *PlainTextDecorator

type ScenarioReport 

type ScenarioReport struct {
	TestName   string
	TestStatus string
	PanicMsg   string
	Trace      string
	Feature    string
	Scenario   string
	Steps      []string
	Errors     []string
}

type ScenarioSteper 

type ScenarioSteper interface {
	Given(name string, fn func()) Givener
}

type Scenery 

type Scenery interface {
	Given(name string, fn func()) Givener
	Before(fn func()) ScenarioSteper
}

func Scenario 

func Scenario(name string, t *testing.T, opts ...Option) Scenery

Scenario creates a test Scenario to describe a test with Given, When and Then

type Suiter 

type Suiter interface {
	Setup(fn func()) *suiteStep
	TierDown(fn func()) *suiteStep
	Feature(name string) *featureStep
	Run()

	Log(args ...any)
	Error(args ...any)
	Errorf(format string, args ...any)
	Fail()
	FailNow()
	Setenv(key, value string)
}

func Suite 

func Suite(name string, t *testing.T, opts ...Option) Suiter

Suite creates a test suite that supports a list of Features

Source Files

View all Source files

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.