fake_service_repository.go

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

import (
	"sync"

	"code.cloudfoundry.org/cli/cf/api"
	"code.cloudfoundry.org/cli/cf/api/resources"
	"code.cloudfoundry.org/cli/cf/models"
)

type FakeServiceRepository struct {
	CreateServiceInstanceStub        func(string, string, map[string]interface{}, []string) error
	createServiceInstanceMutex       sync.RWMutex
	createServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 map[string]interface{}
		arg4 []string
	}
	createServiceInstanceReturns struct {
		result1 error
	}
	createServiceInstanceReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteServiceStub        func(models.ServiceInstance) error
	deleteServiceMutex       sync.RWMutex
	deleteServiceArgsForCall []struct {
		arg1 models.ServiceInstance
	}
	deleteServiceReturns struct {
		result1 error
	}
	deleteServiceReturnsOnCall map[int]struct {
		result1 error
	}
	FindInstanceByNameStub        func(string) (models.ServiceInstance, error)
	findInstanceByNameMutex       sync.RWMutex
	findInstanceByNameArgsForCall []struct {
		arg1 string
	}
	findInstanceByNameReturns struct {
		result1 models.ServiceInstance
		result2 error
	}
	findInstanceByNameReturnsOnCall map[int]struct {
		result1 models.ServiceInstance
		result2 error
	}
	FindServiceOfferingByLabelAndProviderStub        func(string, string) (models.ServiceOffering, error)
	findServiceOfferingByLabelAndProviderMutex       sync.RWMutex
	findServiceOfferingByLabelAndProviderArgsForCall []struct {
		arg1 string
		arg2 string
	}
	findServiceOfferingByLabelAndProviderReturns struct {
		result1 models.ServiceOffering
		result2 error
	}
	findServiceOfferingByLabelAndProviderReturnsOnCall map[int]struct {
		result1 models.ServiceOffering
		result2 error
	}
	FindServiceOfferingsByLabelStub        func(string) (models.ServiceOfferings, error)
	findServiceOfferingsByLabelMutex       sync.RWMutex
	findServiceOfferingsByLabelArgsForCall []struct {
		arg1 string
	}
	findServiceOfferingsByLabelReturns struct {
		result1 models.ServiceOfferings
		result2 error
	}
	findServiceOfferingsByLabelReturnsOnCall map[int]struct {
		result1 models.ServiceOfferings
		result2 error
	}
	FindServiceOfferingsForSpaceByLabelStub        func(string, string) (models.ServiceOfferings, error)
	findServiceOfferingsForSpaceByLabelMutex       sync.RWMutex
	findServiceOfferingsForSpaceByLabelArgsForCall []struct {
		arg1 string
		arg2 string
	}
	findServiceOfferingsForSpaceByLabelReturns struct {
		result1 models.ServiceOfferings
		result2 error
	}
	findServiceOfferingsForSpaceByLabelReturnsOnCall map[int]struct {
		result1 models.ServiceOfferings
		result2 error
	}
	FindServicePlanByDescriptionStub        func(resources.ServicePlanDescription) (string, error)
	findServicePlanByDescriptionMutex       sync.RWMutex
	findServicePlanByDescriptionArgsForCall []struct {
		arg1 resources.ServicePlanDescription
	}
	findServicePlanByDescriptionReturns struct {
		result1 string
		result2 error
	}
	findServicePlanByDescriptionReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	GetAllServiceOfferingsStub        func() (models.ServiceOfferings, error)
	getAllServiceOfferingsMutex       sync.RWMutex
	getAllServiceOfferingsArgsForCall []struct {
	}
	getAllServiceOfferingsReturns struct {
		result1 models.ServiceOfferings
		result2 error
	}
	getAllServiceOfferingsReturnsOnCall map[int]struct {
		result1 models.ServiceOfferings
		result2 error
	}
	GetServiceInstanceCountForServicePlanStub        func(string) (int, error)
	getServiceInstanceCountForServicePlanMutex       sync.RWMutex
	getServiceInstanceCountForServicePlanArgsForCall []struct {
		arg1 string
	}
	getServiceInstanceCountForServicePlanReturns struct {
		result1 int
		result2 error
	}
	getServiceInstanceCountForServicePlanReturnsOnCall map[int]struct {
		result1 int
		result2 error
	}
	GetServiceOfferingByGUIDStub        func(string) (models.ServiceOffering, error)
	getServiceOfferingByGUIDMutex       sync.RWMutex
	getServiceOfferingByGUIDArgsForCall []struct {
		arg1 string
	}
	getServiceOfferingByGUIDReturns struct {
		result1 models.ServiceOffering
		result2 error
	}
	getServiceOfferingByGUIDReturnsOnCall map[int]struct {
		result1 models.ServiceOffering
		result2 error
	}
	GetServiceOfferingsForSpaceStub        func(string) (models.ServiceOfferings, error)
	getServiceOfferingsForSpaceMutex       sync.RWMutex
	getServiceOfferingsForSpaceArgsForCall []struct {
		arg1 string
	}
	getServiceOfferingsForSpaceReturns struct {
		result1 models.ServiceOfferings
		result2 error
	}
	getServiceOfferingsForSpaceReturnsOnCall map[int]struct {
		result1 models.ServiceOfferings
		result2 error
	}
	ListServicesFromBrokerStub        func(string) ([]models.ServiceOffering, error)
	listServicesFromBrokerMutex       sync.RWMutex
	listServicesFromBrokerArgsForCall []struct {
		arg1 string
	}
	listServicesFromBrokerReturns struct {
		result1 []models.ServiceOffering
		result2 error
	}
	listServicesFromBrokerReturnsOnCall map[int]struct {
		result1 []models.ServiceOffering
		result2 error
	}
	ListServicesFromManyBrokersStub        func([]string) ([]models.ServiceOffering, error)
	listServicesFromManyBrokersMutex       sync.RWMutex
	listServicesFromManyBrokersArgsForCall []struct {
		arg1 []string
	}
	listServicesFromManyBrokersReturns struct {
		result1 []models.ServiceOffering
		result2 error
	}
	listServicesFromManyBrokersReturnsOnCall map[int]struct {
		result1 []models.ServiceOffering
		result2 error
	}
	MigrateServicePlanFromV1ToV2Stub        func(string, string) (int, error)
	migrateServicePlanFromV1ToV2Mutex       sync.RWMutex
	migrateServicePlanFromV1ToV2ArgsForCall []struct {
		arg1 string
		arg2 string
	}
	migrateServicePlanFromV1ToV2Returns struct {
		result1 int
		result2 error
	}
	migrateServicePlanFromV1ToV2ReturnsOnCall map[int]struct {
		result1 int
		result2 error
	}
	PurgeServiceInstanceStub        func(models.ServiceInstance) error
	purgeServiceInstanceMutex       sync.RWMutex
	purgeServiceInstanceArgsForCall []struct {
		arg1 models.ServiceInstance
	}
	purgeServiceInstanceReturns struct {
		result1 error
	}
	purgeServiceInstanceReturnsOnCall map[int]struct {
		result1 error
	}
	PurgeServiceOfferingStub        func(models.ServiceOffering) error
	purgeServiceOfferingMutex       sync.RWMutex
	purgeServiceOfferingArgsForCall []struct {
		arg1 models.ServiceOffering
	}
	purgeServiceOfferingReturns struct {
		result1 error
	}
	purgeServiceOfferingReturnsOnCall map[int]struct {
		result1 error
	}
	RenameServiceStub        func(models.ServiceInstance, string) error
	renameServiceMutex       sync.RWMutex
	renameServiceArgsForCall []struct {
		arg1 models.ServiceInstance
		arg2 string
	}
	renameServiceReturns struct {
		result1 error
	}
	renameServiceReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateServiceInstanceStub        func(string, string, map[string]interface{}, []string) error
	updateServiceInstanceMutex       sync.RWMutex
	updateServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 map[string]interface{}
		arg4 []string
	}
	updateServiceInstanceReturns struct {
		result1 error
	}
	updateServiceInstanceReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeServiceRepository) CreateServiceInstance(arg1 string, arg2 string, arg3 map[string]interface{}, arg4 []string) error {
	var arg4Copy []string
	if arg4 != nil {
		arg4Copy = make([]string, len(arg4))
		copy(arg4Copy, arg4)
	}
	fake.createServiceInstanceMutex.Lock()
	ret, specificReturn := fake.createServiceInstanceReturnsOnCall[len(fake.createServiceInstanceArgsForCall)]
	fake.createServiceInstanceArgsForCall = append(fake.createServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 map[string]interface{}
		arg4 []string
	}{arg1, arg2, arg3, arg4Copy})
	fake.recordInvocation("CreateServiceInstance", []interface{}{arg1, arg2, arg3, arg4Copy})
	fake.createServiceInstanceMutex.Unlock()
	if fake.CreateServiceInstanceStub != nil {
		return fake.CreateServiceInstanceStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.createServiceInstanceReturns
	return fakeReturns.result1
}

