request_checker_mock.go

package executor

// Code generated by http://github.com/gojuno/minimock (dev). DO NOT EDIT.

import (
	"context"
	"sync"
	mm_atomic "sync/atomic"
	mm_time "time"

	"github.com/gojuno/minimock"
	"github.com/insolar/insolar/insolar"
	"github.com/insolar/insolar/insolar/record"
)

// RequestCheckerMock implements RequestChecker
type RequestCheckerMock struct {
	t minimock.Tester

	funcCheckRequest          func(ctx context.Context, requestID insolar.ID, request record.Request) (err error)
	inspectFuncCheckRequest   func(ctx context.Context, requestID insolar.ID, request record.Request)
	afterCheckRequestCounter  uint64
	beforeCheckRequestCounter uint64
	CheckRequestMock          mRequestCheckerMockCheckRequest

	funcValidateRequest          func(ctx context.Context, requestID insolar.ID, request record.Request) (err error)
	inspectFuncValidateRequest   func(ctx context.Context, requestID insolar.ID, request record.Request)
	afterValidateRequestCounter  uint64
	beforeValidateRequestCounter uint64
	ValidateRequestMock          mRequestCheckerMockValidateRequest
}

// NewRequestCheckerMock returns a mock for RequestChecker
func NewRequestCheckerMock(t minimock.Tester) *RequestCheckerMock {
	m := &RequestCheckerMock{t: t}
	if controller, ok := t.(minimock.MockController); ok {
		controller.RegisterMocker(m)
	}

	m.CheckRequestMock = mRequestCheckerMockCheckRequest{mock: m}
	m.CheckRequestMock.callArgs = []*RequestCheckerMockCheckRequestParams{}

	m.ValidateRequestMock = mRequestCheckerMockValidateRequest{mock: m}
	m.ValidateRequestMock.callArgs = []*RequestCheckerMockValidateRequestParams{}

	return m
}

type mRequestCheckerMockCheckRequest struct {
	mock               *RequestCheckerMock
	defaultExpectation *RequestCheckerMockCheckRequestExpectation
	expectations       []*RequestCheckerMockCheckRequestExpectation

	callArgs []*RequestCheckerMockCheckRequestParams
	mutex    sync.RWMutex
}

// RequestCheckerMockCheckRequestExpectation specifies expectation struct of the RequestChecker.CheckRequest
type RequestCheckerMockCheckRequestExpectation struct {
	mock    *RequestCheckerMock
	params  *RequestCheckerMockCheckRequestParams
	results *RequestCheckerMockCheckRequestResults
	Counter uint64
}

// RequestCheckerMockCheckRequestParams contains parameters of the RequestChecker.CheckRequest
type RequestCheckerMockCheckRequestParams struct {
	ctx       context.Context
	requestID insolar.ID
	request   record.Request
}

// RequestCheckerMockCheckRequestResults contains results of the RequestChecker.CheckRequest
type RequestCheckerMockCheckRequestResults struct {
	err error
}

// Expect sets up expected params for RequestChecker.CheckRequest
func (mmCheckRequest *mRequestCheckerMockCheckRequest) Expect(ctx context.Context, requestID insolar.ID, request record.Request) *mRequestCheckerMockCheckRequest {
	if mmCheckRequest.mock.funcCheckRequest != nil {
		mmCheckRequest.mock.t.Fatalf("RequestCheckerMock.CheckRequest mock is already set by Set")
	}

	if mmCheckRequest.defaultExpectation == nil {
		mmCheckRequest.defaultExpectation = &RequestCheckerMockCheckRequestExpectation{}
	}

	mmCheckRequest.defaultExpectation.params = &RequestCheckerMockCheckRequestParams{ctx, requestID, request}
	for _, e := range mmCheckRequest.expectations {
		if minimock.Equal(e.params, mmCheckRequest.defaultExpectation.params) {
			mmCheckRequest.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCheckRequest.defaultExpectation.params)
		}
	}

	return mmCheckRequest
}

// Inspect accepts an inspector function that has same arguments as the RequestChecker.CheckRequest
func (mmCheckRequest *mRequestCheckerMockCheckRequest) Inspect(f func(ctx context.Context, requestID insolar.ID, request record.Request)) *mRequestCheckerMockCheckRequest {
	if mmCheckRequest.mock.inspectFuncCheckRequest != nil {
		mmCheckRequest.mock.t.Fatalf("Inspect function is already set for RequestCheckerMock.CheckRequest")
	}

	mmCheckRequest.mock.inspectFuncCheckRequest = f

	return mmCheckRequest
}

