README

Godoc Coverage Status Build Status Go Report Card Mentioned in Awesome Go

apitest

A simple and extensible behavioural testing library. Supports mocking external http calls and renders sequence diagrams on completion.

In behavioural tests the internal structure of the app is not known by the tests. Data is input to the system and the outputs are expected to meet certain conditions.

Join the conversation at #apitest on https://gophers.slack.com.

Logo by @egonelbre

Documentation

Please visit https://apitest.dev for the latest documentation.

Installation

go get -u github.com/steinfletcher/apitest

Examples

Framework and library integration examples
Example Comment
gin popular martini-like web framework
graphql using gqlgen.com to generate a graphql server
gorilla the gorilla web toolkit
iris iris web framework
echo High performance, extensible, minimalist Go web framework
fiber Express inspired web framework written in Go
httprouter High performance HTTP request router that scales well
mocks example mocking out external http calls
sequence diagrams generate sequence diagrams from tests. See the demo
Ginkgo Ginkgo BDD test framework
Companion libraries
Library Comment
JSONPath JSONPath assertion addons
CSS Selectors CSS selector assertion addons
PlantUML Export sequence diagrams as plantUML
DynamoDB Add DynamoDB interactions to sequence diagrams
Credits

This library was influenced by the following software packages:

  • YatSpec for creating sequence diagrams from tests
  • MockMVC and superagent for the concept and behavioural testing approach
  • Gock for the approach to mocking HTTP services in Go
  • Baloo for API design
Code snippets
JSON body matcher
func TestApi(t *testing.T) {
	apitest.New().
		Handler(handler).
		Get("/user/1234").
		Expect(t).
		Body(`{"id": "1234", "name": "Tate"}`).
		Status(http.StatusCreated).
		End()
}
JSONPath

For asserting on parts of the response body JSONPath may be used. A separate module must be installed which provides these assertions - go get -u github.com/steinfletcher/apitest-jsonpath. This is packaged separately to keep this library dependency free.

Given the response is {"a": 12345, "b": [{"key": "c", "value": "result"}]}

func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Get("/hello").
		Expect(t).
		Assert(jsonpath.Contains(`$.b[? @.key=="c"].value`, "result")).
		End()
}

and jsonpath.Equals checks for value equality

func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Get("/hello").
		Expect(t).
		Assert(jsonpath.Equal(`$.a`, float64(12345))).
		End()
}
Custom assert functions
func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Get("/hello").
		Expect(t).
		Assert(func(res *http.Response, req *http.Request) error {
			assert.Equal(t, http.StatusOK, res.StatusCode)
			return nil
		}).
		End()
}
Assert cookies
func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Patch("/hello").
		Expect(t).
		Status(http.StatusOK).
		Cookies(apitest.Cookie"ABC").Value("12345")).
		CookiePresent("Session-Token").
		CookieNotPresent("XXX").
		Cookies(
			apitest.Cookie("ABC").Value("12345"),
			apitest.Cookie("DEF").Value("67890"),
		).
		End()
}
Assert headers
func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Get("/hello").
		Expect(t).
		Status(http.StatusOK).
		Headers(map[string]string{"ABC": "12345"}).
		End()
}
Mocking external http calls
var getUser = apitest.NewMock().
	Get("/user/12345").
	RespondWith().
	Body(`{"name": "jon", "id": "1234"}`).
	Status(http.StatusOK).
	End()

var getPreferences = apitest.NewMock().
	Get("/preferences/12345").
	RespondWith().
	Body(`{"is_contactable": true}`).
	Status(http.StatusOK).
	End()

func TestApi(t *testing.T) {
	apitest.New().
		Mocks(getUser, getPreferences).
		Handler(handler).
		Get("/hello").
		Expect(t).
		Status(http.StatusOK).
		Body(`{"name": "jon", "id": "1234"}`).
		End()
}
Generating sequence diagrams from tests

func TestApi(t *testing.T) {
	apitest.New().
		Report(apitest.SequenceDiagram()).
		Mocks(getUser, getPreferences).
		Handler(handler).
		Get("/hello").
		Expect(t).
		Status(http.StatusOK).
		Body(`{"name": "jon", "id": "1234"}`).
		End()
}

It is possible to override the default storage location by passing the formatter instance Report(apitest.NewSequenceDiagramFormatter(".sequence-diagrams")). You can bring your own formatter too if you want to produce custom output. By default a sequence diagram is rendered on a html page. See the demo

Debugging http requests and responses generated by api test and any mocks
func TestApi(t *testing.T) {
	apitest.New().
		Debug().
		Handler(handler).
		Get("/hello").
		Expect(t).
		Status(http.StatusOK).
		End()
}
Provide basic auth in the request
func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Get("/hello").
		BasicAuth("username", "password").
		Expect(t).
		Status(http.StatusOK).
		End()
}
Provide cookies in the request
func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Get("/hello").
		Cookies(apitest.Cookie("ABC").Value("12345")).
		Expect(t).
		Status(http.StatusOK).
		End()
}
Provide headers in the request
func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Delete("/hello").
		Headers(map[string]string{"My-Header": "12345"}).
		Expect(t).
		Status(http.StatusOK).
		End()
}
Provide query parameters in the request

Query, QueryParams and QueryCollection can all be used in combination

func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Get("/hello").
		QueryParams(map[string]string{"a": "1", "b": "2"}).
		Query("c", "d").
		Expect(t).
		Status(http.StatusOK).
		End()
}

Providing {"a": {"b", "c", "d"} results in parameters encoded as a=b&a=c&a=d. QueryCollection can be used in combination with Query

func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Get("/hello").
		QueryCollection(map[string][]string{"a": {"b", "c", "d"}}).
		Expect(t).
		Status(http.StatusOK).
		End()
}
Provide a url encoded form body in the request
func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Post("/hello").
		FormData("a", "1").
		FormData("b", "2").
		FormData("b", "3").
		FormData("c", "4", "5", "6").
		Expect(t).
		Status(http.StatusOK).
		End()
}
Capture the request and response data
func TestApi(t *testing.T) {
	apitest.New().
		Observe(func(res *http.Response, req *http.Request, apiTest *apitest.APITest) {
			// do something with res and req
		}).
		Handler(handler).
		Get("/hello").
		Expect(t).
		Status(http.StatusOK).
		End()
}
Intercept the request

This is useful for mutating the request before it is sent to the system under test.

func TestApi(t *testing.T) {
	apitest.Handler(handler).
		Intercept(func(req *http.Request) {
			req.URL.RawQuery = "a[]=xxx&a[]=yyy"
		}).
		Get("/hello").
		Expect(t).
		Status(http.StatusOK).
		End()
}

Contributing

View the contributing guide.

