decrypter_mock.go

package crypt

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

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

	"github.com/gojuno/minimock/v3"
)

// DecrypterMock implements Decrypter
type DecrypterMock struct {
	t minimock.Tester

	funcDecrypt          func(encrypted []byte) (ba1 []byte, err error)
	inspectFuncDecrypt   func(encrypted []byte)
	afterDecryptCounter  uint64
	beforeDecryptCounter uint64
	DecryptMock          mDecrypterMockDecrypt
}

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

	m.DecryptMock = mDecrypterMockDecrypt{mock: m}
	m.DecryptMock.callArgs = []*DecrypterMockDecryptParams{}

	return m
}

type mDecrypterMockDecrypt struct {
	mock               *DecrypterMock
	defaultExpectation *DecrypterMockDecryptExpectation
	expectations       []*DecrypterMockDecryptExpectation

	callArgs []*DecrypterMockDecryptParams
	mutex    sync.RWMutex
}

// DecrypterMockDecryptExpectation specifies expectation struct of the Decrypter.Decrypt
type DecrypterMockDecryptExpectation struct {
	mock    *DecrypterMock
	params  *DecrypterMockDecryptParams
	results *DecrypterMockDecryptResults
	Counter uint64
}

// DecrypterMockDecryptParams contains parameters of the Decrypter.Decrypt
type DecrypterMockDecryptParams struct {
	encrypted []byte
}

// DecrypterMockDecryptResults contains results of the Decrypter.Decrypt
type DecrypterMockDecryptResults struct {
	ba1 []byte
	err error
}

// Expect sets up expected params for Decrypter.Decrypt
func (mmDecrypt *mDecrypterMockDecrypt) Expect(encrypted []byte) *mDecrypterMockDecrypt {
	if mmDecrypt.mock.funcDecrypt != nil {
		mmDecrypt.mock.t.Fatalf("DecrypterMock.Decrypt mock is already set by Set")
	}

	if mmDecrypt.defaultExpectation == nil {
		mmDecrypt.defaultExpectation = &DecrypterMockDecryptExpectation{}
	}

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

	return mmDecrypt
}

// Inspect accepts an inspector function that has same arguments as the Decrypter.Decrypt
func (mmDecrypt *mDecrypterMockDecrypt) Inspect(f func(encrypted []byte)) *mDecrypterMockDecrypt {
	if mmDecrypt.mock.inspectFuncDecrypt != nil {
		mmDecrypt.mock.t.Fatalf("Inspect function is already set for DecrypterMock.Decrypt")
	}

	mmDecrypt.mock.inspectFuncDecrypt = f

	return mmDecrypt
}

// Return sets up results that will be returned by Decrypter.Decrypt
func (mmDecrypt *mDecrypterMockDecrypt) Return(ba1 []byte, err error) *DecrypterMock {
	if mmDecrypt.mock.funcDecrypt != nil {
		mmDecrypt.mock.t.Fatalf("DecrypterMock.Decrypt mock is already set by Set")
	}

	if mmDecrypt.defaultExpectation == nil {
		mmDecrypt.defaultExpectation = &DecrypterMockDecryptExpectation{mock: mmDecrypt.mock}
	}
	mmDecrypt.defaultExpectation.results = &DecrypterMockDecryptResults{ba1, err}
	return mmDecrypt.mock
}

//Set uses given function f to mock the Decrypter.Decrypt method
func (mmDecrypt *mDecrypterMockDecrypt) Set(f func(encrypted []byte) (ba1 []byte, err error)) *DecrypterMock {
	if mmDecrypt.defaultExpectation != nil {
		mmDecrypt.mock.t.Fatalf("Default expectation is already set for the Decrypter.Decrypt method")
	}

	if len(mmDecrypt.expectations) > 0 {
		mmDecrypt.mock.t.Fatalf("Some expectations are already set for the Decrypter.Decrypt method")
	}

	mmDecrypt.mock.funcDecrypt = f
	return mmDecrypt.mock
}

// When sets expectation for the Decrypter.Decrypt which will trigger the result defined by the following
// Then helper
func (mmDecrypt *mDecrypterMockDecrypt) When(encrypted []byte) *DecrypterMockDecryptExpectation {
	if mmDecrypt.mock.funcDecrypt != nil {
		mmDecrypt.mock.t.Fatalf("DecrypterMock.Decrypt mock is already set by Set")
	}

	expectation := &DecrypterMockDecryptExpectation{
		mock:   mmDecrypt.mock,
		params: &DecrypterMockDecryptParams{encrypted},
	}
	mmDecrypt.expectations = append(mmDecrypt.expectations, expectation)
	return expectation
}

// Then sets up Decrypter.Decrypt return parameters for the expectation previously defined by the When method
func (e *DecrypterMockDecryptExpectation) Then(ba1 []byte, err error) *DecrypterMock {
	e.results = &DecrypterMockDecryptResults{ba1, err}
	return e.mock
}

// Decrypt implements Decrypter
func (mmDecrypt *DecrypterMock) Decrypt(encrypted []byte) (ba1 []byte, err error) {
	mm_atomic.AddUint64(&mmDecrypt.beforeDecryptCounter, 1)
	defer mm_atomic.AddUint64(&mmDecrypt.afterDecryptCounter, 1)

	if mmDecrypt.inspectFuncDecrypt != nil {
		mmDecrypt.inspectFuncDecrypt(encrypted)
	}

	mm_params := &DecrypterMockDecryptParams{encrypted}

	// Record call args
	mmDecrypt.DecryptMock.mutex.Lock()
	mmDecrypt.DecryptMock.callArgs = append(mmDecrypt.DecryptMock.callArgs, mm_params)
	mmDecrypt.DecryptMock.mutex.Unlock()

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

	if mmDecrypt.DecryptMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmDecrypt.DecryptMock.defaultExpectation.Counter, 1)
		mm_want := mmDecrypt.DecryptMock.defaultExpectation.params
		mm_got := DecrypterMockDecryptParams{encrypted}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmDecrypt.t.Errorf("DecrypterMock.Decrypt got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmDecrypt.DecryptMock.defaultExpectation.results
		if mm_results == nil {
			mmDecrypt.t.Fatal("No results are set for the DecrypterMock.Decrypt")
		}
		return (*mm_results).ba1, (*mm_results).err
	}
	if mmDecrypt.funcDecrypt != nil {
		return mmDecrypt.funcDecrypt(encrypted)
	}
	mmDecrypt.t.Fatalf("Unexpected call to DecrypterMock.Decrypt. %v", encrypted)
	return
}

// DecryptAfterCounter returns a count of finished DecrypterMock.Decrypt invocations
func (mmDecrypt *DecrypterMock) DecryptAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDecrypt.afterDecryptCounter)
}

// DecryptBeforeCounter returns a count of DecrypterMock.Decrypt invocations
func (mmDecrypt *DecrypterMock) DecryptBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDecrypt.beforeDecryptCounter)
}

// Calls returns a list of arguments used in each call to DecrypterMock.Decrypt.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmDecrypt *mDecrypterMockDecrypt) Calls() []*DecrypterMockDecryptParams {
	mmDecrypt.mutex.RLock()

	argCopy := make([]*DecrypterMockDecryptParams, len(mmDecrypt.callArgs))
	copy(argCopy, mmDecrypt.callArgs)

	mmDecrypt.mutex.RUnlock()

	return argCopy
}

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

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

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

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

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