// Return sets up results that will be returned by RequestChecker.CheckRequest
func (mmCheckRequest *mRequestCheckerMockCheckRequest) Return(err error) *RequestCheckerMock {
	if mmCheckRequest.mock.funcCheckRequest != nil {
		mmCheckRequest.mock.t.Fatalf("RequestCheckerMock.CheckRequest mock is already set by Set")
	}

	if mmCheckRequest.defaultExpectation == nil {
		mmCheckRequest.defaultExpectation = &RequestCheckerMockCheckRequestExpectation{mock: mmCheckRequest.mock}
	}
	mmCheckRequest.defaultExpectation.results = &RequestCheckerMockCheckRequestResults{err}
	return mmCheckRequest.mock
}

//Set uses given function f to mock the RequestChecker.CheckRequest method
func (mmCheckRequest *mRequestCheckerMockCheckRequest) Set(f func(ctx context.Context, requestID insolar.ID, request record.Request) (err error)) *RequestCheckerMock {
	if mmCheckRequest.defaultExpectation != nil {
		mmCheckRequest.mock.t.Fatalf("Default expectation is already set for the RequestChecker.CheckRequest method")
	}

	if len(mmCheckRequest.expectations) > 0 {
		mmCheckRequest.mock.t.Fatalf("Some expectations are already set for the RequestChecker.CheckRequest method")
	}

	mmCheckRequest.mock.funcCheckRequest = f
	return mmCheckRequest.mock
}

// When sets expectation for the RequestChecker.CheckRequest which will trigger the result defined by the following
// Then helper
func (mmCheckRequest *mRequestCheckerMockCheckRequest) When(ctx context.Context, requestID insolar.ID, request record.Request) *RequestCheckerMockCheckRequestExpectation {
	if mmCheckRequest.mock.funcCheckRequest != nil {
		mmCheckRequest.mock.t.Fatalf("RequestCheckerMock.CheckRequest mock is already set by Set")
	}

	expectation := &RequestCheckerMockCheckRequestExpectation{
		mock:   mmCheckRequest.mock,
		params: &RequestCheckerMockCheckRequestParams{ctx, requestID, request},
	}
	mmCheckRequest.expectations = append(mmCheckRequest.expectations, expectation)
	return expectation
}

// Then sets up RequestChecker.CheckRequest return parameters for the expectation previously defined by the When method
func (e *RequestCheckerMockCheckRequestExpectation) Then(err error) *RequestCheckerMock {
	e.results = &RequestCheckerMockCheckRequestResults{err}
	return e.mock
}

// CheckRequest implements RequestChecker
func (mmCheckRequest *RequestCheckerMock) CheckRequest(ctx context.Context, requestID insolar.ID, request record.Request) (err error) {
	mm_atomic.AddUint64(&mmCheckRequest.beforeCheckRequestCounter, 1)
	defer mm_atomic.AddUint64(&mmCheckRequest.afterCheckRequestCounter, 1)

	if mmCheckRequest.inspectFuncCheckRequest != nil {
		mmCheckRequest.inspectFuncCheckRequest(ctx, requestID, request)
	}

	params := &RequestCheckerMockCheckRequestParams{ctx, requestID, request}

	// Record call args
	mmCheckRequest.CheckRequestMock.mutex.Lock()
	mmCheckRequest.CheckRequestMock.callArgs = append(mmCheckRequest.CheckRequestMock.callArgs, params)
	mmCheckRequest.CheckRequestMock.mutex.Unlock()

	for _, e := range mmCheckRequest.CheckRequestMock.expectations {
		if minimock.Equal(e.params, params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmCheckRequest.CheckRequestMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmCheckRequest.CheckRequestMock.defaultExpectation.Counter, 1)
		want := mmCheckRequest.CheckRequestMock.defaultExpectation.params
		got := RequestCheckerMockCheckRequestParams{ctx, requestID, request}
		if want != nil && !minimock.Equal(*want, got) {
			mmCheckRequest.t.Errorf("RequestCheckerMock.CheckRequest got unexpected parameters, want: %#v, got: %#v%s\n", *want, got, minimock.Diff(*want, got))
		}

		results := mmCheckRequest.CheckRequestMock.defaultExpectation.results
		if results == nil {
			mmCheckRequest.t.Fatal("No results are set for the RequestCheckerMock.CheckRequest")
		}
		return (*results).err
	}
	if mmCheckRequest.funcCheckRequest != nil {
		return mmCheckRequest.funcCheckRequest(ctx, requestID, request)
	}
	mmCheckRequest.t.Fatalf("Unexpected call to RequestCheckerMock.CheckRequest. %v %v %v", ctx, requestID, request)
	return
}