Expand ▾ Collapse ▴

Documentation

Index

Constants

View Source
const ConsumerName = "cli"

    ConsumerName default consumer name

    View Source
    const SystemUnderTestDefaultName = "sut"

      SystemUnderTestDefaultName default name for system under test

      Variables

      This section is empty.

      Functions

      This section is empty.

      Types

      type APITest

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

        APITest is the top level struct holding the test spec

        func Handler

        func Handler(handler http.Handler) *APITest

          Handler is a convenience method for creating a new apitest with a handler

          func HandlerFunc

          func HandlerFunc(handlerFunc http.HandlerFunc) *APITest

            HandlerFunc is a convenience method for creating a new apitest with a handler func

            func New

            func New(name ...string) *APITest

              New creates a new api test. The name is optional and will appear in test reports

              func (*APITest) Debug

              func (a *APITest) Debug() *APITest

                Debug logs to the console the http wire representation of all http interactions that are intercepted by apitest. This includes the inbound request to the application under test, the response returned by the application and any interactions that are intercepted by the mock server.

                func (*APITest) Delete

                func (a *APITest) Delete(url string) *Request

                  Delete is a convenience method for setting the request as http.MethodDelete

                  func (*APITest) Deletef

                  func (a *APITest) Deletef(format string, args ...interface{}) *Request

                    Deletef is a convenience method that adds formatting support to Delete

                    func (*APITest) EnableMockResponseDelay

                    func (a *APITest) EnableMockResponseDelay() *APITest

                      EnableMockResponseDelay turns on mock response delays (defaults to OFF)

                      func (*APITest) EnableNetworking

                      func (a *APITest) EnableNetworking(cli ...*http.Client) *APITest

                        EnableNetworking will enable networking for provided clients

                        func (*APITest) Get

                        func (a *APITest) Get(url string) *Request

                          Get is a convenience method for setting the request as http.MethodGet

                          func (*APITest) Getf

                          func (a *APITest) Getf(format string, args ...interface{}) *Request

                            Getf is a convenience method that adds formatting support to Get

                            func (*APITest) Handler

                            func (a *APITest) Handler(handler http.Handler) *APITest

                              Handler defines the http handler that is invoked when the test is run

                              func (*APITest) HandlerFunc

                              func (a *APITest) HandlerFunc(handlerFunc http.HandlerFunc) *APITest

                                HandlerFunc defines the http handler that is invoked when the test is run

                                func (*APITest) HttpClient

                                func (a *APITest) HttpClient(cli *http.Client) *APITest

                                  HttpClient allows the developer to provide a custom http client when using mocks

                                  func (*APITest) Intercept

                                  func (a *APITest) Intercept(interceptor Intercept) *APITest

                                    Intercept is a builder method for setting the request interceptor

                                    func (*APITest) Meta

                                    func (a *APITest) Meta(meta map[string]interface{}) *APITest

                                      Meta provides a hook to add custom meta data to the test which can be picked up when defining a custom reporter

                                      func (*APITest) Method

                                      func (a *APITest) Method(method string) *Request

                                        Method is a builder method for setting the http method of the request

                                        func (*APITest) Mocks

                                        func (a *APITest) Mocks(mocks ...*Mock) *APITest

                                          Mocks is a builder method for setting the mocks

                                          func (*APITest) Observe

                                          func (a *APITest) Observe(observers ...Observe) *APITest

                                            Observe is a builder method for setting the observers

                                            func (*APITest) ObserveMocks

                                            func (a *APITest) ObserveMocks(observer Observe) *APITest

                                              ObserveMocks is a builder method for setting the mocks observers

                                              func (*APITest) Patch

                                              func (a *APITest) Patch(url string) *Request

                                                Patch is a convenience method for setting the request as http.MethodPatch

                                                func (*APITest) Patchf

                                                func (a *APITest) Patchf(format string, args ...interface{}) *Request

                                                  Patchf is a convenience method that adds formatting support to Patch

                                                  func (*APITest) Post

                                                  func (a *APITest) Post(url string) *Request

                                                    Post is a convenience method for setting the request as http.MethodPost

                                                    func (*APITest) Postf

                                                    func (a *APITest) Postf(format string, args ...interface{}) *Request

                                                      Postf is a convenience method that adds formatting support to Post

                                                      func (*APITest) Put

                                                      func (a *APITest) Put(url string) *Request

                                                        Put is a convenience method for setting the request as http.MethodPut

                                                        func (*APITest) Putf

                                                        func (a *APITest) Putf(format string, args ...interface{}) *Request

                                                          Putf is a convenience method that adds formatting support to Put

                                                          func (*APITest) Recorder

                                                          func (a *APITest) Recorder(recorder *Recorder) *APITest

                                                            Recorder provides a hook to add a recorder to the test

                                                            func (*APITest) RecorderHook

                                                            func (a *APITest) RecorderHook(hook RecorderHook) *APITest

                                                              RecorderHook allows the consumer to provider a function that will receive the recorder instance before the test runs. This can be used to inject custom events which can then be rendered in diagrams Deprecated: use Recorder() instead

                                                              func (*APITest) Report

                                                              func (a *APITest) Report(reporter ReportFormatter) *APITest

                                                                Report provides a hook to add custom formatting to the output of the test

                                                                func (*APITest) Request

                                                                func (a *APITest) Request() *Request

                                                                  Request returns the request spec

                                                                  func (*APITest) Response

                                                                  func (a *APITest) Response() *Response

                                                                    Response returns the expected response

                                                                    func (*APITest) Verifier

                                                                    func (a *APITest) Verifier(v Verifier) *APITest

                                                                      Verifier allows consumers to override the verification implementation. By default testify is used to perform assertions

                                                                      type Assert

                                                                      type Assert func(*http.Response, *http.Request) error

                                                                        Assert is a user defined custom assertion function

                                                                        var IsClientError Assert = func(response *http.Response, request *http.Request) error {
                                                                        	if response.StatusCode >= 400 && response.StatusCode < 500 {
                                                                        		return nil
                                                                        	}
                                                                        	return fmt.Errorf("not a client error. Status code=%d", response.StatusCode)
                                                                        }

                                                                          IsClientError is a convenience function to assert on a range of client error status codes

                                                                          var IsServerError Assert = func(response *http.Response, request *http.Request) error {
                                                                          	if response.StatusCode >= 500 {
                                                                          		return nil
                                                                          	}
                                                                          	return fmt.Errorf("not a server error. Status code=%d", response.StatusCode)
                                                                          }

                                                                            IsServerError is a convenience function to assert on a range of server error status codes

                                                                            var IsSuccess Assert = func(response *http.Response, request *http.Request) error {
                                                                            	if response.StatusCode >= 200 && response.StatusCode < 400 {
                                                                            		return nil
                                                                            	}
                                                                            	return fmt.Errorf("not success. Status code=%d", response.StatusCode)
                                                                            }

                                                                              IsSuccess is a convenience function to assert on a range of happy path status codes

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

                                                                                Cookie used to represent an http cookie

                                                                                func FromHTTPCookie

                                                                                func FromHTTPCookie(httpCookie *http.Cookie) *Cookie

                                                                                  FromHTTPCookie transforms an http cookie into a Cookie

                                                                                  func NewCookie

                                                                                  func NewCookie(name string) *Cookie

                                                                                    NewCookie creates a new Cookie with the provided name

                                                                                    func (*Cookie) Domain

                                                                                    func (cookie *Cookie) Domain(domain string) *Cookie

                                                                                      Domain sets the domain of the Cookie

                                                                                      func (*Cookie) Expires

                                                                                      func (cookie *Cookie) Expires(expires time.Time) *Cookie

                                                                                        Expires sets the expires time of the Cookie

                                                                                        func (*Cookie) HttpOnly

                                                                                        func (cookie *Cookie) HttpOnly(httpOnly bool) *Cookie

                                                                                          HttpOnly sets the httpOnly bool of the Cookie

                                                                                          func (*Cookie) MaxAge

                                                                                          func (cookie *Cookie) MaxAge(maxAge int) *Cookie

                                                                                            MaxAge sets the maxage of the Cookie

                                                                                            func (*Cookie) Path

                                                                                            func (cookie *Cookie) Path(path string) *Cookie

                                                                                              Path sets the path of the Cookie

                                                                                              func (*Cookie) Secure

                                                                                              func (cookie *Cookie) Secure(secure bool) *Cookie

                                                                                                Secure sets the secure bool of the Cookie

                                                                                                func (*Cookie) ToHttpCookie

                                                                                                func (cookie *Cookie) ToHttpCookie() *http.Cookie

                                                                                                  ToHttpCookie transforms the Cookie to an http cookie

                                                                                                  func (*Cookie) Value

                                                                                                  func (cookie *Cookie) Value(value string) *Cookie

                                                                                                    Value sets the value of the Cookie

                                                                                                    type Event

                                                                                                    type Event interface {
                                                                                                    	GetTime() time.Time
                                                                                                    }

                                                                                                      Event represents a reporting event

                                                                                                      type FinalResponse

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

                                                                                                        FinalResponse used to wrap the final response with a timestamp

                                                                                                        type GraphQLRequestBody

                                                                                                        type GraphQLRequestBody struct {
                                                                                                        	Query         string                 `json:"query"`
                                                                                                        	Variables     map[string]interface{} `json:"variables,omitempty"`
                                                                                                        	OperationName string                 `json:"operationName,omitempty"`
                                                                                                        }

                                                                                                          GraphQLRequestBody represents the POST request body as per the GraphQL spec

                                                                                                          type HttpRequest

                                                                                                          type HttpRequest struct {
                                                                                                          	Source    string
                                                                                                          	Target    string
                                                                                                          	Value     *http.Request
                                                                                                          	Timestamp time.Time
                                                                                                          }

                                                                                                            HttpRequest represents an http request

                                                                                                            func (HttpRequest) GetTime

                                                                                                            func (r HttpRequest) GetTime() time.Time

                                                                                                              GetTime gets the time of the HttpRequest interaction

                                                                                                              type HttpResponse

                                                                                                              type HttpResponse struct {
                                                                                                              	Source    string
                                                                                                              	Target    string
                                                                                                              	Value     *http.Response
                                                                                                              	Timestamp time.Time
                                                                                                              }

                                                                                                                HttpResponse represents an http response

                                                                                                                func (HttpResponse) GetTime

                                                                                                                func (r HttpResponse) GetTime() time.Time

                                                                                                                  GetTime gets the time of the HttpResponse interaction

                                                                                                                  type InboundRequest

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

                                                                                                                    InboundRequest used to wrap the incoming request with a timestamp

                                                                                                                    type Intercept

                                                                                                                    type Intercept func(*http.Request)

                                                                                                                      Intercept will be called before the request is made. Updates to the request will be reflected in the test

                                                                                                                      type Matcher

                                                                                                                      type Matcher func(*http.Request, *MockRequest) error

                                                                                                                        Matcher type accepts the actual request and a mock request to match against. Will return an error that describes why there was a mismatch if the inputs do not match or nil if they do.

                                                                                                                        type MessageRequest

                                                                                                                        type MessageRequest struct {
                                                                                                                        	Source    string
                                                                                                                        	Target    string
                                                                                                                        	Header    string
                                                                                                                        	Body      string
                                                                                                                        	Timestamp time.Time
                                                                                                                        }

                                                                                                                          MessageRequest represents a request interaction

                                                                                                                          func (MessageRequest) GetTime

                                                                                                                          func (r MessageRequest) GetTime() time.Time

                                                                                                                            GetTime gets the time of the MessageRequest interaction

                                                                                                                            type MessageResponse

                                                                                                                            type MessageResponse struct {
                                                                                                                            	Source    string
                                                                                                                            	Target    string
                                                                                                                            	Header    string
                                                                                                                            	Body      string
                                                                                                                            	Timestamp time.Time
                                                                                                                            }

                                                                                                                              MessageResponse represents a response interaction

                                                                                                                              func (MessageResponse) GetTime

                                                                                                                              func (r MessageResponse) GetTime() time.Time

                                                                                                                                GetTime gets the time of the MessageResponse interaction

                                                                                                                                type Mock

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

                                                                                                                                  Mock represents the entire interaction for a mock to be used for testing

                                                                                                                                  func NewMock

                                                                                                                                  func NewMock() *Mock

                                                                                                                                    NewMock create a new mock, ready for configuration using the builder pattern

                                                                                                                                    func (*Mock) Debug

                                                                                                                                    func (m *Mock) Debug() *Mock

                                                                                                                                      Debug is used to set debug mode for mocks in standalone mode. This is overridden by the debug setting in the `APITest` struct

                                                                                                                                      func (*Mock) Delete

                                                                                                                                      func (m *Mock) Delete(u string) *MockRequest

                                                                                                                                        Delete configures the mock to match http method DELETE

                                                                                                                                        func (*Mock) Deletef

                                                                                                                                        func (m *Mock) Deletef(format string, args ...interface{}) *MockRequest

                                                                                                                                          Deletef configures the mock to match http method DELETE and supports formatting

                                                                                                                                          func (*Mock) Get

                                                                                                                                          func (m *Mock) Get(u string) *MockRequest

                                                                                                                                            Get configures the mock to match http method GET

                                                                                                                                            func (*Mock) Getf

                                                                                                                                            func (m *Mock) Getf(format string, args ...interface{}) *MockRequest

                                                                                                                                              Getf configures the mock to match http method GET and supports formatting

                                                                                                                                              func (*Mock) Head

                                                                                                                                              func (m *Mock) Head(u string) *MockRequest

                                                                                                                                                Head configures the mock to match http method HEAD

                                                                                                                                                func (*Mock) HttpClient

                                                                                                                                                func (m *Mock) HttpClient(cli *http.Client) *Mock

                                                                                                                                                  HttpClient allows the developer to provide a custom http client when using mocks

                                                                                                                                                  func (*Mock) Matches

                                                                                                                                                  func (m *Mock) Matches(req *http.Request) []error

                                                                                                                                                    Matches checks whether the given request matches the mock

                                                                                                                                                    func (*Mock) Method

                                                                                                                                                    func (m *Mock) Method(method string) *MockRequest

                                                                                                                                                      Method configures mock to match given http method

                                                                                                                                                      func (*Mock) Patch

                                                                                                                                                      func (m *Mock) Patch(u string) *MockRequest

                                                                                                                                                        Patch configures the mock to match http method PATCH

                                                                                                                                                        func (*Mock) Patchf

                                                                                                                                                        func (m *Mock) Patchf(format string, args ...interface{}) *MockRequest

                                                                                                                                                          Patchf configures the mock to match http method PATCH and supports formatting

                                                                                                                                                          func (*Mock) Post

                                                                                                                                                          func (m *Mock) Post(u string) *MockRequest

                                                                                                                                                            Post configures the mock to match http method POST

                                                                                                                                                            func (*Mock) Postf

                                                                                                                                                            func (m *Mock) Postf(format string, args ...interface{}) *MockRequest

                                                                                                                                                              Postf configures the mock to match http method POST and supports formatting

                                                                                                                                                              func (*Mock) Put

                                                                                                                                                              func (m *Mock) Put(u string) *MockRequest

                                                                                                                                                                Put configures the mock to match http method PUT

                                                                                                                                                                func (*Mock) Putf

                                                                                                                                                                func (m *Mock) Putf(format string, args ...interface{}) *MockRequest

                                                                                                                                                                  Putf configures the mock to match http method PUT and supports formatting

                                                                                                                                                                  type MockRequest

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

                                                                                                                                                                    MockRequest represents the http request side of a mock interaction

                                                                                                                                                                    func (*MockRequest) AddMatcher

                                                                                                                                                                    func (r *MockRequest) AddMatcher(matcher Matcher) *MockRequest

                                                                                                                                                                      AddMatcher configures the mock request to match using a custom matcher

                                                                                                                                                                      func (*MockRequest) BasicAuth

                                                                                                                                                                      func (r *MockRequest) BasicAuth(username, password string) *MockRequest

                                                                                                                                                                        BasicAuth configures the mock request to match the given basic auth parameters

                                                                                                                                                                        func (*MockRequest) Body

                                                                                                                                                                        func (r *MockRequest) Body(b string) *MockRequest

                                                                                                                                                                          Body configures the mock request to match the given body

                                                                                                                                                                          func (*MockRequest) BodyFromFile

                                                                                                                                                                          func (r *MockRequest) BodyFromFile(f string) *MockRequest

                                                                                                                                                                            BodyFromFile configures the mock request to match the given body from a file

                                                                                                                                                                            func (*MockRequest) Bodyf

                                                                                                                                                                            func (r *MockRequest) Bodyf(format string, args ...interface{}) *MockRequest

                                                                                                                                                                              Bodyf configures the mock request to match the given body. Supports formatting the body

                                                                                                                                                                              func (*MockRequest) Cookie

                                                                                                                                                                              func (r *MockRequest) Cookie(name, value string) *MockRequest

                                                                                                                                                                                Cookie configures the mock request to match a cookie

                                                                                                                                                                                func (*MockRequest) CookieNotPresent

                                                                                                                                                                                func (r *MockRequest) CookieNotPresent(name string) *MockRequest

                                                                                                                                                                                  CookieNotPresent configures the mock request to match when a cookie is not present

                                                                                                                                                                                  func (*MockRequest) CookiePresent

                                                                                                                                                                                  func (r *MockRequest) CookiePresent(name string) *MockRequest

                                                                                                                                                                                    CookiePresent configures the mock request to match when a cookie is present, regardless of value

                                                                                                                                                                                    func (*MockRequest) FormData

                                                                                                                                                                                    func (r *MockRequest) FormData(key string, values ...string) *MockRequest

                                                                                                                                                                                      FormData configures the mock request to math the given form data

                                                                                                                                                                                      func (*MockRequest) FormDataNotPresent

                                                                                                                                                                                      func (r *MockRequest) FormDataNotPresent(key string) *MockRequest

                                                                                                                                                                                        FormDataNotPresent configures the mock request to match when the form data is not present

                                                                                                                                                                                        func (*MockRequest) FormDataPresent

                                                                                                                                                                                        func (r *MockRequest) FormDataPresent(key string) *MockRequest

                                                                                                                                                                                          FormDataPresent configures the mock request to match when the form data is present, regardless of values

                                                                                                                                                                                          func (*MockRequest) Header

                                                                                                                                                                                          func (r *MockRequest) Header(key, value string) *MockRequest

                                                                                                                                                                                            Header configures the mock request to match the given header

                                                                                                                                                                                            func (*MockRequest) HeaderNotPresent

                                                                                                                                                                                            func (r *MockRequest) HeaderNotPresent(key string) *MockRequest

                                                                                                                                                                                              HeaderNotPresent configures the mock request to match when the header is not present

                                                                                                                                                                                              func (*MockRequest) HeaderPresent

                                                                                                                                                                                              func (r *MockRequest) HeaderPresent(key string) *MockRequest

                                                                                                                                                                                                HeaderPresent configures the mock request to match when this header is present, regardless of value

                                                                                                                                                                                                func (*MockRequest) Headers

                                                                                                                                                                                                func (r *MockRequest) Headers(headers map[string]string) *MockRequest

                                                                                                                                                                                                  Headers configures the mock request to match the given headers

                                                                                                                                                                                                  func (*MockRequest) JSON

                                                                                                                                                                                                  func (r *MockRequest) JSON(v interface{}) *MockRequest

                                                                                                                                                                                                    JSON is a convenience method for setting the mock request body

                                                                                                                                                                                                    func (*MockRequest) Query

                                                                                                                                                                                                    func (r *MockRequest) Query(key, value string) *MockRequest

                                                                                                                                                                                                      Query configures the mock request to match a query param

                                                                                                                                                                                                      func (*MockRequest) QueryCollection

                                                                                                                                                                                                      func (r *MockRequest) QueryCollection(queryParams map[string][]string) *MockRequest

                                                                                                                                                                                                        QueryCollection configures the mock request to match a number of repeating query params, e.g. ?a=1&a=2&a=3

                                                                                                                                                                                                        func (*MockRequest) QueryNotPresent

                                                                                                                                                                                                        func (r *MockRequest) QueryNotPresent(key string) *MockRequest

                                                                                                                                                                                                          QueryNotPresent configures the mock request to match when the query param is not present

                                                                                                                                                                                                          func (*MockRequest) QueryParams

                                                                                                                                                                                                          func (r *MockRequest) QueryParams(queryParams map[string]string) *MockRequest

                                                                                                                                                                                                            QueryParams configures the mock request to match a number of query params

                                                                                                                                                                                                            func (*MockRequest) QueryPresent

                                                                                                                                                                                                            func (r *MockRequest) QueryPresent(key string) *MockRequest

                                                                                                                                                                                                              QueryPresent configures the mock request to match when a query param is present, regardless of value

                                                                                                                                                                                                              func (*MockRequest) RespondWith

                                                                                                                                                                                                              func (r *MockRequest) RespondWith() *MockResponse

                                                                                                                                                                                                                RespondWith finalises the mock request phase of set up and allowing the definition of response attributes to be defined

                                                                                                                                                                                                                type MockResponse

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

                                                                                                                                                                                                                  MockResponse represents the http response side of a mock interaction

                                                                                                                                                                                                                  func (*MockResponse) Body

                                                                                                                                                                                                                  func (r *MockResponse) Body(body string) *MockResponse

                                                                                                                                                                                                                    Body sets the mock response body

                                                                                                                                                                                                                    func (*MockResponse) BodyFromFile

                                                                                                                                                                                                                    func (r *MockResponse) BodyFromFile(f string) *MockResponse

                                                                                                                                                                                                                      BodyFromFile defines the mock response body from a file

                                                                                                                                                                                                                      func (*MockResponse) Bodyf

                                                                                                                                                                                                                      func (r *MockResponse) Bodyf(format string, args ...interface{}) *MockResponse

                                                                                                                                                                                                                        Bodyf sets the mock response body. Supports formatting

                                                                                                                                                                                                                        func (*MockResponse) Cookie

                                                                                                                                                                                                                        func (r *MockResponse) Cookie(name, value string) *MockResponse

                                                                                                                                                                                                                          Cookie respond with the given cookie

                                                                                                                                                                                                                          func (*MockResponse) Cookies

                                                                                                                                                                                                                          func (r *MockResponse) Cookies(cookie ...*Cookie) *MockResponse

                                                                                                                                                                                                                            Cookies respond with the given cookies

                                                                                                                                                                                                                            func (*MockResponse) End

                                                                                                                                                                                                                            func (r *MockResponse) End() *Mock

                                                                                                                                                                                                                              End finalise the response definition phase in order for the mock to be used

                                                                                                                                                                                                                              func (*MockResponse) EndStandalone

                                                                                                                                                                                                                              func (r *MockResponse) EndStandalone(other ...*Mock) func()

                                                                                                                                                                                                                                EndStandalone finalises the response definition of standalone mocks

                                                                                                                                                                                                                                func (*MockResponse) FixedDelay

                                                                                                                                                                                                                                func (r *MockResponse) FixedDelay(delay int64) *MockResponse

                                                                                                                                                                                                                                  FixedDelay will return the response after the given number of milliseconds. APITest::EnableMockResponseDelay must be set for this to take effect. If Timeout is set this has no effect.

                                                                                                                                                                                                                                  func (*MockResponse) Header

                                                                                                                                                                                                                                  func (r *MockResponse) Header(key string, value string) *MockResponse

                                                                                                                                                                                                                                    Header respond with the given header

                                                                                                                                                                                                                                    func (*MockResponse) Headers

                                                                                                                                                                                                                                    func (r *MockResponse) Headers(headers map[string]string) *MockResponse

                                                                                                                                                                                                                                      Headers respond with the given headers

                                                                                                                                                                                                                                      func (*MockResponse) JSON

                                                                                                                                                                                                                                      func (r *MockResponse) JSON(v interface{}) *MockResponse

                                                                                                                                                                                                                                        JSON is a convenience method for setting the mock response body

                                                                                                                                                                                                                                        func (*MockResponse) Status

                                                                                                                                                                                                                                        func (r *MockResponse) Status(statusCode int) *MockResponse

                                                                                                                                                                                                                                          Status respond with the given status

                                                                                                                                                                                                                                          func (*MockResponse) Timeout

                                                                                                                                                                                                                                          func (r *MockResponse) Timeout() *MockResponse

                                                                                                                                                                                                                                            Timeout forces the mock to return a http timeout

                                                                                                                                                                                                                                            func (*MockResponse) Times

                                                                                                                                                                                                                                            func (r *MockResponse) Times(times int) *MockResponse

                                                                                                                                                                                                                                              Times respond the given number of times

                                                                                                                                                                                                                                              type NoopVerifier

                                                                                                                                                                                                                                              type NoopVerifier struct{}

                                                                                                                                                                                                                                                NoopVerifier is a verifier that does not perform verification

                                                                                                                                                                                                                                                func (NoopVerifier) Equal

                                                                                                                                                                                                                                                func (n NoopVerifier) Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool

                                                                                                                                                                                                                                                  Equal does not perform any assertion and always returns true

                                                                                                                                                                                                                                                  func (NoopVerifier) Fail

                                                                                                                                                                                                                                                  func (n NoopVerifier) Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool

                                                                                                                                                                                                                                                    Fail does not perform any assertion and always returns true

                                                                                                                                                                                                                                                    func (NoopVerifier) JSONEq

                                                                                                                                                                                                                                                    func (n NoopVerifier) JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool

                                                                                                                                                                                                                                                      JSONEq does not perform any assertion and always returns true

                                                                                                                                                                                                                                                      func (NoopVerifier) NoError

                                                                                                                                                                                                                                                      func (n NoopVerifier) NoError(t TestingT, err error, msgAndArgs ...interface{}) bool

                                                                                                                                                                                                                                                        NoError asserts that a function returned no error

                                                                                                                                                                                                                                                        type Observe

                                                                                                                                                                                                                                                        type Observe func(*http.Response, *http.Request, *APITest)

                                                                                                                                                                                                                                                          Observe will be called by with the request and response on completion

                                                                                                                                                                                                                                                          type Recorder

                                                                                                                                                                                                                                                          type Recorder struct {
                                                                                                                                                                                                                                                          	Title    string
                                                                                                                                                                                                                                                          	SubTitle string
                                                                                                                                                                                                                                                          	Meta     map[string]interface{}
                                                                                                                                                                                                                                                          	Events   []Event
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            Recorder represents all of the report data

                                                                                                                                                                                                                                                            func NewTestRecorder

                                                                                                                                                                                                                                                            func NewTestRecorder() *Recorder

                                                                                                                                                                                                                                                              NewTestRecorder creates a new TestRecorder

                                                                                                                                                                                                                                                              func (*Recorder) AddHttpRequest

                                                                                                                                                                                                                                                              func (r *Recorder) AddHttpRequest(req HttpRequest) *Recorder

                                                                                                                                                                                                                                                                AddHttpRequest add an http request to recorder

                                                                                                                                                                                                                                                                func (*Recorder) AddHttpResponse

                                                                                                                                                                                                                                                                func (r *Recorder) AddHttpResponse(req HttpResponse) *Recorder

                                                                                                                                                                                                                                                                  AddHttpResponse add an HttpResponse to the recorder

                                                                                                                                                                                                                                                                  func (*Recorder) AddMessageRequest

                                                                                                                                                                                                                                                                  func (r *Recorder) AddMessageRequest(m MessageRequest) *Recorder

                                                                                                                                                                                                                                                                    AddMessageRequest add a MessageRequest to the recorder

                                                                                                                                                                                                                                                                    func (*Recorder) AddMessageResponse

                                                                                                                                                                                                                                                                    func (r *Recorder) AddMessageResponse(m MessageResponse) *Recorder

                                                                                                                                                                                                                                                                      AddMessageResponse add a MessageResponse to the recorder

                                                                                                                                                                                                                                                                      func (*Recorder) AddMeta

                                                                                                                                                                                                                                                                      func (r *Recorder) AddMeta(meta map[string]interface{}) *Recorder

                                                                                                                                                                                                                                                                        AddMeta add Meta to the recorder

                                                                                                                                                                                                                                                                        func (*Recorder) AddSubTitle

                                                                                                                                                                                                                                                                        func (r *Recorder) AddSubTitle(subTitle string) *Recorder

                                                                                                                                                                                                                                                                          AddSubTitle add a SubTitle to the recorder

                                                                                                                                                                                                                                                                          func (*Recorder) AddTitle

                                                                                                                                                                                                                                                                          func (r *Recorder) AddTitle(title string) *Recorder

                                                                                                                                                                                                                                                                            AddTitle add a Title to the recorder

                                                                                                                                                                                                                                                                            func (*Recorder) Reset

                                                                                                                                                                                                                                                                            func (r *Recorder) Reset()

                                                                                                                                                                                                                                                                              Reset resets the recorder to default starting state

                                                                                                                                                                                                                                                                              func (*Recorder) ResponseStatus

                                                                                                                                                                                                                                                                              func (r *Recorder) ResponseStatus() (int, error)

                                                                                                                                                                                                                                                                                ResponseStatus get response status of the recorder, returning an error when this wasn't possible

                                                                                                                                                                                                                                                                                type RecorderHook

                                                                                                                                                                                                                                                                                type RecorderHook func(*Recorder)

                                                                                                                                                                                                                                                                                  RecorderHook used to implement a custom interaction recorder

                                                                                                                                                                                                                                                                                  type ReportFormatter

                                                                                                                                                                                                                                                                                  type ReportFormatter interface {
                                                                                                                                                                                                                                                                                  	// Format formats the events received from the recorder
                                                                                                                                                                                                                                                                                  	Format(*Recorder)
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    ReportFormatter represents the report formatter

                                                                                                                                                                                                                                                                                    type Request

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

                                                                                                                                                                                                                                                                                      Request is the user defined request that will be invoked on the handler under test

                                                                                                                                                                                                                                                                                      func (*Request) BasicAuth

                                                                                                                                                                                                                                                                                      func (r *Request) BasicAuth(username, password string) *Request

                                                                                                                                                                                                                                                                                        BasicAuth is a builder method to sets basic auth on the request.

                                                                                                                                                                                                                                                                                        func (*Request) Body

                                                                                                                                                                                                                                                                                        func (r *Request) Body(b string) *Request

                                                                                                                                                                                                                                                                                          Body is a builder method to set the request body

                                                                                                                                                                                                                                                                                          func (*Request) BodyFromFile

                                                                                                                                                                                                                                                                                          func (r *Request) BodyFromFile(f string) *Request

                                                                                                                                                                                                                                                                                            BodyFromFile is a builder method to set the request body

                                                                                                                                                                                                                                                                                            func (*Request) Bodyf

                                                                                                                                                                                                                                                                                            func (r *Request) Bodyf(format string, args ...interface{}) *Request

                                                                                                                                                                                                                                                                                              Bodyf sets the request body and supports a formatter

                                                                                                                                                                                                                                                                                              func (*Request) ContentType

                                                                                                                                                                                                                                                                                              func (r *Request) ContentType(contentType string) *Request

                                                                                                                                                                                                                                                                                                ContentType is a builder method to set the Content-Type header of the request

                                                                                                                                                                                                                                                                                                func (*Request) Cookie

                                                                                                                                                                                                                                                                                                func (r *Request) Cookie(name, value string) *Request

                                                                                                                                                                                                                                                                                                  Cookie is a convenience method for setting a single request cookies by name and value

                                                                                                                                                                                                                                                                                                  func (*Request) Cookies

                                                                                                                                                                                                                                                                                                  func (r *Request) Cookies(c ...*Cookie) *Request

                                                                                                                                                                                                                                                                                                    Cookies is a builder method to set the request cookies

                                                                                                                                                                                                                                                                                                    func (*Request) Expect

                                                                                                                                                                                                                                                                                                    func (r *Request) Expect(t TestingT) *Response

                                                                                                                                                                                                                                                                                                      Expect marks the request spec as complete and following code will define the expected response

                                                                                                                                                                                                                                                                                                      func (*Request) FormData

                                                                                                                                                                                                                                                                                                      func (r *Request) FormData(name string, values ...string) *Request

                                                                                                                                                                                                                                                                                                        FormData is a builder method to set the body form data Also sets the content type of the request to application/x-www-form-urlencoded

                                                                                                                                                                                                                                                                                                        func (*Request) GraphQLQuery

                                                                                                                                                                                                                                                                                                        func (r *Request) GraphQLQuery(query string, variables ...map[string]interface{}) *Request

                                                                                                                                                                                                                                                                                                          GraphQLQuery is a convenience method for building a graphql POST request

                                                                                                                                                                                                                                                                                                          func (*Request) GraphQLRequest

                                                                                                                                                                                                                                                                                                          func (r *Request) GraphQLRequest(body GraphQLRequestBody) *Request

                                                                                                                                                                                                                                                                                                            GraphQLRequest builds a graphql POST request

                                                                                                                                                                                                                                                                                                            func (*Request) Header

                                                                                                                                                                                                                                                                                                            func (r *Request) Header(key, value string) *Request

                                                                                                                                                                                                                                                                                                              Header is a builder method to set the request headers

                                                                                                                                                                                                                                                                                                              func (*Request) Headers

                                                                                                                                                                                                                                                                                                              func (r *Request) Headers(headers map[string]string) *Request

                                                                                                                                                                                                                                                                                                                Headers is a builder method to set the request headers

                                                                                                                                                                                                                                                                                                                func (*Request) JSON

                                                                                                                                                                                                                                                                                                                func (r *Request) JSON(v interface{}) *Request

                                                                                                                                                                                                                                                                                                                  JSON is a convenience method for setting the request body and content type header as "application/json". If v is not a string or []byte it will marshall the provided variable as json

                                                                                                                                                                                                                                                                                                                  func (*Request) JSONFromFile

                                                                                                                                                                                                                                                                                                                  func (r *Request) JSONFromFile(f string) *Request

                                                                                                                                                                                                                                                                                                                    JSONFromFile is a convenience method for setting the request body and content type header as "application/json"

                                                                                                                                                                                                                                                                                                                    func (*Request) Query

                                                                                                                                                                                                                                                                                                                    func (r *Request) Query(key, value string) *Request

                                                                                                                                                                                                                                                                                                                      Query is a convenience method to add a query parameter to the request.

                                                                                                                                                                                                                                                                                                                      func (*Request) QueryCollection

                                                                                                                                                                                                                                                                                                                      func (r *Request) QueryCollection(q map[string][]string) *Request

                                                                                                                                                                                                                                                                                                                        QueryCollection is a builder method to set the request query parameters This can be used in combination with request.Query

                                                                                                                                                                                                                                                                                                                        func (*Request) QueryParams

                                                                                                                                                                                                                                                                                                                        func (r *Request) QueryParams(params map[string]string) *Request

                                                                                                                                                                                                                                                                                                                          QueryParams is a builder method to set the request query parameters. This can be used in combination with request.QueryCollection

                                                                                                                                                                                                                                                                                                                          func (*Request) URL

                                                                                                                                                                                                                                                                                                                          func (r *Request) URL(url string) *Request

                                                                                                                                                                                                                                                                                                                            URL is a builder method for setting the url of the request

                                                                                                                                                                                                                                                                                                                            func (*Request) URLf

                                                                                                                                                                                                                                                                                                                            func (r *Request) URLf(format string, args ...interface{}) *Request

                                                                                                                                                                                                                                                                                                                              URLf is a builder method for setting the url of the request and supports a formatter

                                                                                                                                                                                                                                                                                                                              type Response

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

                                                                                                                                                                                                                                                                                                                                Response is the user defined expected response from the application under test

                                                                                                                                                                                                                                                                                                                                func (*Response) Assert

                                                                                                                                                                                                                                                                                                                                func (r *Response) Assert(fn func(*http.Response, *http.Request) error) *Response

                                                                                                                                                                                                                                                                                                                                  Assert allows the consumer to provide a user defined function containing their own custom assertions

                                                                                                                                                                                                                                                                                                                                  func (*Response) Body

                                                                                                                                                                                                                                                                                                                                  func (r *Response) Body(b string) *Response

                                                                                                                                                                                                                                                                                                                                    Body is the expected response body

                                                                                                                                                                                                                                                                                                                                    func (*Response) BodyFromFile

                                                                                                                                                                                                                                                                                                                                    func (r *Response) BodyFromFile(f string) *Response

                                                                                                                                                                                                                                                                                                                                      BodyFromFile reads the given file and uses the content as the expected response body

                                                                                                                                                                                                                                                                                                                                      func (*Response) Bodyf

                                                                                                                                                                                                                                                                                                                                      func (r *Response) Bodyf(format string, args ...interface{}) *Response

                                                                                                                                                                                                                                                                                                                                        Bodyf is the expected response body that supports a formatter

                                                                                                                                                                                                                                                                                                                                        func (*Response) Cookie

                                                                                                                                                                                                                                                                                                                                        func (r *Response) Cookie(name, value string) *Response

                                                                                                                                                                                                                                                                                                                                          Cookie is used to match on an individual cookie name/value pair in the expected response cookies

                                                                                                                                                                                                                                                                                                                                          func (*Response) CookieNotPresent

                                                                                                                                                                                                                                                                                                                                          func (r *Response) CookieNotPresent(cookieName string) *Response

                                                                                                                                                                                                                                                                                                                                            CookieNotPresent is used to assert that a cookie is not present in the response

                                                                                                                                                                                                                                                                                                                                            func (*Response) CookiePresent

                                                                                                                                                                                                                                                                                                                                            func (r *Response) CookiePresent(cookieName string) *Response

                                                                                                                                                                                                                                                                                                                                              CookiePresent is used to assert that a cookie is present in the response, regardless of its value

                                                                                                                                                                                                                                                                                                                                              func (*Response) Cookies

                                                                                                                                                                                                                                                                                                                                              func (r *Response) Cookies(cookies ...*Cookie) *Response

                                                                                                                                                                                                                                                                                                                                                Cookies is the expected response cookies

                                                                                                                                                                                                                                                                                                                                                func (*Response) End

                                                                                                                                                                                                                                                                                                                                                func (r *Response) End() Result

                                                                                                                                                                                                                                                                                                                                                  End runs the test returning the result to the caller

                                                                                                                                                                                                                                                                                                                                                  func (*Response) Header

                                                                                                                                                                                                                                                                                                                                                  func (r *Response) Header(key, value string) *Response

                                                                                                                                                                                                                                                                                                                                                    Header is a builder method to set the request headers

                                                                                                                                                                                                                                                                                                                                                    func (*Response) HeaderNotPresent

                                                                                                                                                                                                                                                                                                                                                    func (r *Response) HeaderNotPresent(name string) *Response

                                                                                                                                                                                                                                                                                                                                                      HeaderNotPresent is a builder method to set the request headers that should not be present in the response

                                                                                                                                                                                                                                                                                                                                                      func (*Response) HeaderPresent

                                                                                                                                                                                                                                                                                                                                                      func (r *Response) HeaderPresent(name string) *Response

                                                                                                                                                                                                                                                                                                                                                        HeaderPresent is a builder method to set the request headers that should be present in the response

                                                                                                                                                                                                                                                                                                                                                        func (*Response) Headers

                                                                                                                                                                                                                                                                                                                                                        func (r *Response) Headers(headers map[string]string) *Response

                                                                                                                                                                                                                                                                                                                                                          Headers is a builder method to set the request headers

                                                                                                                                                                                                                                                                                                                                                          func (*Response) Status

                                                                                                                                                                                                                                                                                                                                                          func (r *Response) Status(s int) *Response

                                                                                                                                                                                                                                                                                                                                                            Status is the expected response http status code

                                                                                                                                                                                                                                                                                                                                                            type Result

                                                                                                                                                                                                                                                                                                                                                            type Result struct {
                                                                                                                                                                                                                                                                                                                                                            	Response *http.Response
                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              Result provides the final result

                                                                                                                                                                                                                                                                                                                                                              func (Result) JSON

                                                                                                                                                                                                                                                                                                                                                              func (r Result) JSON(t interface{})

                                                                                                                                                                                                                                                                                                                                                                JSON unmarshal the result response body to a valid struct

                                                                                                                                                                                                                                                                                                                                                                func (Result) UnmatchedMocks

                                                                                                                                                                                                                                                                                                                                                                func (r Result) UnmatchedMocks() []UnmatchedMock

                                                                                                                                                                                                                                                                                                                                                                  UnmatchedMocks returns any mocks that were not used, e.g. there was not a matching http Request for the mock

                                                                                                                                                                                                                                                                                                                                                                  type SequenceDiagramFormatter

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

                                                                                                                                                                                                                                                                                                                                                                    SequenceDiagramFormatter implementation of a ReportFormatter

                                                                                                                                                                                                                                                                                                                                                                    func SequenceDiagram

                                                                                                                                                                                                                                                                                                                                                                    func SequenceDiagram(path ...string) *SequenceDiagramFormatter

                                                                                                                                                                                                                                                                                                                                                                      SequenceDiagram produce a sequence diagram at the given path or .sequence by default

                                                                                                                                                                                                                                                                                                                                                                      func (*SequenceDiagramFormatter) Format

                                                                                                                                                                                                                                                                                                                                                                      func (r *SequenceDiagramFormatter) Format(recorder *Recorder)

                                                                                                                                                                                                                                                                                                                                                                        Format formats the events received by the recorder

                                                                                                                                                                                                                                                                                                                                                                        type StandaloneMocks

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

                                                                                                                                                                                                                                                                                                                                                                          StandaloneMocks for using mocks outside of API tests context

                                                                                                                                                                                                                                                                                                                                                                          func NewStandaloneMocks

                                                                                                                                                                                                                                                                                                                                                                          func NewStandaloneMocks(mocks ...*Mock) *StandaloneMocks

                                                                                                                                                                                                                                                                                                                                                                            NewStandaloneMocks create a series of StandaloneMocks

                                                                                                                                                                                                                                                                                                                                                                            func (*StandaloneMocks) Debug

                                                                                                                                                                                                                                                                                                                                                                            func (r *StandaloneMocks) Debug() *StandaloneMocks

                                                                                                                                                                                                                                                                                                                                                                              Debug switch on debugging mode

                                                                                                                                                                                                                                                                                                                                                                              func (*StandaloneMocks) End

                                                                                                                                                                                                                                                                                                                                                                              func (r *StandaloneMocks) End() func()

                                                                                                                                                                                                                                                                                                                                                                                End finalises the mock, ready for use

                                                                                                                                                                                                                                                                                                                                                                                func (*StandaloneMocks) HttpClient

                                                                                                                                                                                                                                                                                                                                                                                func (r *StandaloneMocks) HttpClient(cli *http.Client) *StandaloneMocks

                                                                                                                                                                                                                                                                                                                                                                                  HttpClient use the given http client

                                                                                                                                                                                                                                                                                                                                                                                  type TestingT

                                                                                                                                                                                                                                                                                                                                                                                  type TestingT interface {
                                                                                                                                                                                                                                                                                                                                                                                  	Errorf(format string, args ...interface{})
                                                                                                                                                                                                                                                                                                                                                                                  	Fatal(args ...interface{})
                                                                                                                                                                                                                                                                                                                                                                                  	Fatalf(format string, args ...interface{})
                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                    TestingT is an interface to wrap the native *testing.T interface, this allows integration with GinkgoT() interface GinkgoT interface defined in https://github.com/onsi/ginkgo/blob/55c858784e51c26077949c81b6defb6b97b76944/ginkgo_dsl.go#L91

                                                                                                                                                                                                                                                                                                                                                                                    type Transport

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

                                                                                                                                                                                                                                                                                                                                                                                      Transport wraps components used to observe and manipulate the real request and response objects

                                                                                                                                                                                                                                                                                                                                                                                      func (*Transport) Hijack

                                                                                                                                                                                                                                                                                                                                                                                      func (r *Transport) Hijack()

                                                                                                                                                                                                                                                                                                                                                                                        Hijack replace the transport implementation of the interaction under test in order to observe, mock and inject expectations

                                                                                                                                                                                                                                                                                                                                                                                        func (*Transport) Reset

                                                                                                                                                                                                                                                                                                                                                                                        func (r *Transport) Reset()

                                                                                                                                                                                                                                                                                                                                                                                          Reset replace the hijacked transport implementation of the interaction under test to the original implementation

                                                                                                                                                                                                                                                                                                                                                                                          func (*Transport) RoundTrip

                                                                                                                                                                                                                                                                                                                                                                                          func (r *Transport) RoundTrip(req *http.Request) (mockResponse *http.Response, matchErrors error)

                                                                                                                                                                                                                                                                                                                                                                                            RoundTrip implementation intended to match a given expected mock request or throw an error with a list of reasons why no match was found.

                                                                                                                                                                                                                                                                                                                                                                                            type UnmatchedMock

                                                                                                                                                                                                                                                                                                                                                                                            type UnmatchedMock struct {
                                                                                                                                                                                                                                                                                                                                                                                            	URL url.URL
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              UnmatchedMock exposes some information about mocks that failed to match a request

                                                                                                                                                                                                                                                                                                                                                                                              type Verifier

                                                                                                                                                                                                                                                                                                                                                                                              type Verifier interface {
                                                                                                                                                                                                                                                                                                                                                                                              	Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool
                                                                                                                                                                                                                                                                                                                                                                                              	JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool
                                                                                                                                                                                                                                                                                                                                                                                              	Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool
                                                                                                                                                                                                                                                                                                                                                                                              	NoError(t TestingT, err error, msgAndArgs ...interface{}) bool
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                Verifier is the assertion interface allowing consumers to inject a custom assertion implementation. It also allows failure scenarios to be tested within apitest

                                                                                                                                                                                                                                                                                                                                                                                                Directories

                                                                                                                                                                                                                                                                                                                                                                                                Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                examples module
                                                                                                                                                                                                                                                                                                                                                                                                x
                                                                                                                                                                                                                                                                                                                                                                                                db