github.com/IBM-Blockchain/fabric-operator@v1.0.4/pkg/initializer/peer/mocks/ibppeer.go

// Code generated by counterfeiter. DO NOT EDIT.
package mocks

import (
	"sync"

	"github.com/IBM-Blockchain/fabric-operator/pkg/initializer/common/config"
	initializer "github.com/IBM-Blockchain/fabric-operator/pkg/initializer/peer"
)

type IBPPeer struct {
	DeliveryClientCryptoStub        func() map[string][]byte
	deliveryClientCryptoMutex       sync.RWMutex
	deliveryClientCryptoArgsForCall []struct {
	}
	deliveryClientCryptoReturns struct {
		result1 map[string][]byte
	}
	deliveryClientCryptoReturnsOnCall map[int]struct {
		result1 map[string][]byte
	}
	GenerateCryptoStub        func() (*config.CryptoResponse, error)
	generateCryptoMutex       sync.RWMutex
	generateCryptoArgsForCall []struct {
	}
	generateCryptoReturns struct {
		result1 *config.CryptoResponse
		result2 error
	}
	generateCryptoReturnsOnCall map[int]struct {
		result1 *config.CryptoResponse
		result2 error
	}
	GetConfigStub        func() initializer.CoreConfig
	getConfigMutex       sync.RWMutex
	getConfigArgsForCall []struct {
	}
	getConfigReturns struct {
		result1 initializer.CoreConfig
	}
	getConfigReturnsOnCall map[int]struct {
		result1 initializer.CoreConfig
	}
	OverrideConfigStub        func(initializer.CoreConfig) error
	overrideConfigMutex       sync.RWMutex
	overrideConfigArgsForCall []struct {
		arg1 initializer.CoreConfig
	}
	overrideConfigReturns struct {
		result1 error
	}
	overrideConfigReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *IBPPeer) DeliveryClientCrypto() map[string][]byte {
	fake.deliveryClientCryptoMutex.Lock()
	ret, specificReturn := fake.deliveryClientCryptoReturnsOnCall[len(fake.deliveryClientCryptoArgsForCall)]
	fake.deliveryClientCryptoArgsForCall = append(fake.deliveryClientCryptoArgsForCall, struct {
	}{})
	stub := fake.DeliveryClientCryptoStub
	fakeReturns := fake.deliveryClientCryptoReturns
	fake.recordInvocation("DeliveryClientCrypto", []interface{}{})
	fake.deliveryClientCryptoMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *IBPPeer) DeliveryClientCryptoCallCount() int {
	fake.deliveryClientCryptoMutex.RLock()
	defer fake.deliveryClientCryptoMutex.RUnlock()
	return len(fake.deliveryClientCryptoArgsForCall)
}

func (fake *IBPPeer) DeliveryClientCryptoCalls(stub func() map[string][]byte) {
	fake.deliveryClientCryptoMutex.Lock()
	defer fake.deliveryClientCryptoMutex.Unlock()
	fake.DeliveryClientCryptoStub = stub
}

func (fake *IBPPeer) DeliveryClientCryptoReturns(result1 map[string][]byte) {
	fake.deliveryClientCryptoMutex.Lock()
	defer fake.deliveryClientCryptoMutex.Unlock()
	fake.DeliveryClientCryptoStub = nil
	fake.deliveryClientCryptoReturns = struct {
		result1 map[string][]byte
	}{result1}
}

func (fake *IBPPeer) DeliveryClientCryptoReturnsOnCall(i int, result1 map[string][]byte) {
	fake.deliveryClientCryptoMutex.Lock()
	defer fake.deliveryClientCryptoMutex.Unlock()
	fake.DeliveryClientCryptoStub = nil
	if fake.deliveryClientCryptoReturnsOnCall == nil {
		fake.deliveryClientCryptoReturnsOnCall = make(map[int]struct {
			result1 map[string][]byte
		})
	}
	fake.deliveryClientCryptoReturnsOnCall[i] = struct {
		result1 map[string][]byte
	}{result1}
}

func (fake *IBPPeer) GenerateCrypto() (*config.CryptoResponse, error) {
	fake.generateCryptoMutex.Lock()
	ret, specificReturn := fake.generateCryptoReturnsOnCall[len(fake.generateCryptoArgsForCall)]
	fake.generateCryptoArgsForCall = append(fake.generateCryptoArgsForCall, struct {
	}{})
	stub := fake.GenerateCryptoStub
	fakeReturns := fake.generateCryptoReturns
	fake.recordInvocation("GenerateCrypto", []interface{}{})
	fake.generateCryptoMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *IBPPeer) GenerateCryptoCallCount() int {
	fake.generateCryptoMutex.RLock()
	defer fake.generateCryptoMutex.RUnlock()
	return len(fake.generateCryptoArgsForCall)
}

func (fake *IBPPeer) GenerateCryptoCalls(stub func() (*config.CryptoResponse, error)) {
	fake.generateCryptoMutex.Lock()
	defer fake.generateCryptoMutex.Unlock()
	fake.GenerateCryptoStub = stub
}

