resmgmt.gen.go

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

import (
	"sync"

	"github.com/hyperledger/fabric-cli/pkg/fabric"
	"github.com/hyperledger/fabric-protos-go/common"
	pb "github.com/hyperledger/fabric-protos-go/peer"
	"github.com/hyperledger/fabric-sdk-go/pkg/client/resmgmt"
	"github.com/hyperledger/fabric-sdk-go/pkg/common/providers/fab"
	mspctx "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/msp"
	"github.com/hyperledger/fabric-sdk-go/pkg/fab/resource"
)

type ResMgmt struct {
	CreateConfigSignatureStub        func(signer mspctx.SigningIdentity, channelConfigPath string) (*common.ConfigSignature, error)
	createConfigSignatureMutex       sync.RWMutex
	createConfigSignatureArgsForCall []struct {
		signer            mspctx.SigningIdentity
		channelConfigPath string
	}
	createConfigSignatureReturns struct {
		result1 *common.ConfigSignature
		result2 error
	}
	createConfigSignatureReturnsOnCall map[int]struct {
		result1 *common.ConfigSignature
		result2 error
	}
	CreateConfigSignatureDataStub        func(signer mspctx.SigningIdentity, channelConfigPath string) (signatureHeaderData resource.ConfigSignatureData, e error)
	createConfigSignatureDataMutex       sync.RWMutex
	createConfigSignatureDataArgsForCall []struct {
		signer            mspctx.SigningIdentity
		channelConfigPath string
	}
	createConfigSignatureDataReturns struct {
		result1 resource.ConfigSignatureData
		result2 error
	}
	createConfigSignatureDataReturnsOnCall map[int]struct {
		result1 resource.ConfigSignatureData
		result2 error
	}
	InstallCCStub        func(req resmgmt.InstallCCRequest, options ...resmgmt.RequestOption) ([]resmgmt.InstallCCResponse, error)
	installCCMutex       sync.RWMutex
	installCCArgsForCall []struct {
		req     resmgmt.InstallCCRequest
		options []resmgmt.RequestOption
	}
	installCCReturns struct {
		result1 []resmgmt.InstallCCResponse
		result2 error
	}
	installCCReturnsOnCall map[int]struct {
		result1 []resmgmt.InstallCCResponse
		result2 error
	}
	InstantiateCCStub        func(channelID string, req resmgmt.InstantiateCCRequest, options ...resmgmt.RequestOption) (resmgmt.InstantiateCCResponse, error)
	instantiateCCMutex       sync.RWMutex
	instantiateCCArgsForCall []struct {
		channelID string
		req       resmgmt.InstantiateCCRequest
		options   []resmgmt.RequestOption
	}
	instantiateCCReturns struct {
		result1 resmgmt.InstantiateCCResponse
		result2 error
	}
	instantiateCCReturnsOnCall map[int]struct {
		result1 resmgmt.InstantiateCCResponse
		result2 error
	}
	JoinChannelStub        func(channelID string, options ...resmgmt.RequestOption) error
	joinChannelMutex       sync.RWMutex
	joinChannelArgsForCall []struct {
		channelID string
		options   []resmgmt.RequestOption
	}
	joinChannelReturns struct {
		result1 error
	}
	joinChannelReturnsOnCall map[int]struct {
		result1 error
	}
	QueryChannelsStub        func(options ...resmgmt.RequestOption) (*pb.ChannelQueryResponse, error)
	queryChannelsMutex       sync.RWMutex
	queryChannelsArgsForCall []struct {
		options []resmgmt.RequestOption
	}
	queryChannelsReturns struct {
		result1 *pb.ChannelQueryResponse
		result2 error
	}
	queryChannelsReturnsOnCall map[int]struct {
		result1 *pb.ChannelQueryResponse
		result2 error
	}
	QueryCollectionsConfigStub        func(channelID string, chaincodeName string, options ...resmgmt.RequestOption) (*pb.CollectionConfigPackage, error)
	queryCollectionsConfigMutex       sync.RWMutex
	queryCollectionsConfigArgsForCall []struct {
		channelID     string
		chaincodeName string
		options       []resmgmt.RequestOption
	}
	queryCollectionsConfigReturns struct {
		result1 *pb.CollectionConfigPackage
		result2 error
	}
	queryCollectionsConfigReturnsOnCall map[int]struct {
		result1 *pb.CollectionConfigPackage
		result2 error
	}
	QueryConfigFromOrdererStub        func(channelID string, options ...resmgmt.RequestOption) (fab.ChannelCfg, error)
	queryConfigFromOrdererMutex       sync.RWMutex
	queryConfigFromOrdererArgsForCall []struct {
		channelID string
		options   []resmgmt.RequestOption
	}
	queryConfigFromOrdererReturns struct {
		result1 fab.ChannelCfg
		result2 error
	}
	queryConfigFromOrdererReturnsOnCall map[int]struct {
		result1 fab.ChannelCfg
		result2 error
	}
	QueryInstalledChaincodesStub        func(options ...resmgmt.RequestOption) (*pb.ChaincodeQueryResponse, error)
	queryInstalledChaincodesMutex       sync.RWMutex
	queryInstalledChaincodesArgsForCall []struct {
		options []resmgmt.RequestOption
	}
	queryInstalledChaincodesReturns struct {
		result1 *pb.ChaincodeQueryResponse
		result2 error
	}
	queryInstalledChaincodesReturnsOnCall map[int]struct {
		result1 *pb.ChaincodeQueryResponse
		result2 error
	}
	QueryInstantiatedChaincodesStub        func(channelID string, options ...resmgmt.RequestOption) (*pb.ChaincodeQueryResponse, error)
	queryInstantiatedChaincodesMutex       sync.RWMutex
	queryInstantiatedChaincodesArgsForCall []struct {
		channelID string
		options   []resmgmt.RequestOption
	}
	queryInstantiatedChaincodesReturns struct {
		result1 *pb.ChaincodeQueryResponse
		result2 error
	}
	queryInstantiatedChaincodesReturnsOnCall map[int]struct {
		result1 *pb.ChaincodeQueryResponse
		result2 error
	}
	SaveChannelStub        func(req resmgmt.SaveChannelRequest, options ...resmgmt.RequestOption) (resmgmt.SaveChannelResponse, error)
	saveChannelMutex       sync.RWMutex
	saveChannelArgsForCall []struct {
		req     resmgmt.SaveChannelRequest
		options []resmgmt.RequestOption
	}
	saveChannelReturns struct {
		result1 resmgmt.SaveChannelResponse
		result2 error
	}
	saveChannelReturnsOnCall map[int]struct {
		result1 resmgmt.SaveChannelResponse
		result2 error
	}
	UpgradeCCStub        func(channelID string, req resmgmt.UpgradeCCRequest, options ...resmgmt.RequestOption) (resmgmt.UpgradeCCResponse, error)
	upgradeCCMutex       sync.RWMutex
	upgradeCCArgsForCall []struct {
		channelID string
		req       resmgmt.UpgradeCCRequest
		options   []resmgmt.RequestOption
	}
	upgradeCCReturns struct {
		result1 resmgmt.UpgradeCCResponse
		result2 error
	}
	upgradeCCReturnsOnCall map[int]struct {
		result1 resmgmt.UpgradeCCResponse
		result2 error
	}
	LifecycleInstallCCStub        func(req resmgmt.LifecycleInstallCCRequest, options ...resmgmt.RequestOption) ([]resmgmt.LifecycleInstallCCResponse, error)
	lifecycleInstallCCMutex       sync.RWMutex
	lifecycleInstallCCArgsForCall []struct {
		req     resmgmt.LifecycleInstallCCRequest
		options []resmgmt.RequestOption
	}
	lifecycleInstallCCReturns struct {
		result1 []resmgmt.LifecycleInstallCCResponse
		result2 error
	}
	lifecycleInstallCCReturnsOnCall map[int]struct {
		result1 []resmgmt.LifecycleInstallCCResponse
		result2 error
	}
	LifecycleApproveCCStub        func(channelID string, req resmgmt.LifecycleApproveCCRequest, options ...resmgmt.RequestOption) (fab.TransactionID, error)
	lifecycleApproveCCMutex       sync.RWMutex
	lifecycleApproveCCArgsForCall []struct {
		channelID string
		req       resmgmt.LifecycleApproveCCRequest
		options   []resmgmt.RequestOption
	}
	lifecycleApproveCCReturns struct {
		result1 fab.TransactionID
		result2 error
	}
	lifecycleApproveCCReturnsOnCall map[int]struct {
		result1 fab.TransactionID
		result2 error
	}
	LifecycleCommitCCStub        func(channelID string, req resmgmt.LifecycleCommitCCRequest, options ...resmgmt.RequestOption) (fab.TransactionID, error)
	lifecycleCommitCCMutex       sync.RWMutex
	lifecycleCommitCCArgsForCall []struct {
		channelID string
		req       resmgmt.LifecycleCommitCCRequest
		options   []resmgmt.RequestOption
	}
	lifecycleCommitCCReturns struct {
		result1 fab.TransactionID
		result2 error
	}
	lifecycleCommitCCReturnsOnCall map[int]struct {
		result1 fab.TransactionID
		result2 error
	}
	LifecycleQueryInstalledCCStub        func(options ...resmgmt.RequestOption) ([]resmgmt.LifecycleInstalledCC, error)
	lifecycleQueryInstalledCCMutex       sync.RWMutex
	lifecycleQueryInstalledCCArgsForCall []struct {
		options []resmgmt.RequestOption
	}
	lifecycleQueryInstalledCCReturns struct {
		result1 []resmgmt.LifecycleInstalledCC
		result2 error
	}
	lifecycleQueryInstalledCCReturnsOnCall map[int]struct {
		result1 []resmgmt.LifecycleInstalledCC
		result2 error
	}
	LifecycleGetInstalledCCPackageStub        func(packageID string, options ...resmgmt.RequestOption) ([]byte, error)
	lifecycleGetInstalledCCPackageMutex       sync.RWMutex
	lifecycleGetInstalledCCPackageArgsForCall []struct {
		packageID string
		options   []resmgmt.RequestOption
	}
	lifecycleGetInstalledCCPackageReturns struct {
		result1 []byte
		result2 error
	}
	lifecycleGetInstalledCCPackageReturnsOnCall map[int]struct {
		result1 []byte
		result2 error
	}
	LifecycleQueryApprovedCCStub        func(channelID string, req resmgmt.LifecycleQueryApprovedCCRequest, options ...resmgmt.RequestOption) (resmgmt.LifecycleApprovedChaincodeDefinition, error)
	lifecycleQueryApprovedCCMutex       sync.RWMutex
	lifecycleQueryApprovedCCArgsForCall []struct {
		channelID string
		req       resmgmt.LifecycleQueryApprovedCCRequest
		options   []resmgmt.RequestOption
	}
	lifecycleQueryApprovedCCReturns struct {
		result1 resmgmt.LifecycleApprovedChaincodeDefinition
		result2 error
	}
	lifecycleQueryApprovedCCReturnsOnCall map[int]struct {
		result1 resmgmt.LifecycleApprovedChaincodeDefinition
		result2 error
	}
	LifecycleCheckCCCommitReadinessStub        func(channelID string, req resmgmt.LifecycleCheckCCCommitReadinessRequest, options ...resmgmt.RequestOption) (resmgmt.LifecycleCheckCCCommitReadinessResponse, error)
	lifecycleCheckCCCommitReadinessMutex       sync.RWMutex
	lifecycleCheckCCCommitReadinessArgsForCall []struct {
		channelID string
		req       resmgmt.LifecycleCheckCCCommitReadinessRequest
		options   []resmgmt.RequestOption
	}
	lifecycleCheckCCCommitReadinessReturns struct {
		result1 resmgmt.LifecycleCheckCCCommitReadinessResponse
		result2 error
	}
	lifecycleCheckCCCommitReadinessReturnsOnCall map[int]struct {
		result1 resmgmt.LifecycleCheckCCCommitReadinessResponse
		result2 error
	}
	LifecycleQueryCommittedCCStub        func(channelID string, req resmgmt.LifecycleQueryCommittedCCRequest, options ...resmgmt.RequestOption) ([]resmgmt.LifecycleChaincodeDefinition, error)
	lifecycleQueryCommittedCCMutex       sync.RWMutex
	lifecycleQueryCommittedCCArgsForCall []struct {
		channelID string
		req       resmgmt.LifecycleQueryCommittedCCRequest
		options   []resmgmt.RequestOption
	}
	lifecycleQueryCommittedCCReturns struct {
		result1 []resmgmt.LifecycleChaincodeDefinition
		result2 error
	}
	lifecycleQueryCommittedCCReturnsOnCall map[int]struct {
		result1 []resmgmt.LifecycleChaincodeDefinition
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *ResMgmt) CreateConfigSignature(signer mspctx.SigningIdentity, channelConfigPath string) (*common.ConfigSignature, error) {
	fake.createConfigSignatureMutex.Lock()
	ret, specificReturn := fake.createConfigSignatureReturnsOnCall[len(fake.createConfigSignatureArgsForCall)]
	fake.createConfigSignatureArgsForCall = append(fake.createConfigSignatureArgsForCall, struct {
		signer            mspctx.SigningIdentity
		channelConfigPath string
	}{signer, channelConfigPath})
	fake.recordInvocation("CreateConfigSignature", []interface{}{signer, channelConfigPath})
	fake.createConfigSignatureMutex.Unlock()
	if fake.CreateConfigSignatureStub != nil {
		return fake.CreateConfigSignatureStub(signer, channelConfigPath)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.createConfigSignatureReturns.result1, fake.createConfigSignatureReturns.result2
}

func (fake *ResMgmt) CreateConfigSignatureCallCount() int {
	fake.createConfigSignatureMutex.RLock()
	defer fake.createConfigSignatureMutex.RUnlock()
	return len(fake.createConfigSignatureArgsForCall)
}

func (fake *ResMgmt) CreateConfigSignatureArgsForCall(i int) (mspctx.SigningIdentity, string) {
	fake.createConfigSignatureMutex.RLock()
	defer fake.createConfigSignatureMutex.RUnlock()
	return fake.createConfigSignatureArgsForCall[i].signer, fake.createConfigSignatureArgsForCall[i].channelConfigPath
}

func (fake *ResMgmt) CreateConfigSignatureReturns(result1 *common.ConfigSignature, result2 error) {
	fake.CreateConfigSignatureStub = nil
	fake.createConfigSignatureReturns = struct {
		result1 *common.ConfigSignature
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) CreateConfigSignatureReturnsOnCall(i int, result1 *common.ConfigSignature, result2 error) {
	fake.CreateConfigSignatureStub = nil
	if fake.createConfigSignatureReturnsOnCall == nil {
		fake.createConfigSignatureReturnsOnCall = make(map[int]struct {
			result1 *common.ConfigSignature
			result2 error
		})
	}
	fake.createConfigSignatureReturnsOnCall[i] = struct {
		result1 *common.ConfigSignature
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) CreateConfigSignatureData(signer mspctx.SigningIdentity, channelConfigPath string) (signatureHeaderData resource.ConfigSignatureData, e error) {
	fake.createConfigSignatureDataMutex.Lock()
	ret, specificReturn := fake.createConfigSignatureDataReturnsOnCall[len(fake.createConfigSignatureDataArgsForCall)]
	fake.createConfigSignatureDataArgsForCall = append(fake.createConfigSignatureDataArgsForCall, struct {
		signer            mspctx.SigningIdentity
		channelConfigPath string
	}{signer, channelConfigPath})
	fake.recordInvocation("CreateConfigSignatureData", []interface{}{signer, channelConfigPath})
	fake.createConfigSignatureDataMutex.Unlock()
	if fake.CreateConfigSignatureDataStub != nil {
		return fake.CreateConfigSignatureDataStub(signer, channelConfigPath)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.createConfigSignatureDataReturns.result1, fake.createConfigSignatureDataReturns.result2
}

func (fake *ResMgmt) CreateConfigSignatureDataCallCount() int {
	fake.createConfigSignatureDataMutex.RLock()
	defer fake.createConfigSignatureDataMutex.RUnlock()
	return len(fake.createConfigSignatureDataArgsForCall)
}

func (fake *ResMgmt) CreateConfigSignatureDataArgsForCall(i int) (mspctx.SigningIdentity, string) {
	fake.createConfigSignatureDataMutex.RLock()
	defer fake.createConfigSignatureDataMutex.RUnlock()
	return fake.createConfigSignatureDataArgsForCall[i].signer, fake.createConfigSignatureDataArgsForCall[i].channelConfigPath
}

func (fake *ResMgmt) CreateConfigSignatureDataReturns(result1 resource.ConfigSignatureData, result2 error) {
	fake.CreateConfigSignatureDataStub = nil
	fake.createConfigSignatureDataReturns = struct {
		result1 resource.ConfigSignatureData
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) CreateConfigSignatureDataReturnsOnCall(i int, result1 resource.ConfigSignatureData, result2 error) {
	fake.CreateConfigSignatureDataStub = nil
	if fake.createConfigSignatureDataReturnsOnCall == nil {
		fake.createConfigSignatureDataReturnsOnCall = make(map[int]struct {
			result1 resource.ConfigSignatureData
			result2 error
		})
	}
	fake.createConfigSignatureDataReturnsOnCall[i] = struct {
		result1 resource.ConfigSignatureData
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) InstallCC(req resmgmt.InstallCCRequest, options ...resmgmt.RequestOption) ([]resmgmt.InstallCCResponse, error) {
	fake.installCCMutex.Lock()
	ret, specificReturn := fake.installCCReturnsOnCall[len(fake.installCCArgsForCall)]
	fake.installCCArgsForCall = append(fake.installCCArgsForCall, struct {
		req     resmgmt.InstallCCRequest
		options []resmgmt.RequestOption
	}{req, options})
	fake.recordInvocation("InstallCC", []interface{}{req, options})
	fake.installCCMutex.Unlock()
	if fake.InstallCCStub != nil {
		return fake.InstallCCStub(req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.installCCReturns.result1, fake.installCCReturns.result2
}

func (fake *ResMgmt) InstallCCCallCount() int {
	fake.installCCMutex.RLock()
	defer fake.installCCMutex.RUnlock()
	return len(fake.installCCArgsForCall)
}

func (fake *ResMgmt) InstallCCArgsForCall(i int) (resmgmt.InstallCCRequest, []resmgmt.RequestOption) {
	fake.installCCMutex.RLock()
	defer fake.installCCMutex.RUnlock()
	return fake.installCCArgsForCall[i].req, fake.installCCArgsForCall[i].options
}

func (fake *ResMgmt) InstallCCReturns(result1 []resmgmt.InstallCCResponse, result2 error) {
	fake.InstallCCStub = nil
	fake.installCCReturns = struct {
		result1 []resmgmt.InstallCCResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) InstallCCReturnsOnCall(i int, result1 []resmgmt.InstallCCResponse, result2 error) {
	fake.InstallCCStub = nil
	if fake.installCCReturnsOnCall == nil {
		fake.installCCReturnsOnCall = make(map[int]struct {
			result1 []resmgmt.InstallCCResponse
			result2 error
		})
	}
	fake.installCCReturnsOnCall[i] = struct {
		result1 []resmgmt.InstallCCResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) InstantiateCC(channelID string, req resmgmt.InstantiateCCRequest, options ...resmgmt.RequestOption) (resmgmt.InstantiateCCResponse, error) {
	fake.instantiateCCMutex.Lock()
	ret, specificReturn := fake.instantiateCCReturnsOnCall[len(fake.instantiateCCArgsForCall)]
	fake.instantiateCCArgsForCall = append(fake.instantiateCCArgsForCall, struct {
		channelID string
		req       resmgmt.InstantiateCCRequest
		options   []resmgmt.RequestOption
	}{channelID, req, options})
	fake.recordInvocation("InstantiateCC", []interface{}{channelID, req, options})
	fake.instantiateCCMutex.Unlock()
	if fake.InstantiateCCStub != nil {
		return fake.InstantiateCCStub(channelID, req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.instantiateCCReturns.result1, fake.instantiateCCReturns.result2
}

func (fake *ResMgmt) InstantiateCCCallCount() int {
	fake.instantiateCCMutex.RLock()
	defer fake.instantiateCCMutex.RUnlock()
	return len(fake.instantiateCCArgsForCall)
}

func (fake *ResMgmt) InstantiateCCArgsForCall(i int) (string, resmgmt.InstantiateCCRequest, []resmgmt.RequestOption) {
	fake.instantiateCCMutex.RLock()
	defer fake.instantiateCCMutex.RUnlock()
	return fake.instantiateCCArgsForCall[i].channelID, fake.instantiateCCArgsForCall[i].req, fake.instantiateCCArgsForCall[i].options
}

func (fake *ResMgmt) InstantiateCCReturns(result1 resmgmt.InstantiateCCResponse, result2 error) {
	fake.InstantiateCCStub = nil
	fake.instantiateCCReturns = struct {
		result1 resmgmt.InstantiateCCResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) InstantiateCCReturnsOnCall(i int, result1 resmgmt.InstantiateCCResponse, result2 error) {
	fake.InstantiateCCStub = nil
	if fake.instantiateCCReturnsOnCall == nil {
		fake.instantiateCCReturnsOnCall = make(map[int]struct {
			result1 resmgmt.InstantiateCCResponse
			result2 error
		})
	}
	fake.instantiateCCReturnsOnCall[i] = struct {
		result1 resmgmt.InstantiateCCResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) JoinChannel(channelID string, options ...resmgmt.RequestOption) error {
	fake.joinChannelMutex.Lock()
	ret, specificReturn := fake.joinChannelReturnsOnCall[len(fake.joinChannelArgsForCall)]
	fake.joinChannelArgsForCall = append(fake.joinChannelArgsForCall, struct {
		channelID string
		options   []resmgmt.RequestOption
	}{channelID, options})
	fake.recordInvocation("JoinChannel", []interface{}{channelID, options})
	fake.joinChannelMutex.Unlock()
	if fake.JoinChannelStub != nil {
		return fake.JoinChannelStub(channelID, options...)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.joinChannelReturns.result1
}

func (fake *ResMgmt) JoinChannelCallCount() int {
	fake.joinChannelMutex.RLock()
	defer fake.joinChannelMutex.RUnlock()
	return len(fake.joinChannelArgsForCall)
}

func (fake *ResMgmt) JoinChannelArgsForCall(i int) (string, []resmgmt.RequestOption) {
	fake.joinChannelMutex.RLock()
	defer fake.joinChannelMutex.RUnlock()
	return fake.joinChannelArgsForCall[i].channelID, fake.joinChannelArgsForCall[i].options
}

func (fake *ResMgmt) JoinChannelReturns(result1 error) {
	fake.JoinChannelStub = nil
	fake.joinChannelReturns = struct {
		result1 error
	}{result1}
}

func (fake *ResMgmt) JoinChannelReturnsOnCall(i int, result1 error) {
	fake.JoinChannelStub = nil
	if fake.joinChannelReturnsOnCall == nil {
		fake.joinChannelReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.joinChannelReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *ResMgmt) QueryChannels(options ...resmgmt.RequestOption) (*pb.ChannelQueryResponse, error) {
	fake.queryChannelsMutex.Lock()
	ret, specificReturn := fake.queryChannelsReturnsOnCall[len(fake.queryChannelsArgsForCall)]
	fake.queryChannelsArgsForCall = append(fake.queryChannelsArgsForCall, struct {
		options []resmgmt.RequestOption
	}{options})
	fake.recordInvocation("QueryChannels", []interface{}{options})
	fake.queryChannelsMutex.Unlock()
	if fake.QueryChannelsStub != nil {
		return fake.QueryChannelsStub(options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.queryChannelsReturns.result1, fake.queryChannelsReturns.result2
}

func (fake *ResMgmt) QueryChannelsCallCount() int {
	fake.queryChannelsMutex.RLock()
	defer fake.queryChannelsMutex.RUnlock()
	return len(fake.queryChannelsArgsForCall)
}

func (fake *ResMgmt) QueryChannelsArgsForCall(i int) []resmgmt.RequestOption {
	fake.queryChannelsMutex.RLock()
	defer fake.queryChannelsMutex.RUnlock()
	return fake.queryChannelsArgsForCall[i].options
}

func (fake *ResMgmt) QueryChannelsReturns(result1 *pb.ChannelQueryResponse, result2 error) {
	fake.QueryChannelsStub = nil
	fake.queryChannelsReturns = struct {
		result1 *pb.ChannelQueryResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) QueryChannelsReturnsOnCall(i int, result1 *pb.ChannelQueryResponse, result2 error) {
	fake.QueryChannelsStub = nil
	if fake.queryChannelsReturnsOnCall == nil {
		fake.queryChannelsReturnsOnCall = make(map[int]struct {
			result1 *pb.ChannelQueryResponse
			result2 error
		})
	}
	fake.queryChannelsReturnsOnCall[i] = struct {
		result1 *pb.ChannelQueryResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) QueryCollectionsConfig(channelID string, chaincodeName string, options ...resmgmt.RequestOption) (*pb.CollectionConfigPackage, error) {
	fake.queryCollectionsConfigMutex.Lock()
	ret, specificReturn := fake.queryCollectionsConfigReturnsOnCall[len(fake.queryCollectionsConfigArgsForCall)]
	fake.queryCollectionsConfigArgsForCall = append(fake.queryCollectionsConfigArgsForCall, struct {
		channelID     string
		chaincodeName string
		options       []resmgmt.RequestOption
	}{channelID, chaincodeName, options})
	fake.recordInvocation("QueryCollectionsConfig", []interface{}{channelID, chaincodeName, options})
	fake.queryCollectionsConfigMutex.Unlock()
	if fake.QueryCollectionsConfigStub != nil {
		return fake.QueryCollectionsConfigStub(channelID, chaincodeName, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.queryCollectionsConfigReturns.result1, fake.queryCollectionsConfigReturns.result2
}

func (fake *ResMgmt) QueryCollectionsConfigCallCount() int {
	fake.queryCollectionsConfigMutex.RLock()
	defer fake.queryCollectionsConfigMutex.RUnlock()
	return len(fake.queryCollectionsConfigArgsForCall)
}

func (fake *ResMgmt) QueryCollectionsConfigArgsForCall(i int) (string, string, []resmgmt.RequestOption) {
	fake.queryCollectionsConfigMutex.RLock()
	defer fake.queryCollectionsConfigMutex.RUnlock()
	return fake.queryCollectionsConfigArgsForCall[i].channelID, fake.queryCollectionsConfigArgsForCall[i].chaincodeName, fake.queryCollectionsConfigArgsForCall[i].options
}

func (fake *ResMgmt) QueryCollectionsConfigReturns(result1 *pb.CollectionConfigPackage, result2 error) {
	fake.QueryCollectionsConfigStub = nil
	fake.queryCollectionsConfigReturns = struct {
		result1 *pb.CollectionConfigPackage
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) QueryCollectionsConfigReturnsOnCall(i int, result1 *pb.CollectionConfigPackage, result2 error) {
	fake.QueryCollectionsConfigStub = nil
	if fake.queryCollectionsConfigReturnsOnCall == nil {
		fake.queryCollectionsConfigReturnsOnCall = make(map[int]struct {
			result1 *pb.CollectionConfigPackage
			result2 error
		})
	}
	fake.queryCollectionsConfigReturnsOnCall[i] = struct {
		result1 *pb.CollectionConfigPackage
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) QueryConfigFromOrderer(channelID string, options ...resmgmt.RequestOption) (fab.ChannelCfg, error) {
	fake.queryConfigFromOrdererMutex.Lock()
	ret, specificReturn := fake.queryConfigFromOrdererReturnsOnCall[len(fake.queryConfigFromOrdererArgsForCall)]
	fake.queryConfigFromOrdererArgsForCall = append(fake.queryConfigFromOrdererArgsForCall, struct {
		channelID string
		options   []resmgmt.RequestOption
	}{channelID, options})
	fake.recordInvocation("QueryConfigFromOrderer", []interface{}{channelID, options})
	fake.queryConfigFromOrdererMutex.Unlock()
	if fake.QueryConfigFromOrdererStub != nil {
		return fake.QueryConfigFromOrdererStub(channelID, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.queryConfigFromOrdererReturns.result1, fake.queryConfigFromOrdererReturns.result2
}

func (fake *ResMgmt) QueryConfigFromOrdererCallCount() int {
	fake.queryConfigFromOrdererMutex.RLock()
	defer fake.queryConfigFromOrdererMutex.RUnlock()
	return len(fake.queryConfigFromOrdererArgsForCall)
}

func (fake *ResMgmt) QueryConfigFromOrdererArgsForCall(i int) (string, []resmgmt.RequestOption) {
	fake.queryConfigFromOrdererMutex.RLock()
	defer fake.queryConfigFromOrdererMutex.RUnlock()
	return fake.queryConfigFromOrdererArgsForCall[i].channelID, fake.queryConfigFromOrdererArgsForCall[i].options
}

func (fake *ResMgmt) QueryConfigFromOrdererReturns(result1 fab.ChannelCfg, result2 error) {
	fake.QueryConfigFromOrdererStub = nil
	fake.queryConfigFromOrdererReturns = struct {
		result1 fab.ChannelCfg
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) QueryConfigFromOrdererReturnsOnCall(i int, result1 fab.ChannelCfg, result2 error) {
	fake.QueryConfigFromOrdererStub = nil
	if fake.queryConfigFromOrdererReturnsOnCall == nil {
		fake.queryConfigFromOrdererReturnsOnCall = make(map[int]struct {
			result1 fab.ChannelCfg
			result2 error
		})
	}
	fake.queryConfigFromOrdererReturnsOnCall[i] = struct {
		result1 fab.ChannelCfg
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) QueryInstalledChaincodes(options ...resmgmt.RequestOption) (*pb.ChaincodeQueryResponse, error) {
	fake.queryInstalledChaincodesMutex.Lock()
	ret, specificReturn := fake.queryInstalledChaincodesReturnsOnCall[len(fake.queryInstalledChaincodesArgsForCall)]
	fake.queryInstalledChaincodesArgsForCall = append(fake.queryInstalledChaincodesArgsForCall, struct {
		options []resmgmt.RequestOption
	}{options})
	fake.recordInvocation("QueryInstalledChaincodes", []interface{}{options})
	fake.queryInstalledChaincodesMutex.Unlock()
	if fake.QueryInstalledChaincodesStub != nil {
		return fake.QueryInstalledChaincodesStub(options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.queryInstalledChaincodesReturns.result1, fake.queryInstalledChaincodesReturns.result2
}

func (fake *ResMgmt) QueryInstalledChaincodesCallCount() int {
	fake.queryInstalledChaincodesMutex.RLock()
	defer fake.queryInstalledChaincodesMutex.RUnlock()
	return len(fake.queryInstalledChaincodesArgsForCall)
}

func (fake *ResMgmt) QueryInstalledChaincodesArgsForCall(i int) []resmgmt.RequestOption {
	fake.queryInstalledChaincodesMutex.RLock()
	defer fake.queryInstalledChaincodesMutex.RUnlock()
	return fake.queryInstalledChaincodesArgsForCall[i].options
}

func (fake *ResMgmt) QueryInstalledChaincodesReturns(result1 *pb.ChaincodeQueryResponse, result2 error) {
	fake.QueryInstalledChaincodesStub = nil
	fake.queryInstalledChaincodesReturns = struct {
		result1 *pb.ChaincodeQueryResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) QueryInstalledChaincodesReturnsOnCall(i int, result1 *pb.ChaincodeQueryResponse, result2 error) {
	fake.QueryInstalledChaincodesStub = nil
	if fake.queryInstalledChaincodesReturnsOnCall == nil {
		fake.queryInstalledChaincodesReturnsOnCall = make(map[int]struct {
			result1 *pb.ChaincodeQueryResponse
			result2 error
		})
	}
	fake.queryInstalledChaincodesReturnsOnCall[i] = struct {
		result1 *pb.ChaincodeQueryResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) QueryInstantiatedChaincodes(channelID string, options ...resmgmt.RequestOption) (*pb.ChaincodeQueryResponse, error) {
	fake.queryInstantiatedChaincodesMutex.Lock()
	ret, specificReturn := fake.queryInstantiatedChaincodesReturnsOnCall[len(fake.queryInstantiatedChaincodesArgsForCall)]
	fake.queryInstantiatedChaincodesArgsForCall = append(fake.queryInstantiatedChaincodesArgsForCall, struct {
		channelID string
		options   []resmgmt.RequestOption
	}{channelID, options})
	fake.recordInvocation("QueryInstantiatedChaincodes", []interface{}{channelID, options})
	fake.queryInstantiatedChaincodesMutex.Unlock()
	if fake.QueryInstantiatedChaincodesStub != nil {
		return fake.QueryInstantiatedChaincodesStub(channelID, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.queryInstantiatedChaincodesReturns.result1, fake.queryInstantiatedChaincodesReturns.result2
}

func (fake *ResMgmt) QueryInstantiatedChaincodesCallCount() int {
	fake.queryInstantiatedChaincodesMutex.RLock()
	defer fake.queryInstantiatedChaincodesMutex.RUnlock()
	return len(fake.queryInstantiatedChaincodesArgsForCall)
}

func (fake *ResMgmt) QueryInstantiatedChaincodesArgsForCall(i int) (string, []resmgmt.RequestOption) {
	fake.queryInstantiatedChaincodesMutex.RLock()
	defer fake.queryInstantiatedChaincodesMutex.RUnlock()
	return fake.queryInstantiatedChaincodesArgsForCall[i].channelID, fake.queryInstantiatedChaincodesArgsForCall[i].options
}

func (fake *ResMgmt) QueryInstantiatedChaincodesReturns(result1 *pb.ChaincodeQueryResponse, result2 error) {
	fake.QueryInstantiatedChaincodesStub = nil
	fake.queryInstantiatedChaincodesReturns = struct {
		result1 *pb.ChaincodeQueryResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) QueryInstantiatedChaincodesReturnsOnCall(i int, result1 *pb.ChaincodeQueryResponse, result2 error) {
	fake.QueryInstantiatedChaincodesStub = nil
	if fake.queryInstantiatedChaincodesReturnsOnCall == nil {
		fake.queryInstantiatedChaincodesReturnsOnCall = make(map[int]struct {
			result1 *pb.ChaincodeQueryResponse
			result2 error
		})
	}
	fake.queryInstantiatedChaincodesReturnsOnCall[i] = struct {
		result1 *pb.ChaincodeQueryResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) SaveChannel(req resmgmt.SaveChannelRequest, options ...resmgmt.RequestOption) (resmgmt.SaveChannelResponse, error) {
	fake.saveChannelMutex.Lock()
	ret, specificReturn := fake.saveChannelReturnsOnCall[len(fake.saveChannelArgsForCall)]
	fake.saveChannelArgsForCall = append(fake.saveChannelArgsForCall, struct {
		req     resmgmt.SaveChannelRequest
		options []resmgmt.RequestOption
	}{req, options})
	fake.recordInvocation("SaveChannel", []interface{}{req, options})
	fake.saveChannelMutex.Unlock()
	if fake.SaveChannelStub != nil {
		return fake.SaveChannelStub(req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.saveChannelReturns.result1, fake.saveChannelReturns.result2
}

func (fake *ResMgmt) SaveChannelCallCount() int {
	fake.saveChannelMutex.RLock()
	defer fake.saveChannelMutex.RUnlock()
	return len(fake.saveChannelArgsForCall)
}

func (fake *ResMgmt) SaveChannelArgsForCall(i int) (resmgmt.SaveChannelRequest, []resmgmt.RequestOption) {
	fake.saveChannelMutex.RLock()
	defer fake.saveChannelMutex.RUnlock()
	return fake.saveChannelArgsForCall[i].req, fake.saveChannelArgsForCall[i].options
}

func (fake *ResMgmt) SaveChannelReturns(result1 resmgmt.SaveChannelResponse, result2 error) {
	fake.SaveChannelStub = nil
	fake.saveChannelReturns = struct {
		result1 resmgmt.SaveChannelResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) SaveChannelReturnsOnCall(i int, result1 resmgmt.SaveChannelResponse, result2 error) {
	fake.SaveChannelStub = nil
	if fake.saveChannelReturnsOnCall == nil {
		fake.saveChannelReturnsOnCall = make(map[int]struct {
			result1 resmgmt.SaveChannelResponse
			result2 error
		})
	}
	fake.saveChannelReturnsOnCall[i] = struct {
		result1 resmgmt.SaveChannelResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) UpgradeCC(channelID string, req resmgmt.UpgradeCCRequest, options ...resmgmt.RequestOption) (resmgmt.UpgradeCCResponse, error) {
	fake.upgradeCCMutex.Lock()
	ret, specificReturn := fake.upgradeCCReturnsOnCall[len(fake.upgradeCCArgsForCall)]
	fake.upgradeCCArgsForCall = append(fake.upgradeCCArgsForCall, struct {
		channelID string
		req       resmgmt.UpgradeCCRequest
		options   []resmgmt.RequestOption
	}{channelID, req, options})
	fake.recordInvocation("UpgradeCC", []interface{}{channelID, req, options})
	fake.upgradeCCMutex.Unlock()
	if fake.UpgradeCCStub != nil {
		return fake.UpgradeCCStub(channelID, req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.upgradeCCReturns.result1, fake.upgradeCCReturns.result2
}

func (fake *ResMgmt) UpgradeCCCallCount() int {
	fake.upgradeCCMutex.RLock()
	defer fake.upgradeCCMutex.RUnlock()
	return len(fake.upgradeCCArgsForCall)
}

func (fake *ResMgmt) UpgradeCCArgsForCall(i int) (string, resmgmt.UpgradeCCRequest, []resmgmt.RequestOption) {
	fake.upgradeCCMutex.RLock()
	defer fake.upgradeCCMutex.RUnlock()
	return fake.upgradeCCArgsForCall[i].channelID, fake.upgradeCCArgsForCall[i].req, fake.upgradeCCArgsForCall[i].options
}

func (fake *ResMgmt) UpgradeCCReturns(result1 resmgmt.UpgradeCCResponse, result2 error) {
	fake.UpgradeCCStub = nil
	fake.upgradeCCReturns = struct {
		result1 resmgmt.UpgradeCCResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) UpgradeCCReturnsOnCall(i int, result1 resmgmt.UpgradeCCResponse, result2 error) {
	fake.UpgradeCCStub = nil
	if fake.upgradeCCReturnsOnCall == nil {
		fake.upgradeCCReturnsOnCall = make(map[int]struct {
			result1 resmgmt.UpgradeCCResponse
			result2 error
		})
	}
	fake.upgradeCCReturnsOnCall[i] = struct {
		result1 resmgmt.UpgradeCCResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleInstallCC(req resmgmt.LifecycleInstallCCRequest, options ...resmgmt.RequestOption) ([]resmgmt.LifecycleInstallCCResponse, error) {
	fake.lifecycleInstallCCMutex.Lock()
	ret, specificReturn := fake.lifecycleInstallCCReturnsOnCall[len(fake.lifecycleInstallCCArgsForCall)]
	fake.lifecycleInstallCCArgsForCall = append(fake.lifecycleInstallCCArgsForCall, struct {
		req     resmgmt.LifecycleInstallCCRequest
		options []resmgmt.RequestOption
	}{req, options})
	fake.recordInvocation("LifecycleInstallCC", []interface{}{req, options})
	fake.lifecycleInstallCCMutex.Unlock()
	if fake.LifecycleInstallCCStub != nil {
		return fake.LifecycleInstallCCStub(req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lifecycleInstallCCReturns.result1, fake.lifecycleInstallCCReturns.result2
}

func (fake *ResMgmt) LifecycleInstallCCCallCount() int {
	fake.lifecycleInstallCCMutex.RLock()
	defer fake.lifecycleInstallCCMutex.RUnlock()
	return len(fake.lifecycleInstallCCArgsForCall)
}

func (fake *ResMgmt) LifecycleInstallCCArgsForCall(i int) (resmgmt.LifecycleInstallCCRequest, []resmgmt.RequestOption) {
	fake.lifecycleInstallCCMutex.RLock()
	defer fake.lifecycleInstallCCMutex.RUnlock()
	return fake.lifecycleInstallCCArgsForCall[i].req, fake.lifecycleInstallCCArgsForCall[i].options
}

func (fake *ResMgmt) LifecycleInstallCCReturns(result1 []resmgmt.LifecycleInstallCCResponse, result2 error) {
	fake.LifecycleInstallCCStub = nil
	fake.lifecycleInstallCCReturns = struct {
		result1 []resmgmt.LifecycleInstallCCResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleInstallCCReturnsOnCall(i int, result1 []resmgmt.LifecycleInstallCCResponse, result2 error) {
	fake.LifecycleInstallCCStub = nil
	if fake.lifecycleInstallCCReturnsOnCall == nil {
		fake.lifecycleInstallCCReturnsOnCall = make(map[int]struct {
			result1 []resmgmt.LifecycleInstallCCResponse
			result2 error
		})
	}
	fake.lifecycleInstallCCReturnsOnCall[i] = struct {
		result1 []resmgmt.LifecycleInstallCCResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleApproveCC(channelID string, req resmgmt.LifecycleApproveCCRequest, options ...resmgmt.RequestOption) (fab.TransactionID, error) {
	fake.lifecycleApproveCCMutex.Lock()
	ret, specificReturn := fake.lifecycleApproveCCReturnsOnCall[len(fake.lifecycleApproveCCArgsForCall)]
	fake.lifecycleApproveCCArgsForCall = append(fake.lifecycleApproveCCArgsForCall, struct {
		channelID string
		req       resmgmt.LifecycleApproveCCRequest
		options   []resmgmt.RequestOption
	}{channelID, req, options})
	fake.recordInvocation("LifecycleApproveCC", []interface{}{channelID, req, options})
	fake.lifecycleApproveCCMutex.Unlock()
	if fake.LifecycleApproveCCStub != nil {
		return fake.LifecycleApproveCCStub(channelID, req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lifecycleApproveCCReturns.result1, fake.lifecycleApproveCCReturns.result2
}

func (fake *ResMgmt) LifecycleApproveCCCallCount() int {
	fake.lifecycleApproveCCMutex.RLock()
	defer fake.lifecycleApproveCCMutex.RUnlock()
	return len(fake.lifecycleApproveCCArgsForCall)
}

func (fake *ResMgmt) LifecycleApproveCCArgsForCall(i int) (string, resmgmt.LifecycleApproveCCRequest, []resmgmt.RequestOption) {
	fake.lifecycleApproveCCMutex.RLock()
	defer fake.lifecycleApproveCCMutex.RUnlock()
	return fake.lifecycleApproveCCArgsForCall[i].channelID, fake.lifecycleApproveCCArgsForCall[i].req, fake.lifecycleApproveCCArgsForCall[i].options
}

func (fake *ResMgmt) LifecycleApproveCCReturns(result1 fab.TransactionID, result2 error) {
	fake.LifecycleApproveCCStub = nil
	fake.lifecycleApproveCCReturns = struct {
		result1 fab.TransactionID
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleApproveCCReturnsOnCall(i int, result1 fab.TransactionID, result2 error) {
	fake.LifecycleApproveCCStub = nil
	if fake.lifecycleApproveCCReturnsOnCall == nil {
		fake.lifecycleApproveCCReturnsOnCall = make(map[int]struct {
			result1 fab.TransactionID
			result2 error
		})
	}
	fake.lifecycleApproveCCReturnsOnCall[i] = struct {
		result1 fab.TransactionID
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleCommitCC(channelID string, req resmgmt.LifecycleCommitCCRequest, options ...resmgmt.RequestOption) (fab.TransactionID, error) {
	fake.lifecycleCommitCCMutex.Lock()
	ret, specificReturn := fake.lifecycleCommitCCReturnsOnCall[len(fake.lifecycleCommitCCArgsForCall)]
	fake.lifecycleCommitCCArgsForCall = append(fake.lifecycleCommitCCArgsForCall, struct {
		channelID string
		req       resmgmt.LifecycleCommitCCRequest
		options   []resmgmt.RequestOption
	}{channelID, req, options})
	fake.recordInvocation("LifecycleCommitCC", []interface{}{channelID, req, options})
	fake.lifecycleCommitCCMutex.Unlock()
	if fake.LifecycleCommitCCStub != nil {
		return fake.LifecycleCommitCCStub(channelID, req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lifecycleCommitCCReturns.result1, fake.lifecycleCommitCCReturns.result2
}

func (fake *ResMgmt) LifecycleCommitCCCallCount() int {
	fake.lifecycleCommitCCMutex.RLock()
	defer fake.lifecycleCommitCCMutex.RUnlock()
	return len(fake.lifecycleCommitCCArgsForCall)
}

func (fake *ResMgmt) LifecycleCommitCCArgsForCall(i int) (string, resmgmt.LifecycleCommitCCRequest, []resmgmt.RequestOption) {
	fake.lifecycleCommitCCMutex.RLock()
	defer fake.lifecycleCommitCCMutex.RUnlock()
	return fake.lifecycleCommitCCArgsForCall[i].channelID, fake.lifecycleCommitCCArgsForCall[i].req, fake.lifecycleCommitCCArgsForCall[i].options
}

func (fake *ResMgmt) LifecycleCommitCCReturns(result1 fab.TransactionID, result2 error) {
	fake.LifecycleCommitCCStub = nil
	fake.lifecycleCommitCCReturns = struct {
		result1 fab.TransactionID
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleCommitCCReturnsOnCall(i int, result1 fab.TransactionID, result2 error) {
	fake.LifecycleCommitCCStub = nil
	if fake.lifecycleCommitCCReturnsOnCall == nil {
		fake.lifecycleCommitCCReturnsOnCall = make(map[int]struct {
			result1 fab.TransactionID
			result2 error
		})
	}
	fake.lifecycleCommitCCReturnsOnCall[i] = struct {
		result1 fab.TransactionID
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleQueryInstalledCC(options ...resmgmt.RequestOption) ([]resmgmt.LifecycleInstalledCC, error) {
	fake.lifecycleQueryInstalledCCMutex.Lock()
	ret, specificReturn := fake.lifecycleQueryInstalledCCReturnsOnCall[len(fake.lifecycleQueryInstalledCCArgsForCall)]
	fake.lifecycleQueryInstalledCCArgsForCall = append(fake.lifecycleQueryInstalledCCArgsForCall, struct {
		options []resmgmt.RequestOption
	}{options})
	fake.recordInvocation("LifecycleQueryInstalledCC", []interface{}{options})
	fake.lifecycleQueryInstalledCCMutex.Unlock()
	if fake.LifecycleQueryInstalledCCStub != nil {
		return fake.LifecycleQueryInstalledCCStub(options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lifecycleQueryInstalledCCReturns.result1, fake.lifecycleQueryInstalledCCReturns.result2
}

func (fake *ResMgmt) LifecycleQueryInstalledCCCallCount() int {
	fake.lifecycleQueryInstalledCCMutex.RLock()
	defer fake.lifecycleQueryInstalledCCMutex.RUnlock()
	return len(fake.lifecycleQueryInstalledCCArgsForCall)
}

func (fake *ResMgmt) LifecycleQueryInstalledCCArgsForCall(i int) []resmgmt.RequestOption {
	fake.lifecycleQueryInstalledCCMutex.RLock()
	defer fake.lifecycleQueryInstalledCCMutex.RUnlock()
	return fake.lifecycleQueryInstalledCCArgsForCall[i].options
}

func (fake *ResMgmt) LifecycleQueryInstalledCCReturns(result1 []resmgmt.LifecycleInstalledCC, result2 error) {
	fake.LifecycleQueryInstalledCCStub = nil
	fake.lifecycleQueryInstalledCCReturns = struct {
		result1 []resmgmt.LifecycleInstalledCC
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleQueryInstalledCCReturnsOnCall(i int, result1 []resmgmt.LifecycleInstalledCC, result2 error) {
	fake.LifecycleQueryInstalledCCStub = nil
	if fake.lifecycleQueryInstalledCCReturnsOnCall == nil {
		fake.lifecycleQueryInstalledCCReturnsOnCall = make(map[int]struct {
			result1 []resmgmt.LifecycleInstalledCC
			result2 error
		})
	}
	fake.lifecycleQueryInstalledCCReturnsOnCall[i] = struct {
		result1 []resmgmt.LifecycleInstalledCC
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleGetInstalledCCPackage(packageID string, options ...resmgmt.RequestOption) ([]byte, error) {
	fake.lifecycleGetInstalledCCPackageMutex.Lock()
	ret, specificReturn := fake.lifecycleGetInstalledCCPackageReturnsOnCall[len(fake.lifecycleGetInstalledCCPackageArgsForCall)]
	fake.lifecycleGetInstalledCCPackageArgsForCall = append(fake.lifecycleGetInstalledCCPackageArgsForCall, struct {
		packageID string
		options   []resmgmt.RequestOption
	}{packageID, options})
	fake.recordInvocation("LifecycleGetInstalledCCPackage", []interface{}{packageID, options})
	fake.lifecycleGetInstalledCCPackageMutex.Unlock()
	if fake.LifecycleGetInstalledCCPackageStub != nil {
		return fake.LifecycleGetInstalledCCPackageStub(packageID, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lifecycleGetInstalledCCPackageReturns.result1, fake.lifecycleGetInstalledCCPackageReturns.result2
}

func (fake *ResMgmt) LifecycleGetInstalledCCPackageCallCount() int {
	fake.lifecycleGetInstalledCCPackageMutex.RLock()
	defer fake.lifecycleGetInstalledCCPackageMutex.RUnlock()
	return len(fake.lifecycleGetInstalledCCPackageArgsForCall)
}

func (fake *ResMgmt) LifecycleGetInstalledCCPackageArgsForCall(i int) (string, []resmgmt.RequestOption) {
	fake.lifecycleGetInstalledCCPackageMutex.RLock()
	defer fake.lifecycleGetInstalledCCPackageMutex.RUnlock()
	return fake.lifecycleGetInstalledCCPackageArgsForCall[i].packageID, fake.lifecycleGetInstalledCCPackageArgsForCall[i].options
}

func (fake *ResMgmt) LifecycleGetInstalledCCPackageReturns(result1 []byte, result2 error) {
	fake.LifecycleGetInstalledCCPackageStub = nil
	fake.lifecycleGetInstalledCCPackageReturns = struct {
		result1 []byte
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleGetInstalledCCPackageReturnsOnCall(i int, result1 []byte, result2 error) {
	fake.LifecycleGetInstalledCCPackageStub = nil
	if fake.lifecycleGetInstalledCCPackageReturnsOnCall == nil {
		fake.lifecycleGetInstalledCCPackageReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 error
		})
	}
	fake.lifecycleGetInstalledCCPackageReturnsOnCall[i] = struct {
		result1 []byte
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleQueryApprovedCC(channelID string, req resmgmt.LifecycleQueryApprovedCCRequest, options ...resmgmt.RequestOption) (resmgmt.LifecycleApprovedChaincodeDefinition, error) {
	fake.lifecycleQueryApprovedCCMutex.Lock()
	ret, specificReturn := fake.lifecycleQueryApprovedCCReturnsOnCall[len(fake.lifecycleQueryApprovedCCArgsForCall)]
	fake.lifecycleQueryApprovedCCArgsForCall = append(fake.lifecycleQueryApprovedCCArgsForCall, struct {
		channelID string
		req       resmgmt.LifecycleQueryApprovedCCRequest
		options   []resmgmt.RequestOption
	}{channelID, req, options})
	fake.recordInvocation("LifecycleQueryApprovedCC", []interface{}{channelID, req, options})
	fake.lifecycleQueryApprovedCCMutex.Unlock()
	if fake.LifecycleQueryApprovedCCStub != nil {
		return fake.LifecycleQueryApprovedCCStub(channelID, req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lifecycleQueryApprovedCCReturns.result1, fake.lifecycleQueryApprovedCCReturns.result2
}

func (fake *ResMgmt) LifecycleQueryApprovedCCCallCount() int {
	fake.lifecycleQueryApprovedCCMutex.RLock()
	defer fake.lifecycleQueryApprovedCCMutex.RUnlock()
	return len(fake.lifecycleQueryApprovedCCArgsForCall)
}

func (fake *ResMgmt) LifecycleQueryApprovedCCArgsForCall(i int) (string, resmgmt.LifecycleQueryApprovedCCRequest, []resmgmt.RequestOption) {
	fake.lifecycleQueryApprovedCCMutex.RLock()
	defer fake.lifecycleQueryApprovedCCMutex.RUnlock()
	return fake.lifecycleQueryApprovedCCArgsForCall[i].channelID, fake.lifecycleQueryApprovedCCArgsForCall[i].req, fake.lifecycleQueryApprovedCCArgsForCall[i].options
}

func (fake *ResMgmt) LifecycleQueryApprovedCCReturns(result1 resmgmt.LifecycleApprovedChaincodeDefinition, result2 error) {
	fake.LifecycleQueryApprovedCCStub = nil
	fake.lifecycleQueryApprovedCCReturns = struct {
		result1 resmgmt.LifecycleApprovedChaincodeDefinition
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleQueryApprovedCCReturnsOnCall(i int, result1 resmgmt.LifecycleApprovedChaincodeDefinition, result2 error) {
	fake.LifecycleQueryApprovedCCStub = nil
	if fake.lifecycleQueryApprovedCCReturnsOnCall == nil {
		fake.lifecycleQueryApprovedCCReturnsOnCall = make(map[int]struct {
			result1 resmgmt.LifecycleApprovedChaincodeDefinition
			result2 error
		})
	}
	fake.lifecycleQueryApprovedCCReturnsOnCall[i] = struct {
		result1 resmgmt.LifecycleApprovedChaincodeDefinition
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleCheckCCCommitReadiness(channelID string, req resmgmt.LifecycleCheckCCCommitReadinessRequest, options ...resmgmt.RequestOption) (resmgmt.LifecycleCheckCCCommitReadinessResponse, error) {
	fake.lifecycleCheckCCCommitReadinessMutex.Lock()
	ret, specificReturn := fake.lifecycleCheckCCCommitReadinessReturnsOnCall[len(fake.lifecycleCheckCCCommitReadinessArgsForCall)]
	fake.lifecycleCheckCCCommitReadinessArgsForCall = append(fake.lifecycleCheckCCCommitReadinessArgsForCall, struct {
		channelID string
		req       resmgmt.LifecycleCheckCCCommitReadinessRequest
		options   []resmgmt.RequestOption
	}{channelID, req, options})
	fake.recordInvocation("LifecycleCheckCCCommitReadiness", []interface{}{channelID, req, options})
	fake.lifecycleCheckCCCommitReadinessMutex.Unlock()
	if fake.LifecycleCheckCCCommitReadinessStub != nil {
		return fake.LifecycleCheckCCCommitReadinessStub(channelID, req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lifecycleCheckCCCommitReadinessReturns.result1, fake.lifecycleCheckCCCommitReadinessReturns.result2
}

func (fake *ResMgmt) LifecycleCheckCCCommitReadinessCallCount() int {
	fake.lifecycleCheckCCCommitReadinessMutex.RLock()
	defer fake.lifecycleCheckCCCommitReadinessMutex.RUnlock()
	return len(fake.lifecycleCheckCCCommitReadinessArgsForCall)
}

func (fake *ResMgmt) LifecycleCheckCCCommitReadinessArgsForCall(i int) (string, resmgmt.LifecycleCheckCCCommitReadinessRequest, []resmgmt.RequestOption) {
	fake.lifecycleCheckCCCommitReadinessMutex.RLock()
	defer fake.lifecycleCheckCCCommitReadinessMutex.RUnlock()
	return fake.lifecycleCheckCCCommitReadinessArgsForCall[i].channelID, fake.lifecycleCheckCCCommitReadinessArgsForCall[i].req, fake.lifecycleCheckCCCommitReadinessArgsForCall[i].options
}

func (fake *ResMgmt) LifecycleCheckCCCommitReadinessReturns(result1 resmgmt.LifecycleCheckCCCommitReadinessResponse, result2 error) {
	fake.LifecycleCheckCCCommitReadinessStub = nil
	fake.lifecycleCheckCCCommitReadinessReturns = struct {
		result1 resmgmt.LifecycleCheckCCCommitReadinessResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleCheckCCCommitReadinessReturnsOnCall(i int, result1 resmgmt.LifecycleCheckCCCommitReadinessResponse, result2 error) {
	fake.LifecycleCheckCCCommitReadinessStub = nil
	if fake.lifecycleCheckCCCommitReadinessReturnsOnCall == nil {
		fake.lifecycleCheckCCCommitReadinessReturnsOnCall = make(map[int]struct {
			result1 resmgmt.LifecycleCheckCCCommitReadinessResponse
			result2 error
		})
	}
	fake.lifecycleCheckCCCommitReadinessReturnsOnCall[i] = struct {
		result1 resmgmt.LifecycleCheckCCCommitReadinessResponse
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleQueryCommittedCC(channelID string, req resmgmt.LifecycleQueryCommittedCCRequest, options ...resmgmt.RequestOption) ([]resmgmt.LifecycleChaincodeDefinition, error) {
	fake.lifecycleQueryCommittedCCMutex.Lock()
	ret, specificReturn := fake.lifecycleQueryCommittedCCReturnsOnCall[len(fake.lifecycleQueryCommittedCCArgsForCall)]
	fake.lifecycleQueryCommittedCCArgsForCall = append(fake.lifecycleQueryCommittedCCArgsForCall, struct {
		channelID string
		req       resmgmt.LifecycleQueryCommittedCCRequest
		options   []resmgmt.RequestOption
	}{channelID, req, options})
	fake.recordInvocation("LifecycleQueryCommittedCC", []interface{}{channelID, req, options})
	fake.lifecycleQueryCommittedCCMutex.Unlock()
	if fake.LifecycleQueryCommittedCCStub != nil {
		return fake.LifecycleQueryCommittedCCStub(channelID, req, options...)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lifecycleQueryCommittedCCReturns.result1, fake.lifecycleQueryCommittedCCReturns.result2
}

func (fake *ResMgmt) LifecycleQueryCommittedCCCallCount() int {
	fake.lifecycleQueryCommittedCCMutex.RLock()
	defer fake.lifecycleQueryCommittedCCMutex.RUnlock()
	return len(fake.lifecycleQueryCommittedCCArgsForCall)
}

func (fake *ResMgmt) LifecycleQueryCommittedCCArgsForCall(i int) (string, resmgmt.LifecycleQueryCommittedCCRequest, []resmgmt.RequestOption) {
	fake.lifecycleQueryCommittedCCMutex.RLock()
	defer fake.lifecycleQueryCommittedCCMutex.RUnlock()
	return fake.lifecycleQueryCommittedCCArgsForCall[i].channelID, fake.lifecycleQueryCommittedCCArgsForCall[i].req, fake.lifecycleQueryCommittedCCArgsForCall[i].options
}

func (fake *ResMgmt) LifecycleQueryCommittedCCReturns(result1 []resmgmt.LifecycleChaincodeDefinition, result2 error) {
	fake.LifecycleQueryCommittedCCStub = nil
	fake.lifecycleQueryCommittedCCReturns = struct {
		result1 []resmgmt.LifecycleChaincodeDefinition
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) LifecycleQueryCommittedCCReturnsOnCall(i int, result1 []resmgmt.LifecycleChaincodeDefinition, result2 error) {
	fake.LifecycleQueryCommittedCCStub = nil
	if fake.lifecycleQueryCommittedCCReturnsOnCall == nil {
		fake.lifecycleQueryCommittedCCReturnsOnCall = make(map[int]struct {
			result1 []resmgmt.LifecycleChaincodeDefinition
			result2 error
		})
	}
	fake.lifecycleQueryCommittedCCReturnsOnCall[i] = struct {
		result1 []resmgmt.LifecycleChaincodeDefinition
		result2 error
	}{result1, result2}
}

func (fake *ResMgmt) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.createConfigSignatureMutex.RLock()
	defer fake.createConfigSignatureMutex.RUnlock()
	fake.createConfigSignatureDataMutex.RLock()
	defer fake.createConfigSignatureDataMutex.RUnlock()
	fake.installCCMutex.RLock()
	defer fake.installCCMutex.RUnlock()
	fake.instantiateCCMutex.RLock()
	defer fake.instantiateCCMutex.RUnlock()
	fake.joinChannelMutex.RLock()
	defer fake.joinChannelMutex.RUnlock()
	fake.queryChannelsMutex.RLock()
	defer fake.queryChannelsMutex.RUnlock()
	fake.queryCollectionsConfigMutex.RLock()
	defer fake.queryCollectionsConfigMutex.RUnlock()
	fake.queryConfigFromOrdererMutex.RLock()
	defer fake.queryConfigFromOrdererMutex.RUnlock()
	fake.queryInstalledChaincodesMutex.RLock()
	defer fake.queryInstalledChaincodesMutex.RUnlock()
	fake.queryInstantiatedChaincodesMutex.RLock()
	defer fake.queryInstantiatedChaincodesMutex.RUnlock()
	fake.saveChannelMutex.RLock()
	defer fake.saveChannelMutex.RUnlock()
	fake.upgradeCCMutex.RLock()
	defer fake.upgradeCCMutex.RUnlock()
	fake.lifecycleInstallCCMutex.RLock()
	defer fake.lifecycleInstallCCMutex.RUnlock()
	fake.lifecycleApproveCCMutex.RLock()
	defer fake.lifecycleApproveCCMutex.RUnlock()
	fake.lifecycleCommitCCMutex.RLock()
	defer fake.lifecycleCommitCCMutex.RUnlock()
	fake.lifecycleQueryInstalledCCMutex.RLock()
	defer fake.lifecycleQueryInstalledCCMutex.RUnlock()
	fake.lifecycleGetInstalledCCPackageMutex.RLock()
	defer fake.lifecycleGetInstalledCCPackageMutex.RUnlock()
	fake.lifecycleQueryApprovedCCMutex.RLock()
	defer fake.lifecycleQueryApprovedCCMutex.RUnlock()
	fake.lifecycleCheckCCCommitReadinessMutex.RLock()
	defer fake.lifecycleCheckCCCommitReadinessMutex.RUnlock()
	fake.lifecycleQueryCommittedCCMutex.RLock()
	defer fake.lifecycleQueryCommittedCCMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *ResMgmt) 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 _ fabric.ResourceManagement = new(ResMgmt)