// CheckRequestAfterCounter returns a count of finished RequestCheckerMock.CheckRequest invocations
func (mmCheckRequest *RequestCheckerMock) CheckRequestAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCheckRequest.afterCheckRequestCounter)
}

// CheckRequestBeforeCounter returns a count of RequestCheckerMock.CheckRequest invocations
func (mmCheckRequest *RequestCheckerMock) CheckRequestBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCheckRequest.beforeCheckRequestCounter)
}

// Calls returns a list of arguments used in each call to RequestCheckerMock.CheckRequest.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmCheckRequest *mRequestCheckerMockCheckRequest) Calls() []*RequestCheckerMockCheckRequestParams {
	mmCheckRequest.mutex.RLock()

	argCopy := make([]*RequestCheckerMockCheckRequestParams, len(mmCheckRequest.callArgs))
	copy(argCopy, mmCheckRequest.callArgs)

	mmCheckRequest.mutex.RUnlock()

	return argCopy
}

// MinimockCheckRequestDone returns true if the count of the CheckRequest invocations corresponds
// the number of defined expectations
func (m *RequestCheckerMock) MinimockCheckRequestDone() bool {
	for _, e := range m.CheckRequestMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.CheckRequestMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterCheckRequestCounter) < 1 {
		return false
	}
	// if func was set then invocations count should be greater than zero
	if m.funcCheckRequest != nil && mm_atomic.LoadUint64(&m.afterCheckRequestCounter) < 1 {
		return false
	}
	return true
}

// MinimockCheckRequestInspect logs each unmet expectation
func (m *RequestCheckerMock) MinimockCheckRequestInspect() {
	for _, e := range m.CheckRequestMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to RequestCheckerMock.CheckRequest with params: %#v", *e.params)
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.CheckRequestMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterCheckRequestCounter) < 1 {
		if m.CheckRequestMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to RequestCheckerMock.CheckRequest")
		} else {
			m.t.Errorf("Expected call to RequestCheckerMock.CheckRequest with params: %#v", *m.CheckRequestMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcCheckRequest != nil && mm_atomic.LoadUint64(&m.afterCheckRequestCounter) < 1 {
		m.t.Error("Expected call to RequestCheckerMock.CheckRequest")
	}
}

type mRequestCheckerMockValidateRequest struct {
	mock               *RequestCheckerMock
	defaultExpectation *RequestCheckerMockValidateRequestExpectation
	expectations       []*RequestCheckerMockValidateRequestExpectation

	callArgs []*RequestCheckerMockValidateRequestParams
	mutex    sync.RWMutex
}

// RequestCheckerMockValidateRequestExpectation specifies expectation struct of the RequestChecker.ValidateRequest
type RequestCheckerMockValidateRequestExpectation struct {
	mock    *RequestCheckerMock
	params  *RequestCheckerMockValidateRequestParams
	results *RequestCheckerMockValidateRequestResults
	Counter uint64
}

// RequestCheckerMockValidateRequestParams contains parameters of the RequestChecker.ValidateRequest
type RequestCheckerMockValidateRequestParams struct {
	ctx       context.Context
	requestID insolar.ID
	request   record.Request
}

// RequestCheckerMockValidateRequestResults contains results of the RequestChecker.ValidateRequest
type RequestCheckerMockValidateRequestResults struct {
	err error
}

// Expect sets up expected params for RequestChecker.ValidateRequest
func (mmValidateRequest *mRequestCheckerMockValidateRequest) Expect(ctx context.Context, requestID insolar.ID, request record.Request) *mRequestCheckerMockValidateRequest {
	if mmValidateRequest.mock.funcValidateRequest != nil {
		mmValidateRequest.mock.t.Fatalf("RequestCheckerMock.ValidateRequest mock is already set by Set")
	}

	if mmValidateRequest.defaultExpectation == nil {
		mmValidateRequest.defaultExpectation = &RequestCheckerMockValidateRequestExpectation{}
	}

	mmValidateRequest.defaultExpectation.params = &RequestCheckerMockValidateRequestParams{ctx, requestID, request}
	for _, e := range mmValidateRequest.expectations {
		if minimock.Equal(e.params, mmValidateRequest.defaultExpectation.params) {
			mmValidateRequest.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmValidateRequest.defaultExpectation.params)
		}
	}

	return mmValidateRequest
}