func (fake *IBPPeer) GenerateCryptoReturns(result1 *config.CryptoResponse, result2 error) {
	fake.generateCryptoMutex.Lock()
	defer fake.generateCryptoMutex.Unlock()
	fake.GenerateCryptoStub = nil
	fake.generateCryptoReturns = struct {
		result1 *config.CryptoResponse
		result2 error
	}{result1, result2}
}

func (fake *IBPPeer) GenerateCryptoReturnsOnCall(i int, result1 *config.CryptoResponse, result2 error) {
	fake.generateCryptoMutex.Lock()
	defer fake.generateCryptoMutex.Unlock()
	fake.GenerateCryptoStub = nil
	if fake.generateCryptoReturnsOnCall == nil {
		fake.generateCryptoReturnsOnCall = make(map[int]struct {
			result1 *config.CryptoResponse
			result2 error
		})
	}
	fake.generateCryptoReturnsOnCall[i] = struct {
		result1 *config.CryptoResponse
		result2 error
	}{result1, result2}
}

func (fake *IBPPeer) GetConfig() initializer.CoreConfig {
	fake.getConfigMutex.Lock()
	ret, specificReturn := fake.getConfigReturnsOnCall[len(fake.getConfigArgsForCall)]
	fake.getConfigArgsForCall = append(fake.getConfigArgsForCall, struct {
	}{})
	stub := fake.GetConfigStub
	fakeReturns := fake.getConfigReturns
	fake.recordInvocation("GetConfig", []interface{}{})
	fake.getConfigMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *IBPPeer) GetConfigCallCount() int {
	fake.getConfigMutex.RLock()
	defer fake.getConfigMutex.RUnlock()
	return len(fake.getConfigArgsForCall)
}

func (fake *IBPPeer) GetConfigCalls(stub func() initializer.CoreConfig) {
	fake.getConfigMutex.Lock()
	defer fake.getConfigMutex.Unlock()
	fake.GetConfigStub = stub
}

func (fake *IBPPeer) GetConfigReturns(result1 initializer.CoreConfig) {
	fake.getConfigMutex.Lock()
	defer fake.getConfigMutex.Unlock()
	fake.GetConfigStub = nil
	fake.getConfigReturns = struct {
		result1 initializer.CoreConfig
	}{result1}
}

func (fake *IBPPeer) GetConfigReturnsOnCall(i int, result1 initializer.CoreConfig) {
	fake.getConfigMutex.Lock()
	defer fake.getConfigMutex.Unlock()
	fake.GetConfigStub = nil
	if fake.getConfigReturnsOnCall == nil {
		fake.getConfigReturnsOnCall = make(map[int]struct {
			result1 initializer.CoreConfig
		})
	}
	fake.getConfigReturnsOnCall[i] = struct {
		result1 initializer.CoreConfig
	}{result1}
}

func (fake *IBPPeer) OverrideConfig(arg1 initializer.CoreConfig) error {
	fake.overrideConfigMutex.Lock()
	ret, specificReturn := fake.overrideConfigReturnsOnCall[len(fake.overrideConfigArgsForCall)]
	fake.overrideConfigArgsForCall = append(fake.overrideConfigArgsForCall, struct {
		arg1 initializer.CoreConfig
	}{arg1})
	stub := fake.OverrideConfigStub
	fakeReturns := fake.overrideConfigReturns
	fake.recordInvocation("OverrideConfig", []interface{}{arg1})
	fake.overrideConfigMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *IBPPeer) OverrideConfigCallCount() int {
	fake.overrideConfigMutex.RLock()
	defer fake.overrideConfigMutex.RUnlock()
	return len(fake.overrideConfigArgsForCall)
}

func (fake *IBPPeer) OverrideConfigCalls(stub func(initializer.CoreConfig) error) {
	fake.overrideConfigMutex.Lock()
	defer fake.overrideConfigMutex.Unlock()
	fake.OverrideConfigStub = stub
}

func (fake *IBPPeer) OverrideConfigArgsForCall(i int) initializer.CoreConfig {
	fake.overrideConfigMutex.RLock()
	defer fake.overrideConfigMutex.RUnlock()
	argsForCall := fake.overrideConfigArgsForCall[i]
	return argsForCall.arg1
}

func (fake *IBPPeer) OverrideConfigReturns(result1 error) {
	fake.overrideConfigMutex.Lock()
	defer fake.overrideConfigMutex.Unlock()
	fake.OverrideConfigStub = nil
	fake.overrideConfigReturns = struct {
		result1 error
	}{result1}
}

func (fake *IBPPeer) OverrideConfigReturnsOnCall(i int, result1 error) {
	fake.overrideConfigMutex.Lock()
	defer fake.overrideConfigMutex.Unlock()
	fake.OverrideConfigStub = nil
	if fake.overrideConfigReturnsOnCall == nil {
		fake.overrideConfigReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.overrideConfigReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *IBPPeer) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.deliveryClientCryptoMutex.RLock()
	defer fake.deliveryClientCryptoMutex.RUnlock()
	fake.generateCryptoMutex.RLock()
	defer fake.generateCryptoMutex.RUnlock()
	fake.getConfigMutex.RLock()
	defer fake.getConfigMutex.RUnlock()
	fake.overrideConfigMutex.RLock()
	defer fake.overrideConfigMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *IBPPeer) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ initializer.IBPPeer = new(IBPPeer)