accessor_mock.go

package drop

// 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"
)

// AccessorMock implements Accessor
type AccessorMock struct {
	t minimock.Tester

	funcForPulse          func(ctx context.Context, jetID insolar.JetID, pulse insolar.PulseNumber) (d1 Drop, err error)
	inspectFuncForPulse   func(ctx context.Context, jetID insolar.JetID, pulse insolar.PulseNumber)
	afterForPulseCounter  uint64
	beforeForPulseCounter uint64
	ForPulseMock          mAccessorMockForPulse
}

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

	m.ForPulseMock = mAccessorMockForPulse{mock: m}
	m.ForPulseMock.callArgs = []*AccessorMockForPulseParams{}

	return m
}

type mAccessorMockForPulse struct {
	mock               *AccessorMock
	defaultExpectation *AccessorMockForPulseExpectation
	expectations       []*AccessorMockForPulseExpectation

	callArgs []*AccessorMockForPulseParams
	mutex    sync.RWMutex
}

// AccessorMockForPulseExpectation specifies expectation struct of the Accessor.ForPulse
type AccessorMockForPulseExpectation struct {
	mock    *AccessorMock
	params  *AccessorMockForPulseParams
	results *AccessorMockForPulseResults
	Counter uint64
}

// AccessorMockForPulseParams contains parameters of the Accessor.ForPulse
type AccessorMockForPulseParams struct {
	ctx   context.Context
	jetID insolar.JetID
	pulse insolar.PulseNumber
}

// AccessorMockForPulseResults contains results of the Accessor.ForPulse
type AccessorMockForPulseResults struct {
	d1  Drop
	err error
}

// Expect sets up expected params for Accessor.ForPulse
func (mmForPulse *mAccessorMockForPulse) Expect(ctx context.Context, jetID insolar.JetID, pulse insolar.PulseNumber) *mAccessorMockForPulse {
	if mmForPulse.mock.funcForPulse != nil {
		mmForPulse.mock.t.Fatalf("AccessorMock.ForPulse mock is already set by Set")
	}

	if mmForPulse.defaultExpectation == nil {
		mmForPulse.defaultExpectation = &AccessorMockForPulseExpectation{}
	}

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

	return mmForPulse
}

// Inspect accepts an inspector function that has same arguments as the Accessor.ForPulse
func (mmForPulse *mAccessorMockForPulse) Inspect(f func(ctx context.Context, jetID insolar.JetID, pulse insolar.PulseNumber)) *mAccessorMockForPulse {
	if mmForPulse.mock.inspectFuncForPulse != nil {
		mmForPulse.mock.t.Fatalf("Inspect function is already set for AccessorMock.ForPulse")
	}

	mmForPulse.mock.inspectFuncForPulse = f

	return mmForPulse
}

// Return sets up results that will be returned by Accessor.ForPulse
func (mmForPulse *mAccessorMockForPulse) Return(d1 Drop, err error) *AccessorMock {
	if mmForPulse.mock.funcForPulse != nil {
		mmForPulse.mock.t.Fatalf("AccessorMock.ForPulse mock is already set by Set")
	}

	if mmForPulse.defaultExpectation == nil {
		mmForPulse.defaultExpectation = &AccessorMockForPulseExpectation{mock: mmForPulse.mock}
	}
	mmForPulse.defaultExpectation.results = &AccessorMockForPulseResults{d1, err}
	return mmForPulse.mock
}

//Set uses given function f to mock the Accessor.ForPulse method
func (mmForPulse *mAccessorMockForPulse) Set(f func(ctx context.Context, jetID insolar.JetID, pulse insolar.PulseNumber) (d1 Drop, err error)) *AccessorMock {
	if mmForPulse.defaultExpectation != nil {
		mmForPulse.mock.t.Fatalf("Default expectation is already set for the Accessor.ForPulse method")
	}

	if len(mmForPulse.expectations) > 0 {
		mmForPulse.mock.t.Fatalf("Some expectations are already set for the Accessor.ForPulse method")
	}

	mmForPulse.mock.funcForPulse = f
	return mmForPulse.mock
}

