client_moq.go

// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package client

import (
	"context"
	"net/http"
	"net/url"
	"sync"
)

// Ensure, that IClientMock does implement IClient.
// If this is not the case, regenerate this file with moq.
var _ IClient = &IClientMock{}

// IClientMock is a mock implementation of IClient.
//
// 	func TestSomethingThatUsesIClient(t *testing.T) {
//
// 		// make and configure a mocked IClient
// 		mockedIClient := &IClientMock{
// 			baseURLGetterFunc: func() *url.URL {
// 				panic("mock out the baseURLGetter method")
// 			},
// 			doFunc: func(ctx context.Context, req *http.Request, v interface{}) (*Response, error) {
// 				panic("mock out the do method")
// 			},
// 			dumpHTTPFunc: func(req *http.Request, resp *http.Response) error {
// 				panic("mock out the dumpHTTP method")
// 			},
// 			newRequestFunc: func(method string, path string, body interface{}) (*http.Request, error) {
// 				panic("mock out the newRequest method")
// 			},
// 			postFormFunc: func(ctx context.Context, urlMoqParam string, data url.Values, v interface{}) (*Response, error) {
// 				panic("mock out the postForm method")
// 			},
// 		}
//
// 		// use mockedIClient in code that requires IClient
// 		// and then make assertions.
//
// 	}
type IClientMock struct {
	// baseURLGetterFunc mocks the baseURLGetter method.
	baseURLGetterFunc func() *url.URL

	// doFunc mocks the do method.
	doFunc func(ctx context.Context, req *http.Request, v interface{}) (*Response, error)

	// dumpHTTPFunc mocks the dumpHTTP method.
	dumpHTTPFunc func(req *http.Request, resp *http.Response) error

	// newRequestFunc mocks the newRequest method.
	newRequestFunc func(method string, path string, body interface{}) (*http.Request, error)

	// postFormFunc mocks the postForm method.
	postFormFunc func(ctx context.Context, urlMoqParam string, data url.Values, v interface{}) (*Response, error)

	// calls tracks calls to the methods.
	calls struct {
		// baseURLGetter holds details about calls to the baseURLGetter method.
		baseURLGetter []struct {
		}
		// do holds details about calls to the do method.
		do []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Req is the req argument value.
			Req *http.Request
			// V is the v argument value.
			V interface{}
		}
		// dumpHTTP holds details about calls to the dumpHTTP method.
		dumpHTTP []struct {
			// Req is the req argument value.
			Req *http.Request
			// Resp is the resp argument value.
			Resp *http.Response
		}
		// newRequest holds details about calls to the newRequest method.
		newRequest []struct {
			// Method is the method argument value.
			Method string
			// Path is the path argument value.
			Path string
			// Body is the body argument value.
			Body interface{}
		}
		// postForm holds details about calls to the postForm method.
		postForm []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// UrlMoqParam is the urlMoqParam argument value.
			UrlMoqParam string
			// Data is the data argument value.
			Data url.Values
			// V is the v argument value.
			V interface{}
		}
	}
	lockbaseURLGetter sync.RWMutex
	lockdo            sync.RWMutex
	lockdumpHTTP      sync.RWMutex
	locknewRequest    sync.RWMutex
	lockpostForm      sync.RWMutex
}

// baseURLGetter calls baseURLGetterFunc.
func (mock *IClientMock) baseURLGetter() *url.URL {
	if mock.baseURLGetterFunc == nil {
		panic("IClientMock.baseURLGetterFunc: method is nil but IClient.baseURLGetter was just called")
	}
	callInfo := struct {
	}{}
	mock.lockbaseURLGetter.Lock()
	mock.calls.baseURLGetter = append(mock.calls.baseURLGetter, callInfo)
	mock.lockbaseURLGetter.Unlock()
	return mock.baseURLGetterFunc()
}

// baseURLGetterCalls gets all the calls that were made to baseURLGetter.
// Check the length with:
//     len(mockedIClient.baseURLGetterCalls())
func (mock *IClientMock) baseURLGetterCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockbaseURLGetter.RLock()
	calls = mock.calls.baseURLGetter
	mock.lockbaseURLGetter.RUnlock()
	return calls
}