// Inspect accepts an inspector function that has same arguments as the RequestChecker.ValidateRequest
func (mmValidateRequest *mRequestCheckerMockValidateRequest) Inspect(f func(ctx context.Context, requestID insolar.ID, request record.Request)) *mRequestCheckerMockValidateRequest {
	if mmValidateRequest.mock.inspectFuncValidateRequest != nil {
		mmValidateRequest.mock.t.Fatalf("Inspect function is already set for RequestCheckerMock.ValidateRequest")
	}

	mmValidateRequest.mock.inspectFuncValidateRequest = f

	return mmValidateRequest
}

// Return sets up results that will be returned by RequestChecker.ValidateRequest
func (mmValidateRequest *mRequestCheckerMockValidateRequest) Return(err error) *RequestCheckerMock {
	if mmValidateRequest.mock.funcValidateRequest != nil {
		mmValidateRequest.mock.t.Fatalf("RequestCheckerMock.ValidateRequest mock is already set by Set")
	}

	if mmValidateRequest.defaultExpectation == nil {
		mmValidateRequest.defaultExpectation = &RequestCheckerMockValidateRequestExpectation{mock: mmValidateRequest.mock}
	}
	mmValidateRequest.defaultExpectation.results = &RequestCheckerMockValidateRequestResults{err}
	return mmValidateRequest.mock
}

//Set uses given function f to mock the RequestChecker.ValidateRequest method
func (mmValidateRequest *mRequestCheckerMockValidateRequest) Set(f func(ctx context.Context, requestID insolar.ID, request record.Request) (err error)) *RequestCheckerMock {
	if mmValidateRequest.defaultExpectation != nil {
		mmValidateRequest.mock.t.Fatalf("Default expectation is already set for the RequestChecker.ValidateRequest method")
	}

	if len(mmValidateRequest.expectations) > 0 {
		mmValidateRequest.mock.t.Fatalf("Some expectations are already set for the RequestChecker.ValidateRequest method")
	}

	mmValidateRequest.mock.funcValidateRequest = f
	return mmValidateRequest.mock
}

// When sets expectation for the RequestChecker.ValidateRequest which will trigger the result defined by the following
// Then helper
func (mmValidateRequest *mRequestCheckerMockValidateRequest) When(ctx context.Context, requestID insolar.ID, request record.Request) *RequestCheckerMockValidateRequestExpectation {
	if mmValidateRequest.mock.funcValidateRequest != nil {
		mmValidateRequest.mock.t.Fatalf("RequestCheckerMock.ValidateRequest mock is already set by Set")
	}

	expectation := &RequestCheckerMockValidateRequestExpectation{
		mock:   mmValidateRequest.mock,
		params: &RequestCheckerMockValidateRequestParams{ctx, requestID, request},
	}
	mmValidateRequest.expectations = append(mmValidateRequest.expectations, expectation)
	return expectation
}

// Then sets up RequestChecker.ValidateRequest return parameters for the expectation previously defined by the When method
func (e *RequestCheckerMockValidateRequestExpectation) Then(err error) *RequestCheckerMock {
	e.results = &RequestCheckerMockValidateRequestResults{err}
	return e.mock
}

