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.New().
		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.New(handler).
		Get("/hello").
		Expect(t).
		Assert(jsonpath.Equal(`$.a`, float64(12345))).
		End()
}
Custom assert functions
func TestApi(t *testing.T) {
	apitest.New().
		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.New().
		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.New().
		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.New().
		Handler(handler).
		Get("/hello").
		BasicAuth("username", "password").
		Expect(t).
		Status(http.StatusOK).
		End()
}
Provide cookies in the request
func TestApi(t *testing.T) {
	apitest.New().
		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.New().
		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.New().
		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.New().
		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.New().
		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.New().
		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 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) 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