// do calls doFunc.
func (mock *IClientMock) do(ctx context.Context, req *http.Request, v interface{}) (*Response, error) {
	if mock.doFunc == nil {
		panic("IClientMock.doFunc: method is nil but IClient.do was just called")
	}
	callInfo := struct {
		Ctx context.Context
		Req *http.Request
		V   interface{}
	}{
		Ctx: ctx,
		Req: req,
		V:   v,
	}
	mock.lockdo.Lock()
	mock.calls.do = append(mock.calls.do, callInfo)
	mock.lockdo.Unlock()
	return mock.doFunc(ctx, req, v)
}

// doCalls gets all the calls that were made to do.
// Check the length with:
//     len(mockedIClient.doCalls())
func (mock *IClientMock) doCalls() []struct {
	Ctx context.Context
	Req *http.Request
	V   interface{}
} {
	var calls []struct {
		Ctx context.Context
		Req *http.Request
		V   interface{}
	}
	mock.lockdo.RLock()
	calls = mock.calls.do
	mock.lockdo.RUnlock()
	return calls
}

// dumpHTTP calls dumpHTTPFunc.
func (mock *IClientMock) dumpHTTP(req *http.Request, resp *http.Response) error {
	if mock.dumpHTTPFunc == nil {
		panic("IClientMock.dumpHTTPFunc: method is nil but IClient.dumpHTTP was just called")
	}
	callInfo := struct {
		Req  *http.Request
		Resp *http.Response
	}{
		Req:  req,
		Resp: resp,
	}
	mock.lockdumpHTTP.Lock()
	mock.calls.dumpHTTP = append(mock.calls.dumpHTTP, callInfo)
	mock.lockdumpHTTP.Unlock()
	return mock.dumpHTTPFunc(req, resp)
}

// dumpHTTPCalls gets all the calls that were made to dumpHTTP.
// Check the length with:
//     len(mockedIClient.dumpHTTPCalls())
func (mock *IClientMock) dumpHTTPCalls() []struct {
	Req  *http.Request
	Resp *http.Response
} {
	var calls []struct {
		Req  *http.Request
		Resp *http.Response
	}
	mock.lockdumpHTTP.RLock()
	calls = mock.calls.dumpHTTP
	mock.lockdumpHTTP.RUnlock()
	return calls
}

// newRequest calls newRequestFunc.
func (mock *IClientMock) newRequest(method string, path string, body interface{}) (*http.Request, error) {
	if mock.newRequestFunc == nil {
		panic("IClientMock.newRequestFunc: method is nil but IClient.newRequest was just called")
	}
	callInfo := struct {
		Method string
		Path   string
		Body   interface{}
	}{
		Method: method,
		Path:   path,
		Body:   body,
	}
	mock.locknewRequest.Lock()
	mock.calls.newRequest = append(mock.calls.newRequest, callInfo)
	mock.locknewRequest.Unlock()
	return mock.newRequestFunc(method, path, body)
}

// newRequestCalls gets all the calls that were made to newRequest.
// Check the length with:
//     len(mockedIClient.newRequestCalls())
func (mock *IClientMock) newRequestCalls() []struct {
	Method string
	Path   string
	Body   interface{}
} {
	var calls []struct {
		Method string
		Path   string
		Body   interface{}
	}
	mock.locknewRequest.RLock()
	calls = mock.calls.newRequest
	mock.locknewRequest.RUnlock()
	return calls
}

// postForm calls postFormFunc.
func (mock *IClientMock) postForm(ctx context.Context, urlMoqParam string, data url.Values, v interface{}) (*Response, error) {
	if mock.postFormFunc == nil {
		panic("IClientMock.postFormFunc: method is nil but IClient.postForm was just called")
	}
	callInfo := struct {
		Ctx         context.Context
		UrlMoqParam string
		Data        url.Values
		V           interface{}
	}{
		Ctx:         ctx,
		UrlMoqParam: urlMoqParam,
		Data:        data,
		V:           v,
	}
	mock.lockpostForm.Lock()
	mock.calls.postForm = append(mock.calls.postForm, callInfo)
	mock.lockpostForm.Unlock()
	return mock.postFormFunc(ctx, urlMoqParam, data, v)
}

// postFormCalls gets all the calls that were made to postForm.
// Check the length with:
//     len(mockedIClient.postFormCalls())
func (mock *IClientMock) postFormCalls() []struct {
	Ctx         context.Context
	UrlMoqParam string
	Data        url.Values
	V           interface{}
} {
	var calls []struct {
		Ctx         context.Context
		UrlMoqParam string
		Data        url.Values
		V           interface{}
	}
	mock.lockpostForm.RLock()
	calls = mock.calls.postForm
	mock.lockpostForm.RUnlock()
	return calls
}