// When sets expectation for the Accessor.ForPulse which will trigger the result defined by the following
// Then helper
func (mmForPulse *mAccessorMockForPulse) When(ctx context.Context, jetID insolar.JetID, pulse insolar.PulseNumber) *AccessorMockForPulseExpectation {
	if mmForPulse.mock.funcForPulse != nil {
		mmForPulse.mock.t.Fatalf("AccessorMock.ForPulse mock is already set by Set")
	}

	expectation := &AccessorMockForPulseExpectation{
		mock:   mmForPulse.mock,
		params: &AccessorMockForPulseParams{ctx, jetID, pulse},
	}
	mmForPulse.expectations = append(mmForPulse.expectations, expectation)
	return expectation
}

// Then sets up Accessor.ForPulse return parameters for the expectation previously defined by the When method
func (e *AccessorMockForPulseExpectation) Then(d1 Drop, err error) *AccessorMock {
	e.results = &AccessorMockForPulseResults{d1, err}
	return e.mock
}

// ForPulse implements Accessor
func (mmForPulse *AccessorMock) ForPulse(ctx context.Context, jetID insolar.JetID, pulse insolar.PulseNumber) (d1 Drop, err error) {
	mm_atomic.AddUint64(&mmForPulse.beforeForPulseCounter, 1)
	defer mm_atomic.AddUint64(&mmForPulse.afterForPulseCounter, 1)

	if mmForPulse.inspectFuncForPulse != nil {
		mmForPulse.inspectFuncForPulse(ctx, jetID, pulse)
	}

	params := &AccessorMockForPulseParams{ctx, jetID, pulse}

	// Record call args
	mmForPulse.ForPulseMock.mutex.Lock()
	mmForPulse.ForPulseMock.callArgs = append(mmForPulse.ForPulseMock.callArgs, params)
	mmForPulse.ForPulseMock.mutex.Unlock()

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

	if mmForPulse.ForPulseMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmForPulse.ForPulseMock.defaultExpectation.Counter, 1)
		want := mmForPulse.ForPulseMock.defaultExpectation.params
		got := AccessorMockForPulseParams{ctx, jetID, pulse}
		if want != nil && !minimock.Equal(*want, got) {
			mmForPulse.t.Errorf("AccessorMock.ForPulse got unexpected parameters, want: %#v, got: %#v%s\n", *want, got, minimock.Diff(*want, got))
		}

		results := mmForPulse.ForPulseMock.defaultExpectation.results
		if results == nil {
			mmForPulse.t.Fatal("No results are set for the AccessorMock.ForPulse")
		}
		return (*results).d1, (*results).err
	}
	if mmForPulse.funcForPulse != nil {
		return mmForPulse.funcForPulse(ctx, jetID, pulse)
	}
	mmForPulse.t.Fatalf("Unexpected call to AccessorMock.ForPulse. %v %v %v", ctx, jetID, pulse)
	return
}

// ForPulseAfterCounter returns a count of finished AccessorMock.ForPulse invocations
func (mmForPulse *AccessorMock) ForPulseAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmForPulse.afterForPulseCounter)
}

// ForPulseBeforeCounter returns a count of AccessorMock.ForPulse invocations
func (mmForPulse *AccessorMock) ForPulseBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmForPulse.beforeForPulseCounter)
}

// Calls returns a list of arguments used in each call to AccessorMock.ForPulse.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmForPulse *mAccessorMockForPulse) Calls() []*AccessorMockForPulseParams {
	mmForPulse.mutex.RLock()

	argCopy := make([]*AccessorMockForPulseParams, len(mmForPulse.callArgs))
	copy(argCopy, mmForPulse.callArgs)

	mmForPulse.mutex.RUnlock()

	return argCopy
}

// MinimockForPulseDone returns true if the count of the ForPulse invocations corresponds
// the number of defined expectations
func (m *AccessorMock) MinimockForPulseDone() bool {
	for _, e := range m.ForPulseMock.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.ForPulseMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterForPulseCounter) < 1 {
		return false
	}
	// if func was set then invocations count should be greater than zero
	if m.funcForPulse != nil && mm_atomic.LoadUint64(&m.afterForPulseCounter) < 1 {
		return false
	}
	return true
}

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

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

// MinimockFinish checks that all mocked methods have been called the expected number of times
func (m *AccessorMock) MinimockFinish() {
	if !m.minimockDone() {
		m.MinimockForPulseInspect()
		m.t.FailNow()
	}
}

// MinimockWait waits for all mocked methods to be called the expected number of times
func (m *AccessorMock) 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 *AccessorMock) minimockDone() bool {
	done := true
	return done &&
		m.MinimockForPulseDone()
}