fake_registry_interface.go

// This file was generated by counterfeiter
package fakes

import (
	"sync"

	"code.cloudfoundry.org/gorouter/registry"
	"code.cloudfoundry.org/gorouter/route"
)

type FakeRegistryInterface struct {
	RegisterStub        func(uri route.Uri, endpoint *route.Endpoint)
	registerMutex       sync.RWMutex
	registerArgsForCall []struct {
		uri      route.Uri
		endpoint *route.Endpoint
	}
	UnregisterStub        func(uri route.Uri, endpoint *route.Endpoint)
	unregisterMutex       sync.RWMutex
	unregisterArgsForCall []struct {
		uri      route.Uri
		endpoint *route.Endpoint
	}
	LookupStub        func(uri route.Uri) *route.Pool
	lookupMutex       sync.RWMutex
	lookupArgsForCall []struct {
		uri route.Uri
	}
	lookupReturns struct {
		result1 *route.Pool
	}
	LookupWithInstanceStub        func(uri route.Uri, appId, appIndex string) *route.Pool
	lookupWithInstanceMutex       sync.RWMutex
	lookupWithInstanceArgsForCall []struct {
		uri      route.Uri
		appId    string
		appIndex string
	}
	lookupWithInstanceReturns struct {
		result1 *route.Pool
	}
	StartPruningCycleStub        func()
	startPruningCycleMutex       sync.RWMutex
	startPruningCycleArgsForCall []struct{}
	StopPruningCycleStub         func()
	stopPruningCycleMutex        sync.RWMutex
	stopPruningCycleArgsForCall  []struct{}
	NumUrisStub                  func() int
	numUrisMutex                 sync.RWMutex
	numUrisArgsForCall           []struct{}
	numUrisReturns               struct {
		result1 int
	}
	NumEndpointsStub        func() int
	numEndpointsMutex       sync.RWMutex
	numEndpointsArgsForCall []struct{}
	numEndpointsReturns     struct {
		result1 int
	}
	MarshalJSONStub        func() ([]byte, error)
	marshalJSONMutex       sync.RWMutex
	marshalJSONArgsForCall []struct{}
	marshalJSONReturns     struct {
		result1 []byte
		result2 error
	}
}

func (fake *FakeRegistryInterface) Register(uri route.Uri, endpoint *route.Endpoint) {
	fake.registerMutex.Lock()
	fake.registerArgsForCall = append(fake.registerArgsForCall, struct {
		uri      route.Uri
		endpoint *route.Endpoint
	}{uri, endpoint})
	fake.registerMutex.Unlock()
	if fake.RegisterStub != nil {
		fake.RegisterStub(uri, endpoint)
	}
}

func (fake *FakeRegistryInterface) RegisterCallCount() int {
	fake.registerMutex.RLock()
	defer fake.registerMutex.RUnlock()
	return len(fake.registerArgsForCall)
}

func (fake *FakeRegistryInterface) RegisterArgsForCall(i int) (route.Uri, *route.Endpoint) {
	fake.registerMutex.RLock()
	defer fake.registerMutex.RUnlock()
	return fake.registerArgsForCall[i].uri, fake.registerArgsForCall[i].endpoint
}

func (fake *FakeRegistryInterface) Unregister(uri route.Uri, endpoint *route.Endpoint) {
	fake.unregisterMutex.Lock()
	fake.unregisterArgsForCall = append(fake.unregisterArgsForCall, struct {
		uri      route.Uri
		endpoint *route.Endpoint
	}{uri, endpoint})
	fake.unregisterMutex.Unlock()
	if fake.UnregisterStub != nil {
		fake.UnregisterStub(uri, endpoint)
	}
}

func (fake *FakeRegistryInterface) UnregisterCallCount() int {
	fake.unregisterMutex.RLock()
	defer fake.unregisterMutex.RUnlock()
	return len(fake.unregisterArgsForCall)
}

func (fake *FakeRegistryInterface) UnregisterArgsForCall(i int) (route.Uri, *route.Endpoint) {
	fake.unregisterMutex.RLock()
	defer fake.unregisterMutex.RUnlock()
	return fake.unregisterArgsForCall[i].uri, fake.unregisterArgsForCall[i].endpoint
}

func (fake *FakeRegistryInterface) Lookup(uri route.Uri) *route.Pool {
	fake.lookupMutex.Lock()
	fake.lookupArgsForCall = append(fake.lookupArgsForCall, struct {
		uri route.Uri
	}{uri})
	fake.lookupMutex.Unlock()
	if fake.LookupStub != nil {
		return fake.LookupStub(uri)
	} else {
		return fake.lookupReturns.result1
	}
}

func (fake *FakeRegistryInterface) LookupCallCount() int {
	fake.lookupMutex.RLock()
	defer fake.lookupMutex.RUnlock()
	return len(fake.lookupArgsForCall)
}

func (fake *FakeRegistryInterface) LookupArgsForCall(i int) route.Uri {
	fake.lookupMutex.RLock()
	defer fake.lookupMutex.RUnlock()
	return fake.lookupArgsForCall[i].uri
}

func (fake *FakeRegistryInterface) LookupReturns(result1 *route.Pool) {
	fake.LookupStub = nil
	fake.lookupReturns = struct {
		result1 *route.Pool
	}{result1}
}