func (fake *FakeServiceRepository) CreateServiceInstanceCallCount() int {
	fake.createServiceInstanceMutex.RLock()
	defer fake.createServiceInstanceMutex.RUnlock()
	return len(fake.createServiceInstanceArgsForCall)
}

func (fake *FakeServiceRepository) CreateServiceInstanceCalls(stub func(string, string, map[string]interface{}, []string) error) {
	fake.createServiceInstanceMutex.Lock()
	defer fake.createServiceInstanceMutex.Unlock()
	fake.CreateServiceInstanceStub = stub
}

func (fake *FakeServiceRepository) CreateServiceInstanceArgsForCall(i int) (string, string, map[string]interface{}, []string) {
	fake.createServiceInstanceMutex.RLock()
	defer fake.createServiceInstanceMutex.RUnlock()
	argsForCall := fake.createServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeServiceRepository) CreateServiceInstanceReturns(result1 error) {
	fake.createServiceInstanceMutex.Lock()
	defer fake.createServiceInstanceMutex.Unlock()
	fake.CreateServiceInstanceStub = nil
	fake.createServiceInstanceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) CreateServiceInstanceReturnsOnCall(i int, result1 error) {
	fake.createServiceInstanceMutex.Lock()
	defer fake.createServiceInstanceMutex.Unlock()
	fake.CreateServiceInstanceStub = nil
	if fake.createServiceInstanceReturnsOnCall == nil {
		fake.createServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createServiceInstanceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) DeleteService(arg1 models.ServiceInstance) error {
	fake.deleteServiceMutex.Lock()
	ret, specificReturn := fake.deleteServiceReturnsOnCall[len(fake.deleteServiceArgsForCall)]
	fake.deleteServiceArgsForCall = append(fake.deleteServiceArgsForCall, struct {
		arg1 models.ServiceInstance
	}{arg1})
	fake.recordInvocation("DeleteService", []interface{}{arg1})
	fake.deleteServiceMutex.Unlock()
	if fake.DeleteServiceStub != nil {
		return fake.DeleteServiceStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.deleteServiceReturns
	return fakeReturns.result1
}

func (fake *FakeServiceRepository) DeleteServiceCallCount() int {
	fake.deleteServiceMutex.RLock()
	defer fake.deleteServiceMutex.RUnlock()
	return len(fake.deleteServiceArgsForCall)
}

func (fake *FakeServiceRepository) DeleteServiceCalls(stub func(models.ServiceInstance) error) {
	fake.deleteServiceMutex.Lock()
	defer fake.deleteServiceMutex.Unlock()
	fake.DeleteServiceStub = stub
}

func (fake *FakeServiceRepository) DeleteServiceArgsForCall(i int) models.ServiceInstance {
	fake.deleteServiceMutex.RLock()
	defer fake.deleteServiceMutex.RUnlock()
	argsForCall := fake.deleteServiceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) DeleteServiceReturns(result1 error) {
	fake.deleteServiceMutex.Lock()
	defer fake.deleteServiceMutex.Unlock()
	fake.DeleteServiceStub = nil
	fake.deleteServiceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) DeleteServiceReturnsOnCall(i int, result1 error) {
	fake.deleteServiceMutex.Lock()
	defer fake.deleteServiceMutex.Unlock()
	fake.DeleteServiceStub = nil
	if fake.deleteServiceReturnsOnCall == nil {
		fake.deleteServiceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteServiceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) FindInstanceByName(arg1 string) (models.ServiceInstance, error) {
	fake.findInstanceByNameMutex.Lock()
	ret, specificReturn := fake.findInstanceByNameReturnsOnCall[len(fake.findInstanceByNameArgsForCall)]
	fake.findInstanceByNameArgsForCall = append(fake.findInstanceByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("FindInstanceByName", []interface{}{arg1})
	fake.findInstanceByNameMutex.Unlock()
	if fake.FindInstanceByNameStub != nil {
		return fake.FindInstanceByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findInstanceByNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) FindInstanceByNameCallCount() int {
	fake.findInstanceByNameMutex.RLock()
	defer fake.findInstanceByNameMutex.RUnlock()
	return len(fake.findInstanceByNameArgsForCall)
}

func (fake *FakeServiceRepository) FindInstanceByNameCalls(stub func(string) (models.ServiceInstance, error)) {
	fake.findInstanceByNameMutex.Lock()
	defer fake.findInstanceByNameMutex.Unlock()
	fake.FindInstanceByNameStub = stub
}

func (fake *FakeServiceRepository) FindInstanceByNameArgsForCall(i int) string {
	fake.findInstanceByNameMutex.RLock()
	defer fake.findInstanceByNameMutex.RUnlock()
	argsForCall := fake.findInstanceByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) FindInstanceByNameReturns(result1 models.ServiceInstance, result2 error) {
	fake.findInstanceByNameMutex.Lock()
	defer fake.findInstanceByNameMutex.Unlock()
	fake.FindInstanceByNameStub = nil
	fake.findInstanceByNameReturns = struct {
		result1 models.ServiceInstance
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) FindInstanceByNameReturnsOnCall(i int, result1 models.ServiceInstance, result2 error) {
	fake.findInstanceByNameMutex.Lock()
	defer fake.findInstanceByNameMutex.Unlock()
	fake.FindInstanceByNameStub = nil
	if fake.findInstanceByNameReturnsOnCall == nil {
		fake.findInstanceByNameReturnsOnCall = make(map[int]struct {
			result1 models.ServiceInstance
			result2 error
		})
	}
	fake.findInstanceByNameReturnsOnCall[i] = struct {
		result1 models.ServiceInstance
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) FindServiceOfferingByLabelAndProvider(arg1 string, arg2 string) (models.ServiceOffering, error) {
	fake.findServiceOfferingByLabelAndProviderMutex.Lock()
	ret, specificReturn := fake.findServiceOfferingByLabelAndProviderReturnsOnCall[len(fake.findServiceOfferingByLabelAndProviderArgsForCall)]
	fake.findServiceOfferingByLabelAndProviderArgsForCall = append(fake.findServiceOfferingByLabelAndProviderArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("FindServiceOfferingByLabelAndProvider", []interface{}{arg1, arg2})
	fake.findServiceOfferingByLabelAndProviderMutex.Unlock()
	if fake.FindServiceOfferingByLabelAndProviderStub != nil {
		return fake.FindServiceOfferingByLabelAndProviderStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findServiceOfferingByLabelAndProviderReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) FindServiceOfferingByLabelAndProviderCallCount() int {
	fake.findServiceOfferingByLabelAndProviderMutex.RLock()
	defer fake.findServiceOfferingByLabelAndProviderMutex.RUnlock()
	return len(fake.findServiceOfferingByLabelAndProviderArgsForCall)
}

func (fake *FakeServiceRepository) FindServiceOfferingByLabelAndProviderCalls(stub func(string, string) (models.ServiceOffering, error)) {
	fake.findServiceOfferingByLabelAndProviderMutex.Lock()
	defer fake.findServiceOfferingByLabelAndProviderMutex.Unlock()
	fake.FindServiceOfferingByLabelAndProviderStub = stub
}

func (fake *FakeServiceRepository) FindServiceOfferingByLabelAndProviderArgsForCall(i int) (string, string) {
	fake.findServiceOfferingByLabelAndProviderMutex.RLock()
	defer fake.findServiceOfferingByLabelAndProviderMutex.RUnlock()
	argsForCall := fake.findServiceOfferingByLabelAndProviderArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeServiceRepository) FindServiceOfferingByLabelAndProviderReturns(result1 models.ServiceOffering, result2 error) {
	fake.findServiceOfferingByLabelAndProviderMutex.Lock()
	defer fake.findServiceOfferingByLabelAndProviderMutex.Unlock()
	fake.FindServiceOfferingByLabelAndProviderStub = nil
	fake.findServiceOfferingByLabelAndProviderReturns = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) FindServiceOfferingByLabelAndProviderReturnsOnCall(i int, result1 models.ServiceOffering, result2 error) {
	fake.findServiceOfferingByLabelAndProviderMutex.Lock()
	defer fake.findServiceOfferingByLabelAndProviderMutex.Unlock()
	fake.FindServiceOfferingByLabelAndProviderStub = nil
	if fake.findServiceOfferingByLabelAndProviderReturnsOnCall == nil {
		fake.findServiceOfferingByLabelAndProviderReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOffering
			result2 error
		})
	}
	fake.findServiceOfferingByLabelAndProviderReturnsOnCall[i] = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) FindServiceOfferingsByLabel(arg1 string) (models.ServiceOfferings, error) {
	fake.findServiceOfferingsByLabelMutex.Lock()
	ret, specificReturn := fake.findServiceOfferingsByLabelReturnsOnCall[len(fake.findServiceOfferingsByLabelArgsForCall)]
	fake.findServiceOfferingsByLabelArgsForCall = append(fake.findServiceOfferingsByLabelArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("FindServiceOfferingsByLabel", []interface{}{arg1})
	fake.findServiceOfferingsByLabelMutex.Unlock()
	if fake.FindServiceOfferingsByLabelStub != nil {
		return fake.FindServiceOfferingsByLabelStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findServiceOfferingsByLabelReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) FindServiceOfferingsByLabelCallCount() int {
	fake.findServiceOfferingsByLabelMutex.RLock()
	defer fake.findServiceOfferingsByLabelMutex.RUnlock()
	return len(fake.findServiceOfferingsByLabelArgsForCall)
}

func (fake *FakeServiceRepository) FindServiceOfferingsByLabelCalls(stub func(string) (models.ServiceOfferings, error)) {
	fake.findServiceOfferingsByLabelMutex.Lock()
	defer fake.findServiceOfferingsByLabelMutex.Unlock()
	fake.FindServiceOfferingsByLabelStub = stub
}

func (fake *FakeServiceRepository) FindServiceOfferingsByLabelArgsForCall(i int) string {
	fake.findServiceOfferingsByLabelMutex.RLock()
	defer fake.findServiceOfferingsByLabelMutex.RUnlock()
	argsForCall := fake.findServiceOfferingsByLabelArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) FindServiceOfferingsByLabelReturns(result1 models.ServiceOfferings, result2 error) {
	fake.findServiceOfferingsByLabelMutex.Lock()
	defer fake.findServiceOfferingsByLabelMutex.Unlock()
	fake.FindServiceOfferingsByLabelStub = nil
	fake.findServiceOfferingsByLabelReturns = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) FindServiceOfferingsByLabelReturnsOnCall(i int, result1 models.ServiceOfferings, result2 error) {
	fake.findServiceOfferingsByLabelMutex.Lock()
	defer fake.findServiceOfferingsByLabelMutex.Unlock()
	fake.FindServiceOfferingsByLabelStub = nil
	if fake.findServiceOfferingsByLabelReturnsOnCall == nil {
		fake.findServiceOfferingsByLabelReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOfferings
			result2 error
		})
	}
	fake.findServiceOfferingsByLabelReturnsOnCall[i] = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) FindServiceOfferingsForSpaceByLabel(arg1 string, arg2 string) (models.ServiceOfferings, error) {
	fake.findServiceOfferingsForSpaceByLabelMutex.Lock()
	ret, specificReturn := fake.findServiceOfferingsForSpaceByLabelReturnsOnCall[len(fake.findServiceOfferingsForSpaceByLabelArgsForCall)]
	fake.findServiceOfferingsForSpaceByLabelArgsForCall = append(fake.findServiceOfferingsForSpaceByLabelArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("FindServiceOfferingsForSpaceByLabel", []interface{}{arg1, arg2})
	fake.findServiceOfferingsForSpaceByLabelMutex.Unlock()
	if fake.FindServiceOfferingsForSpaceByLabelStub != nil {
		return fake.FindServiceOfferingsForSpaceByLabelStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findServiceOfferingsForSpaceByLabelReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) FindServiceOfferingsForSpaceByLabelCallCount() int {
	fake.findServiceOfferingsForSpaceByLabelMutex.RLock()
	defer fake.findServiceOfferingsForSpaceByLabelMutex.RUnlock()
	return len(fake.findServiceOfferingsForSpaceByLabelArgsForCall)
}

func (fake *FakeServiceRepository) FindServiceOfferingsForSpaceByLabelCalls(stub func(string, string) (models.ServiceOfferings, error)) {
	fake.findServiceOfferingsForSpaceByLabelMutex.Lock()
	defer fake.findServiceOfferingsForSpaceByLabelMutex.Unlock()
	fake.FindServiceOfferingsForSpaceByLabelStub = stub
}

func (fake *FakeServiceRepository) FindServiceOfferingsForSpaceByLabelArgsForCall(i int) (string, string) {
	fake.findServiceOfferingsForSpaceByLabelMutex.RLock()
	defer fake.findServiceOfferingsForSpaceByLabelMutex.RUnlock()
	argsForCall := fake.findServiceOfferingsForSpaceByLabelArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeServiceRepository) FindServiceOfferingsForSpaceByLabelReturns(result1 models.ServiceOfferings, result2 error) {
	fake.findServiceOfferingsForSpaceByLabelMutex.Lock()
	defer fake.findServiceOfferingsForSpaceByLabelMutex.Unlock()
	fake.FindServiceOfferingsForSpaceByLabelStub = nil
	fake.findServiceOfferingsForSpaceByLabelReturns = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) FindServiceOfferingsForSpaceByLabelReturnsOnCall(i int, result1 models.ServiceOfferings, result2 error) {
	fake.findServiceOfferingsForSpaceByLabelMutex.Lock()
	defer fake.findServiceOfferingsForSpaceByLabelMutex.Unlock()
	fake.FindServiceOfferingsForSpaceByLabelStub = nil
	if fake.findServiceOfferingsForSpaceByLabelReturnsOnCall == nil {
		fake.findServiceOfferingsForSpaceByLabelReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOfferings
			result2 error
		})
	}
	fake.findServiceOfferingsForSpaceByLabelReturnsOnCall[i] = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) FindServicePlanByDescription(arg1 resources.ServicePlanDescription) (string, error) {
	fake.findServicePlanByDescriptionMutex.Lock()
	ret, specificReturn := fake.findServicePlanByDescriptionReturnsOnCall[len(fake.findServicePlanByDescriptionArgsForCall)]
	fake.findServicePlanByDescriptionArgsForCall = append(fake.findServicePlanByDescriptionArgsForCall, struct {
		arg1 resources.ServicePlanDescription
	}{arg1})
	fake.recordInvocation("FindServicePlanByDescription", []interface{}{arg1})
	fake.findServicePlanByDescriptionMutex.Unlock()
	if fake.FindServicePlanByDescriptionStub != nil {
		return fake.FindServicePlanByDescriptionStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findServicePlanByDescriptionReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) FindServicePlanByDescriptionCallCount() int {
	fake.findServicePlanByDescriptionMutex.RLock()
	defer fake.findServicePlanByDescriptionMutex.RUnlock()
	return len(fake.findServicePlanByDescriptionArgsForCall)
}

func (fake *FakeServiceRepository) FindServicePlanByDescriptionCalls(stub func(resources.ServicePlanDescription) (string, error)) {
	fake.findServicePlanByDescriptionMutex.Lock()
	defer fake.findServicePlanByDescriptionMutex.Unlock()
	fake.FindServicePlanByDescriptionStub = stub
}

func (fake *FakeServiceRepository) FindServicePlanByDescriptionArgsForCall(i int) resources.ServicePlanDescription {
	fake.findServicePlanByDescriptionMutex.RLock()
	defer fake.findServicePlanByDescriptionMutex.RUnlock()
	argsForCall := fake.findServicePlanByDescriptionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) FindServicePlanByDescriptionReturns(result1 string, result2 error) {
	fake.findServicePlanByDescriptionMutex.Lock()
	defer fake.findServicePlanByDescriptionMutex.Unlock()
	fake.FindServicePlanByDescriptionStub = nil
	fake.findServicePlanByDescriptionReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) FindServicePlanByDescriptionReturnsOnCall(i int, result1 string, result2 error) {
	fake.findServicePlanByDescriptionMutex.Lock()
	defer fake.findServicePlanByDescriptionMutex.Unlock()
	fake.FindServicePlanByDescriptionStub = nil
	if fake.findServicePlanByDescriptionReturnsOnCall == nil {
		fake.findServicePlanByDescriptionReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.findServicePlanByDescriptionReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) GetAllServiceOfferings() (models.ServiceOfferings, error) {
	fake.getAllServiceOfferingsMutex.Lock()
	ret, specificReturn := fake.getAllServiceOfferingsReturnsOnCall[len(fake.getAllServiceOfferingsArgsForCall)]
	fake.getAllServiceOfferingsArgsForCall = append(fake.getAllServiceOfferingsArgsForCall, struct {
	}{})
	fake.recordInvocation("GetAllServiceOfferings", []interface{}{})
	fake.getAllServiceOfferingsMutex.Unlock()
	if fake.GetAllServiceOfferingsStub != nil {
		return fake.GetAllServiceOfferingsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getAllServiceOfferingsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) GetAllServiceOfferingsCallCount() int {
	fake.getAllServiceOfferingsMutex.RLock()
	defer fake.getAllServiceOfferingsMutex.RUnlock()
	return len(fake.getAllServiceOfferingsArgsForCall)
}

func (fake *FakeServiceRepository) GetAllServiceOfferingsCalls(stub func() (models.ServiceOfferings, error)) {
	fake.getAllServiceOfferingsMutex.Lock()
	defer fake.getAllServiceOfferingsMutex.Unlock()
	fake.GetAllServiceOfferingsStub = stub
}

func (fake *FakeServiceRepository) GetAllServiceOfferingsReturns(result1 models.ServiceOfferings, result2 error) {
	fake.getAllServiceOfferingsMutex.Lock()
	defer fake.getAllServiceOfferingsMutex.Unlock()
	fake.GetAllServiceOfferingsStub = nil
	fake.getAllServiceOfferingsReturns = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) GetAllServiceOfferingsReturnsOnCall(i int, result1 models.ServiceOfferings, result2 error) {
	fake.getAllServiceOfferingsMutex.Lock()
	defer fake.getAllServiceOfferingsMutex.Unlock()
	fake.GetAllServiceOfferingsStub = nil
	if fake.getAllServiceOfferingsReturnsOnCall == nil {
		fake.getAllServiceOfferingsReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOfferings
			result2 error
		})
	}
	fake.getAllServiceOfferingsReturnsOnCall[i] = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) GetServiceInstanceCountForServicePlan(arg1 string) (int, error) {
	fake.getServiceInstanceCountForServicePlanMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceCountForServicePlanReturnsOnCall[len(fake.getServiceInstanceCountForServicePlanArgsForCall)]
	fake.getServiceInstanceCountForServicePlanArgsForCall = append(fake.getServiceInstanceCountForServicePlanArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceInstanceCountForServicePlan", []interface{}{arg1})
	fake.getServiceInstanceCountForServicePlanMutex.Unlock()
	if fake.GetServiceInstanceCountForServicePlanStub != nil {
		return fake.GetServiceInstanceCountForServicePlanStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServiceInstanceCountForServicePlanReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) GetServiceInstanceCountForServicePlanCallCount() int {
	fake.getServiceInstanceCountForServicePlanMutex.RLock()
	defer fake.getServiceInstanceCountForServicePlanMutex.RUnlock()
	return len(fake.getServiceInstanceCountForServicePlanArgsForCall)
}

func (fake *FakeServiceRepository) GetServiceInstanceCountForServicePlanCalls(stub func(string) (int, error)) {
	fake.getServiceInstanceCountForServicePlanMutex.Lock()
	defer fake.getServiceInstanceCountForServicePlanMutex.Unlock()
	fake.GetServiceInstanceCountForServicePlanStub = stub
}

func (fake *FakeServiceRepository) GetServiceInstanceCountForServicePlanArgsForCall(i int) string {
	fake.getServiceInstanceCountForServicePlanMutex.RLock()
	defer fake.getServiceInstanceCountForServicePlanMutex.RUnlock()
	argsForCall := fake.getServiceInstanceCountForServicePlanArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) GetServiceInstanceCountForServicePlanReturns(result1 int, result2 error) {
	fake.getServiceInstanceCountForServicePlanMutex.Lock()
	defer fake.getServiceInstanceCountForServicePlanMutex.Unlock()
	fake.GetServiceInstanceCountForServicePlanStub = nil
	fake.getServiceInstanceCountForServicePlanReturns = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) GetServiceInstanceCountForServicePlanReturnsOnCall(i int, result1 int, result2 error) {
	fake.getServiceInstanceCountForServicePlanMutex.Lock()
	defer fake.getServiceInstanceCountForServicePlanMutex.Unlock()
	fake.GetServiceInstanceCountForServicePlanStub = nil
	if fake.getServiceInstanceCountForServicePlanReturnsOnCall == nil {
		fake.getServiceInstanceCountForServicePlanReturnsOnCall = make(map[int]struct {
			result1 int
			result2 error
		})
	}
	fake.getServiceInstanceCountForServicePlanReturnsOnCall[i] = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) GetServiceOfferingByGUID(arg1 string) (models.ServiceOffering, error) {
	fake.getServiceOfferingByGUIDMutex.Lock()
	ret, specificReturn := fake.getServiceOfferingByGUIDReturnsOnCall[len(fake.getServiceOfferingByGUIDArgsForCall)]
	fake.getServiceOfferingByGUIDArgsForCall = append(fake.getServiceOfferingByGUIDArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceOfferingByGUID", []interface{}{arg1})
	fake.getServiceOfferingByGUIDMutex.Unlock()
	if fake.GetServiceOfferingByGUIDStub != nil {
		return fake.GetServiceOfferingByGUIDStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServiceOfferingByGUIDReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) GetServiceOfferingByGUIDCallCount() int {
	fake.getServiceOfferingByGUIDMutex.RLock()
	defer fake.getServiceOfferingByGUIDMutex.RUnlock()
	return len(fake.getServiceOfferingByGUIDArgsForCall)
}

func (fake *FakeServiceRepository) GetServiceOfferingByGUIDCalls(stub func(string) (models.ServiceOffering, error)) {
	fake.getServiceOfferingByGUIDMutex.Lock()
	defer fake.getServiceOfferingByGUIDMutex.Unlock()
	fake.GetServiceOfferingByGUIDStub = stub
}

func (fake *FakeServiceRepository) GetServiceOfferingByGUIDArgsForCall(i int) string {
	fake.getServiceOfferingByGUIDMutex.RLock()
	defer fake.getServiceOfferingByGUIDMutex.RUnlock()
	argsForCall := fake.getServiceOfferingByGUIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) GetServiceOfferingByGUIDReturns(result1 models.ServiceOffering, result2 error) {
	fake.getServiceOfferingByGUIDMutex.Lock()
	defer fake.getServiceOfferingByGUIDMutex.Unlock()
	fake.GetServiceOfferingByGUIDStub = nil
	fake.getServiceOfferingByGUIDReturns = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) GetServiceOfferingByGUIDReturnsOnCall(i int, result1 models.ServiceOffering, result2 error) {
	fake.getServiceOfferingByGUIDMutex.Lock()
	defer fake.getServiceOfferingByGUIDMutex.Unlock()
	fake.GetServiceOfferingByGUIDStub = nil
	if fake.getServiceOfferingByGUIDReturnsOnCall == nil {
		fake.getServiceOfferingByGUIDReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOffering
			result2 error
		})
	}
	fake.getServiceOfferingByGUIDReturnsOnCall[i] = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) GetServiceOfferingsForSpace(arg1 string) (models.ServiceOfferings, error) {
	fake.getServiceOfferingsForSpaceMutex.Lock()
	ret, specificReturn := fake.getServiceOfferingsForSpaceReturnsOnCall[len(fake.getServiceOfferingsForSpaceArgsForCall)]
	fake.getServiceOfferingsForSpaceArgsForCall = append(fake.getServiceOfferingsForSpaceArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceOfferingsForSpace", []interface{}{arg1})
	fake.getServiceOfferingsForSpaceMutex.Unlock()
	if fake.GetServiceOfferingsForSpaceStub != nil {
		return fake.GetServiceOfferingsForSpaceStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServiceOfferingsForSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) GetServiceOfferingsForSpaceCallCount() int {
	fake.getServiceOfferingsForSpaceMutex.RLock()
	defer fake.getServiceOfferingsForSpaceMutex.RUnlock()
	return len(fake.getServiceOfferingsForSpaceArgsForCall)
}

func (fake *FakeServiceRepository) GetServiceOfferingsForSpaceCalls(stub func(string) (models.ServiceOfferings, error)) {
	fake.getServiceOfferingsForSpaceMutex.Lock()
	defer fake.getServiceOfferingsForSpaceMutex.Unlock()
	fake.GetServiceOfferingsForSpaceStub = stub
}

func (fake *FakeServiceRepository) GetServiceOfferingsForSpaceArgsForCall(i int) string {
	fake.getServiceOfferingsForSpaceMutex.RLock()
	defer fake.getServiceOfferingsForSpaceMutex.RUnlock()
	argsForCall := fake.getServiceOfferingsForSpaceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) GetServiceOfferingsForSpaceReturns(result1 models.ServiceOfferings, result2 error) {
	fake.getServiceOfferingsForSpaceMutex.Lock()
	defer fake.getServiceOfferingsForSpaceMutex.Unlock()
	fake.GetServiceOfferingsForSpaceStub = nil
	fake.getServiceOfferingsForSpaceReturns = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) GetServiceOfferingsForSpaceReturnsOnCall(i int, result1 models.ServiceOfferings, result2 error) {
	fake.getServiceOfferingsForSpaceMutex.Lock()
	defer fake.getServiceOfferingsForSpaceMutex.Unlock()
	fake.GetServiceOfferingsForSpaceStub = nil
	if fake.getServiceOfferingsForSpaceReturnsOnCall == nil {
		fake.getServiceOfferingsForSpaceReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOfferings
			result2 error
		})
	}
	fake.getServiceOfferingsForSpaceReturnsOnCall[i] = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) ListServicesFromBroker(arg1 string) ([]models.ServiceOffering, error) {
	fake.listServicesFromBrokerMutex.Lock()
	ret, specificReturn := fake.listServicesFromBrokerReturnsOnCall[len(fake.listServicesFromBrokerArgsForCall)]
	fake.listServicesFromBrokerArgsForCall = append(fake.listServicesFromBrokerArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("ListServicesFromBroker", []interface{}{arg1})
	fake.listServicesFromBrokerMutex.Unlock()
	if fake.ListServicesFromBrokerStub != nil {
		return fake.ListServicesFromBrokerStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.listServicesFromBrokerReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) ListServicesFromBrokerCallCount() int {
	fake.listServicesFromBrokerMutex.RLock()
	defer fake.listServicesFromBrokerMutex.RUnlock()
	return len(fake.listServicesFromBrokerArgsForCall)
}

func (fake *FakeServiceRepository) ListServicesFromBrokerCalls(stub func(string) ([]models.ServiceOffering, error)) {
	fake.listServicesFromBrokerMutex.Lock()
	defer fake.listServicesFromBrokerMutex.Unlock()
	fake.ListServicesFromBrokerStub = stub
}

func (fake *FakeServiceRepository) ListServicesFromBrokerArgsForCall(i int) string {
	fake.listServicesFromBrokerMutex.RLock()
	defer fake.listServicesFromBrokerMutex.RUnlock()
	argsForCall := fake.listServicesFromBrokerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) ListServicesFromBrokerReturns(result1 []models.ServiceOffering, result2 error) {
	fake.listServicesFromBrokerMutex.Lock()
	defer fake.listServicesFromBrokerMutex.Unlock()
	fake.ListServicesFromBrokerStub = nil
	fake.listServicesFromBrokerReturns = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) ListServicesFromBrokerReturnsOnCall(i int, result1 []models.ServiceOffering, result2 error) {
	fake.listServicesFromBrokerMutex.Lock()
	defer fake.listServicesFromBrokerMutex.Unlock()
	fake.ListServicesFromBrokerStub = nil
	if fake.listServicesFromBrokerReturnsOnCall == nil {
		fake.listServicesFromBrokerReturnsOnCall = make(map[int]struct {
			result1 []models.ServiceOffering
			result2 error
		})
	}
	fake.listServicesFromBrokerReturnsOnCall[i] = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) ListServicesFromManyBrokers(arg1 []string) ([]models.ServiceOffering, error) {
	var arg1Copy []string
	if arg1 != nil {
		arg1Copy = make([]string, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.listServicesFromManyBrokersMutex.Lock()
	ret, specificReturn := fake.listServicesFromManyBrokersReturnsOnCall[len(fake.listServicesFromManyBrokersArgsForCall)]
	fake.listServicesFromManyBrokersArgsForCall = append(fake.listServicesFromManyBrokersArgsForCall, struct {
		arg1 []string
	}{arg1Copy})
	fake.recordInvocation("ListServicesFromManyBrokers", []interface{}{arg1Copy})
	fake.listServicesFromManyBrokersMutex.Unlock()
	if fake.ListServicesFromManyBrokersStub != nil {
		return fake.ListServicesFromManyBrokersStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.listServicesFromManyBrokersReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) ListServicesFromManyBrokersCallCount() int {
	fake.listServicesFromManyBrokersMutex.RLock()
	defer fake.listServicesFromManyBrokersMutex.RUnlock()
	return len(fake.listServicesFromManyBrokersArgsForCall)
}

func (fake *FakeServiceRepository) ListServicesFromManyBrokersCalls(stub func([]string) ([]models.ServiceOffering, error)) {
	fake.listServicesFromManyBrokersMutex.Lock()
	defer fake.listServicesFromManyBrokersMutex.Unlock()
	fake.ListServicesFromManyBrokersStub = stub
}

func (fake *FakeServiceRepository) ListServicesFromManyBrokersArgsForCall(i int) []string {
	fake.listServicesFromManyBrokersMutex.RLock()
	defer fake.listServicesFromManyBrokersMutex.RUnlock()
	argsForCall := fake.listServicesFromManyBrokersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) ListServicesFromManyBrokersReturns(result1 []models.ServiceOffering, result2 error) {
	fake.listServicesFromManyBrokersMutex.Lock()
	defer fake.listServicesFromManyBrokersMutex.Unlock()
	fake.ListServicesFromManyBrokersStub = nil
	fake.listServicesFromManyBrokersReturns = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) ListServicesFromManyBrokersReturnsOnCall(i int, result1 []models.ServiceOffering, result2 error) {
	fake.listServicesFromManyBrokersMutex.Lock()
	defer fake.listServicesFromManyBrokersMutex.Unlock()
	fake.ListServicesFromManyBrokersStub = nil
	if fake.listServicesFromManyBrokersReturnsOnCall == nil {
		fake.listServicesFromManyBrokersReturnsOnCall = make(map[int]struct {
			result1 []models.ServiceOffering
			result2 error
		})
	}
	fake.listServicesFromManyBrokersReturnsOnCall[i] = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) MigrateServicePlanFromV1ToV2(arg1 string, arg2 string) (int, error) {
	fake.migrateServicePlanFromV1ToV2Mutex.Lock()
	ret, specificReturn := fake.migrateServicePlanFromV1ToV2ReturnsOnCall[len(fake.migrateServicePlanFromV1ToV2ArgsForCall)]
	fake.migrateServicePlanFromV1ToV2ArgsForCall = append(fake.migrateServicePlanFromV1ToV2ArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("MigrateServicePlanFromV1ToV2", []interface{}{arg1, arg2})
	fake.migrateServicePlanFromV1ToV2Mutex.Unlock()
	if fake.MigrateServicePlanFromV1ToV2Stub != nil {
		return fake.MigrateServicePlanFromV1ToV2Stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.migrateServicePlanFromV1ToV2Returns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceRepository) MigrateServicePlanFromV1ToV2CallCount() int {
	fake.migrateServicePlanFromV1ToV2Mutex.RLock()
	defer fake.migrateServicePlanFromV1ToV2Mutex.RUnlock()
	return len(fake.migrateServicePlanFromV1ToV2ArgsForCall)
}

func (fake *FakeServiceRepository) MigrateServicePlanFromV1ToV2Calls(stub func(string, string) (int, error)) {
	fake.migrateServicePlanFromV1ToV2Mutex.Lock()
	defer fake.migrateServicePlanFromV1ToV2Mutex.Unlock()
	fake.MigrateServicePlanFromV1ToV2Stub = stub
}

func (fake *FakeServiceRepository) MigrateServicePlanFromV1ToV2ArgsForCall(i int) (string, string) {
	fake.migrateServicePlanFromV1ToV2Mutex.RLock()
	defer fake.migrateServicePlanFromV1ToV2Mutex.RUnlock()
	argsForCall := fake.migrateServicePlanFromV1ToV2ArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeServiceRepository) MigrateServicePlanFromV1ToV2Returns(result1 int, result2 error) {
	fake.migrateServicePlanFromV1ToV2Mutex.Lock()
	defer fake.migrateServicePlanFromV1ToV2Mutex.Unlock()
	fake.MigrateServicePlanFromV1ToV2Stub = nil
	fake.migrateServicePlanFromV1ToV2Returns = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) MigrateServicePlanFromV1ToV2ReturnsOnCall(i int, result1 int, result2 error) {
	fake.migrateServicePlanFromV1ToV2Mutex.Lock()
	defer fake.migrateServicePlanFromV1ToV2Mutex.Unlock()
	fake.MigrateServicePlanFromV1ToV2Stub = nil
	if fake.migrateServicePlanFromV1ToV2ReturnsOnCall == nil {
		fake.migrateServicePlanFromV1ToV2ReturnsOnCall = make(map[int]struct {
			result1 int
			result2 error
		})
	}
	fake.migrateServicePlanFromV1ToV2ReturnsOnCall[i] = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceRepository) PurgeServiceInstance(arg1 models.ServiceInstance) error {
	fake.purgeServiceInstanceMutex.Lock()
	ret, specificReturn := fake.purgeServiceInstanceReturnsOnCall[len(fake.purgeServiceInstanceArgsForCall)]
	fake.purgeServiceInstanceArgsForCall = append(fake.purgeServiceInstanceArgsForCall, struct {
		arg1 models.ServiceInstance
	}{arg1})
	fake.recordInvocation("PurgeServiceInstance", []interface{}{arg1})
	fake.purgeServiceInstanceMutex.Unlock()
	if fake.PurgeServiceInstanceStub != nil {
		return fake.PurgeServiceInstanceStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.purgeServiceInstanceReturns
	return fakeReturns.result1
}

func (fake *FakeServiceRepository) PurgeServiceInstanceCallCount() int {
	fake.purgeServiceInstanceMutex.RLock()
	defer fake.purgeServiceInstanceMutex.RUnlock()
	return len(fake.purgeServiceInstanceArgsForCall)
}

func (fake *FakeServiceRepository) PurgeServiceInstanceCalls(stub func(models.ServiceInstance) error) {
	fake.purgeServiceInstanceMutex.Lock()
	defer fake.purgeServiceInstanceMutex.Unlock()
	fake.PurgeServiceInstanceStub = stub
}

func (fake *FakeServiceRepository) PurgeServiceInstanceArgsForCall(i int) models.ServiceInstance {
	fake.purgeServiceInstanceMutex.RLock()
	defer fake.purgeServiceInstanceMutex.RUnlock()
	argsForCall := fake.purgeServiceInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) PurgeServiceInstanceReturns(result1 error) {
	fake.purgeServiceInstanceMutex.Lock()
	defer fake.purgeServiceInstanceMutex.Unlock()
	fake.PurgeServiceInstanceStub = nil
	fake.purgeServiceInstanceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) PurgeServiceInstanceReturnsOnCall(i int, result1 error) {
	fake.purgeServiceInstanceMutex.Lock()
	defer fake.purgeServiceInstanceMutex.Unlock()
	fake.PurgeServiceInstanceStub = nil
	if fake.purgeServiceInstanceReturnsOnCall == nil {
		fake.purgeServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.purgeServiceInstanceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) PurgeServiceOffering(arg1 models.ServiceOffering) error {
	fake.purgeServiceOfferingMutex.Lock()
	ret, specificReturn := fake.purgeServiceOfferingReturnsOnCall[len(fake.purgeServiceOfferingArgsForCall)]
	fake.purgeServiceOfferingArgsForCall = append(fake.purgeServiceOfferingArgsForCall, struct {
		arg1 models.ServiceOffering
	}{arg1})
	fake.recordInvocation("PurgeServiceOffering", []interface{}{arg1})
	fake.purgeServiceOfferingMutex.Unlock()
	if fake.PurgeServiceOfferingStub != nil {
		return fake.PurgeServiceOfferingStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.purgeServiceOfferingReturns
	return fakeReturns.result1
}

func (fake *FakeServiceRepository) PurgeServiceOfferingCallCount() int {
	fake.purgeServiceOfferingMutex.RLock()
	defer fake.purgeServiceOfferingMutex.RUnlock()
	return len(fake.purgeServiceOfferingArgsForCall)
}

func (fake *FakeServiceRepository) PurgeServiceOfferingCalls(stub func(models.ServiceOffering) error) {
	fake.purgeServiceOfferingMutex.Lock()
	defer fake.purgeServiceOfferingMutex.Unlock()
	fake.PurgeServiceOfferingStub = stub
}

func (fake *FakeServiceRepository) PurgeServiceOfferingArgsForCall(i int) models.ServiceOffering {
	fake.purgeServiceOfferingMutex.RLock()
	defer fake.purgeServiceOfferingMutex.RUnlock()
	argsForCall := fake.purgeServiceOfferingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceRepository) PurgeServiceOfferingReturns(result1 error) {
	fake.purgeServiceOfferingMutex.Lock()
	defer fake.purgeServiceOfferingMutex.Unlock()
	fake.PurgeServiceOfferingStub = nil
	fake.purgeServiceOfferingReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) PurgeServiceOfferingReturnsOnCall(i int, result1 error) {
	fake.purgeServiceOfferingMutex.Lock()
	defer fake.purgeServiceOfferingMutex.Unlock()
	fake.PurgeServiceOfferingStub = nil
	if fake.purgeServiceOfferingReturnsOnCall == nil {
		fake.purgeServiceOfferingReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.purgeServiceOfferingReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) RenameService(arg1 models.ServiceInstance, arg2 string) error {
	fake.renameServiceMutex.Lock()
	ret, specificReturn := fake.renameServiceReturnsOnCall[len(fake.renameServiceArgsForCall)]
	fake.renameServiceArgsForCall = append(fake.renameServiceArgsForCall, struct {
		arg1 models.ServiceInstance
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("RenameService", []interface{}{arg1, arg2})
	fake.renameServiceMutex.Unlock()
	if fake.RenameServiceStub != nil {
		return fake.RenameServiceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.renameServiceReturns
	return fakeReturns.result1
}

func (fake *FakeServiceRepository) RenameServiceCallCount() int {
	fake.renameServiceMutex.RLock()
	defer fake.renameServiceMutex.RUnlock()
	return len(fake.renameServiceArgsForCall)
}

func (fake *FakeServiceRepository) RenameServiceCalls(stub func(models.ServiceInstance, string) error) {
	fake.renameServiceMutex.Lock()
	defer fake.renameServiceMutex.Unlock()
	fake.RenameServiceStub = stub
}

func (fake *FakeServiceRepository) RenameServiceArgsForCall(i int) (models.ServiceInstance, string) {
	fake.renameServiceMutex.RLock()
	defer fake.renameServiceMutex.RUnlock()
	argsForCall := fake.renameServiceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeServiceRepository) RenameServiceReturns(result1 error) {
	fake.renameServiceMutex.Lock()
	defer fake.renameServiceMutex.Unlock()
	fake.RenameServiceStub = nil
	fake.renameServiceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) RenameServiceReturnsOnCall(i int, result1 error) {
	fake.renameServiceMutex.Lock()
	defer fake.renameServiceMutex.Unlock()
	fake.RenameServiceStub = nil
	if fake.renameServiceReturnsOnCall == nil {
		fake.renameServiceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.renameServiceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) UpdateServiceInstance(arg1 string, arg2 string, arg3 map[string]interface{}, arg4 []string) error {
	var arg4Copy []string
	if arg4 != nil {
		arg4Copy = make([]string, len(arg4))
		copy(arg4Copy, arg4)
	}
	fake.updateServiceInstanceMutex.Lock()
	ret, specificReturn := fake.updateServiceInstanceReturnsOnCall[len(fake.updateServiceInstanceArgsForCall)]
	fake.updateServiceInstanceArgsForCall = append(fake.updateServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 map[string]interface{}
		arg4 []string
	}{arg1, arg2, arg3, arg4Copy})
	fake.recordInvocation("UpdateServiceInstance", []interface{}{arg1, arg2, arg3, arg4Copy})
	fake.updateServiceInstanceMutex.Unlock()
	if fake.UpdateServiceInstanceStub != nil {
		return fake.UpdateServiceInstanceStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.updateServiceInstanceReturns
	return fakeReturns.result1
}

func (fake *FakeServiceRepository) UpdateServiceInstanceCallCount() int {
	fake.updateServiceInstanceMutex.RLock()
	defer fake.updateServiceInstanceMutex.RUnlock()
	return len(fake.updateServiceInstanceArgsForCall)
}

func (fake *FakeServiceRepository) UpdateServiceInstanceCalls(stub func(string, string, map[string]interface{}, []string) error) {
	fake.updateServiceInstanceMutex.Lock()
	defer fake.updateServiceInstanceMutex.Unlock()
	fake.UpdateServiceInstanceStub = stub
}

func (fake *FakeServiceRepository) UpdateServiceInstanceArgsForCall(i int) (string, string, map[string]interface{}, []string) {
	fake.updateServiceInstanceMutex.RLock()
	defer fake.updateServiceInstanceMutex.RUnlock()
	argsForCall := fake.updateServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeServiceRepository) UpdateServiceInstanceReturns(result1 error) {
	fake.updateServiceInstanceMutex.Lock()
	defer fake.updateServiceInstanceMutex.Unlock()
	fake.UpdateServiceInstanceStub = nil
	fake.updateServiceInstanceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) UpdateServiceInstanceReturnsOnCall(i int, result1 error) {
	fake.updateServiceInstanceMutex.Lock()
	defer fake.updateServiceInstanceMutex.Unlock()
	fake.UpdateServiceInstanceStub = nil
	if fake.updateServiceInstanceReturnsOnCall == nil {
		fake.updateServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateServiceInstanceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeServiceRepository) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.createServiceInstanceMutex.RLock()
	defer fake.createServiceInstanceMutex.RUnlock()
	fake.deleteServiceMutex.RLock()
	defer fake.deleteServiceMutex.RUnlock()
	fake.findInstanceByNameMutex.RLock()
	defer fake.findInstanceByNameMutex.RUnlock()
	fake.findServiceOfferingByLabelAndProviderMutex.RLock()
	defer fake.findServiceOfferingByLabelAndProviderMutex.RUnlock()
	fake.findServiceOfferingsByLabelMutex.RLock()
	defer fake.findServiceOfferingsByLabelMutex.RUnlock()
	fake.findServiceOfferingsForSpaceByLabelMutex.RLock()
	defer fake.findServiceOfferingsForSpaceByLabelMutex.RUnlock()
	fake.findServicePlanByDescriptionMutex.RLock()
	defer fake.findServicePlanByDescriptionMutex.RUnlock()
	fake.getAllServiceOfferingsMutex.RLock()
	defer fake.getAllServiceOfferingsMutex.RUnlock()
	fake.getServiceInstanceCountForServicePlanMutex.RLock()
	defer fake.getServiceInstanceCountForServicePlanMutex.RUnlock()
	fake.getServiceOfferingByGUIDMutex.RLock()
	defer fake.getServiceOfferingByGUIDMutex.RUnlock()
	fake.getServiceOfferingsForSpaceMutex.RLock()
	defer fake.getServiceOfferingsForSpaceMutex.RUnlock()
	fake.listServicesFromBrokerMutex.RLock()
	defer fake.listServicesFromBrokerMutex.RUnlock()
	fake.listServicesFromManyBrokersMutex.RLock()
	defer fake.listServicesFromManyBrokersMutex.RUnlock()
	fake.migrateServicePlanFromV1ToV2Mutex.RLock()
	defer fake.migrateServicePlanFromV1ToV2Mutex.RUnlock()
	fake.purgeServiceInstanceMutex.RLock()
	defer fake.purgeServiceInstanceMutex.RUnlock()
	fake.purgeServiceOfferingMutex.RLock()
	defer fake.purgeServiceOfferingMutex.RUnlock()
	fake.renameServiceMutex.RLock()
	defer fake.renameServiceMutex.RUnlock()
	fake.updateServiceInstanceMutex.RLock()
	defer fake.updateServiceInstanceMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeServiceRepository) 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 _ api.ServiceRepository = new(FakeServiceRepository)