// ValidateRequest implements RequestChecker
func (mmValidateRequest *RequestCheckerMock) ValidateRequest(ctx context.Context, requestID insolar.ID, request record.Request) (err error) {
	mm_atomic.AddUint64(&mmValidateRequest.beforeValidateRequestCounter, 1)
	defer mm_atomic.AddUint64(&mmValidateRequest.afterValidateRequestCounter, 1)

	if mmValidateRequest.inspectFuncValidateRequest != nil {
		mmValidateRequest.inspectFuncValidateRequest(ctx, requestID, request)
	}

	params := &RequestCheckerMockValidateRequestParams{ctx, requestID, request}

	// Record call args
	mmValidateRequest.ValidateRequestMock.mutex.Lock()
	mmValidateRequest.ValidateRequestMock.callArgs = append(mmValidateRequest.ValidateRequestMock.callArgs, params)
	mmValidateRequest.ValidateRequestMock.mutex.Unlock()

	for _, e := range mmValidateRequest.ValidateRequestMock.expectations {
		if minimock.Equal(e.params, params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmValidateRequest.ValidateRequestMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmValidateRequest.ValidateRequestMock.defaultExpectation.Counter, 1)
		want := mmValidateRequest.ValidateRequestMock.defaultExpectation.params
		got := RequestCheckerMockValidateRequestParams{ctx, requestID, request}
		if want != nil && !minimock.Equal(*want, got) {
			mmValidateRequest.t.Errorf("RequestCheckerMock.ValidateRequest got unexpected parameters, want: %#v, got: %#v%s\n", *want, got, minimock.Diff(*want, got))
		}

		results := mmValidateRequest.ValidateRequestMock.defaultExpectation.results
		if results == nil {
			mmValidateRequest.t.Fatal("No results are set for the RequestCheckerMock.ValidateRequest")
		}
		return (*results).err
	}
	if mmValidateRequest.funcValidateRequest != nil {
		return mmValidateRequest.funcValidateRequest(ctx, requestID, request)
	}
	mmValidateRequest.t.Fatalf("Unexpected call to RequestCheckerMock.ValidateRequest. %v %v %v", ctx, requestID, request)
	return
}

// ValidateRequestAfterCounter returns a count of finished RequestCheckerMock.ValidateRequest invocations
func (mmValidateRequest *RequestCheckerMock) ValidateRequestAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmValidateRequest.afterValidateRequestCounter)
}

// ValidateRequestBeforeCounter returns a count of RequestCheckerMock.ValidateRequest invocations
func (mmValidateRequest *RequestCheckerMock) ValidateRequestBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmValidateRequest.beforeValidateRequestCounter)
}

// Calls returns a list of arguments used in each call to RequestCheckerMock.ValidateRequest.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmValidateRequest *mRequestCheckerMockValidateRequest) Calls() []*RequestCheckerMockValidateRequestParams {
	mmValidateRequest.mutex.RLock()

	argCopy := make([]*RequestCheckerMockValidateRequestParams, len(mmValidateRequest.callArgs))
	copy(argCopy, mmValidateRequest.callArgs)

	mmValidateRequest.mutex.RUnlock()

	return argCopy
}

// MinimockValidateRequestDone returns true if the count of the ValidateRequest invocations corresponds
// the number of defined expectations
func (m *RequestCheckerMock) MinimockValidateRequestDone() bool {
	for _, e := range m.ValidateRequestMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.ValidateRequestMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterValidateRequestCounter) < 1 {
		return false
	}
	// if func was set then invocations count should be greater than zero
	if m.funcValidateRequest != nil && mm_atomic.LoadUint64(&m.afterValidateRequestCounter) < 1 {
		return false
	}
	return true
}

// MinimockValidateRequestInspect logs each unmet expectation
func (m *RequestCheckerMock) MinimockValidateRequestInspect() {
	for _, e := range m.ValidateRequestMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to RequestCheckerMock.ValidateRequest with params: %#v", *e.params)
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.ValidateRequestMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterValidateRequestCounter) < 1 {
		if m.ValidateRequestMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to RequestCheckerMock.ValidateRequest")
		} else {
			m.t.Errorf("Expected call to RequestCheckerMock.ValidateRequest with params: %#v", *m.ValidateRequestMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcValidateRequest != nil && mm_atomic.LoadUint64(&m.afterValidateRequestCounter) < 1 {
		m.t.Error("Expected call to RequestCheckerMock.ValidateRequest")
	}
}

// MinimockFinish checks that all mocked methods have been called the expected number of times
func (m *RequestCheckerMock) MinimockFinish() {
	if !m.minimockDone() {
		m.MinimockCheckRequestInspect()

		m.MinimockValidateRequestInspect()
		m.t.FailNow()
	}
}

// MinimockWait waits for all mocked methods to be called the expected number of times
func (m *RequestCheckerMock) MinimockWait(timeout mm_time.Duration) {
	timeoutCh := mm_time.After(timeout)
	for {
		if m.minimockDone() {
			return
		}
		select {
		case <-timeoutCh:
			m.MinimockFinish()
			return
		case <-mm_time.After(10 * mm_time.Millisecond):
		}
	}
}

func (m *RequestCheckerMock) minimockDone() bool {
	done := true
	return done &&
		m.MinimockCheckRequestDone() &&
		m.MinimockValidateRequestDone()
}