func (fake *FakeRegistryInterface) LookupWithInstance(uri route.Uri, appId string, appIndex string) *route.Pool {
	fake.lookupWithInstanceMutex.Lock()
	fake.lookupWithInstanceArgsForCall = append(fake.lookupWithInstanceArgsForCall, struct {
		uri      route.Uri
		appId    string
		appIndex string
	}{uri, appId, appIndex})
	fake.lookupWithInstanceMutex.Unlock()
	if fake.LookupWithInstanceStub != nil {
		return fake.LookupWithInstanceStub(uri, appId, appIndex)
	} else {
		return fake.lookupWithInstanceReturns.result1
	}
}

func (fake *FakeRegistryInterface) LookupWithInstanceCallCount() int {
	fake.lookupWithInstanceMutex.RLock()
	defer fake.lookupWithInstanceMutex.RUnlock()
	return len(fake.lookupWithInstanceArgsForCall)
}

func (fake *FakeRegistryInterface) LookupWithInstanceArgsForCall(i int) (route.Uri, string, string) {
	fake.lookupWithInstanceMutex.RLock()
	defer fake.lookupWithInstanceMutex.RUnlock()
	return fake.lookupWithInstanceArgsForCall[i].uri, fake.lookupWithInstanceArgsForCall[i].appId, fake.lookupWithInstanceArgsForCall[i].appIndex
}

func (fake *FakeRegistryInterface) LookupWithInstanceReturns(result1 *route.Pool) {
	fake.LookupWithInstanceStub = nil
	fake.lookupWithInstanceReturns = struct {
		result1 *route.Pool
	}{result1}
}

func (fake *FakeRegistryInterface) StartPruningCycle() {
	fake.startPruningCycleMutex.Lock()
	fake.startPruningCycleArgsForCall = append(fake.startPruningCycleArgsForCall, struct{}{})
	fake.startPruningCycleMutex.Unlock()
	if fake.StartPruningCycleStub != nil {
		fake.StartPruningCycleStub()
	}
}

func (fake *FakeRegistryInterface) StartPruningCycleCallCount() int {
	fake.startPruningCycleMutex.RLock()
	defer fake.startPruningCycleMutex.RUnlock()
	return len(fake.startPruningCycleArgsForCall)
}

func (fake *FakeRegistryInterface) StopPruningCycle() {
	fake.stopPruningCycleMutex.Lock()
	fake.stopPruningCycleArgsForCall = append(fake.stopPruningCycleArgsForCall, struct{}{})
	fake.stopPruningCycleMutex.Unlock()
	if fake.StopPruningCycleStub != nil {
		fake.StopPruningCycleStub()
	}
}

func (fake *FakeRegistryInterface) StopPruningCycleCallCount() int {
	fake.stopPruningCycleMutex.RLock()
	defer fake.stopPruningCycleMutex.RUnlock()
	return len(fake.stopPruningCycleArgsForCall)
}

func (fake *FakeRegistryInterface) NumUris() int {
	fake.numUrisMutex.Lock()
	fake.numUrisArgsForCall = append(fake.numUrisArgsForCall, struct{}{})
	fake.numUrisMutex.Unlock()
	if fake.NumUrisStub != nil {
		return fake.NumUrisStub()
	} else {
		return fake.numUrisReturns.result1
	}
}

func (fake *FakeRegistryInterface) NumUrisCallCount() int {
	fake.numUrisMutex.RLock()
	defer fake.numUrisMutex.RUnlock()
	return len(fake.numUrisArgsForCall)
}

func (fake *FakeRegistryInterface) NumUrisReturns(result1 int) {
	fake.NumUrisStub = nil
	fake.numUrisReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeRegistryInterface) NumEndpoints() int {
	fake.numEndpointsMutex.Lock()
	fake.numEndpointsArgsForCall = append(fake.numEndpointsArgsForCall, struct{}{})
	fake.numEndpointsMutex.Unlock()
	if fake.NumEndpointsStub != nil {
		return fake.NumEndpointsStub()
	} else {
		return fake.numEndpointsReturns.result1
	}
}

func (fake *FakeRegistryInterface) NumEndpointsCallCount() int {
	fake.numEndpointsMutex.RLock()
	defer fake.numEndpointsMutex.RUnlock()
	return len(fake.numEndpointsArgsForCall)
}

func (fake *FakeRegistryInterface) NumEndpointsReturns(result1 int) {
	fake.NumEndpointsStub = nil
	fake.numEndpointsReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeRegistryInterface) MarshalJSON() ([]byte, error) {
	fake.marshalJSONMutex.Lock()
	fake.marshalJSONArgsForCall = append(fake.marshalJSONArgsForCall, struct{}{})
	fake.marshalJSONMutex.Unlock()
	if fake.MarshalJSONStub != nil {
		return fake.MarshalJSONStub()
	} else {
		return fake.marshalJSONReturns.result1, fake.marshalJSONReturns.result2
	}
}

func (fake *FakeRegistryInterface) MarshalJSONCallCount() int {
	fake.marshalJSONMutex.RLock()
	defer fake.marshalJSONMutex.RUnlock()
	return len(fake.marshalJSONArgsForCall)
}

func (fake *FakeRegistryInterface) MarshalJSONReturns(result1 []byte, result2 error) {
	fake.MarshalJSONStub = nil
	fake.marshalJSONReturns = struct {
		result1 []byte
		result2 error
	}{result1, result2}
}

var _ registry.RegistryInterface = new(FakeRegistryInterface)