route_mappings_repo.go

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

import (
	"sync"

	"code.cloudfoundry.org/copilot/models"
)

type RouteMappingsRepo struct {
	GetCalculatedWeightStub        func(rm *models.RouteMapping) int32
	getCalculatedWeightMutex       sync.RWMutex
	getCalculatedWeightArgsForCall []struct {
		rm *models.RouteMapping
	}
	getCalculatedWeightReturns struct {
		result1 int32
	}
	getCalculatedWeightReturnsOnCall map[int]struct {
		result1 int32
	}
	MapStub        func(routeMapping *models.RouteMapping)
	mapMutex       sync.RWMutex
	mapArgsForCall []struct {
		routeMapping *models.RouteMapping
	}
	UnmapStub        func(routeMapping *models.RouteMapping)
	unmapMutex       sync.RWMutex
	unmapArgsForCall []struct {
		routeMapping *models.RouteMapping
	}
	SyncStub        func(routeMappings []*models.RouteMapping)
	syncMutex       sync.RWMutex
	syncArgsForCall []struct {
		routeMappings []*models.RouteMapping
	}
	ListStub        func() map[string]*models.RouteMapping
	listMutex       sync.RWMutex
	listArgsForCall []struct{}
	listReturns     struct {
		result1 map[string]*models.RouteMapping
	}
	listReturnsOnCall map[int]struct {
		result1 map[string]*models.RouteMapping
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *RouteMappingsRepo) GetCalculatedWeight(rm *models.RouteMapping) int32 {
	fake.getCalculatedWeightMutex.Lock()
	ret, specificReturn := fake.getCalculatedWeightReturnsOnCall[len(fake.getCalculatedWeightArgsForCall)]
	fake.getCalculatedWeightArgsForCall = append(fake.getCalculatedWeightArgsForCall, struct {
		rm *models.RouteMapping
	}{rm})
	fake.recordInvocation("GetCalculatedWeight", []interface{}{rm})
	fake.getCalculatedWeightMutex.Unlock()
	if fake.GetCalculatedWeightStub != nil {
		return fake.GetCalculatedWeightStub(rm)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.getCalculatedWeightReturns.result1
}

func (fake *RouteMappingsRepo) GetCalculatedWeightCallCount() int {
	fake.getCalculatedWeightMutex.RLock()
	defer fake.getCalculatedWeightMutex.RUnlock()
	return len(fake.getCalculatedWeightArgsForCall)
}

func (fake *RouteMappingsRepo) GetCalculatedWeightArgsForCall(i int) *models.RouteMapping {
	fake.getCalculatedWeightMutex.RLock()
	defer fake.getCalculatedWeightMutex.RUnlock()
	return fake.getCalculatedWeightArgsForCall[i].rm
}

func (fake *RouteMappingsRepo) GetCalculatedWeightReturns(result1 int32) {
	fake.GetCalculatedWeightStub = nil
	fake.getCalculatedWeightReturns = struct {
		result1 int32
	}{result1}
}

func (fake *RouteMappingsRepo) GetCalculatedWeightReturnsOnCall(i int, result1 int32) {
	fake.GetCalculatedWeightStub = nil
	if fake.getCalculatedWeightReturnsOnCall == nil {
		fake.getCalculatedWeightReturnsOnCall = make(map[int]struct {
			result1 int32
		})
	}
	fake.getCalculatedWeightReturnsOnCall[i] = struct {
		result1 int32
	}{result1}
}

func (fake *RouteMappingsRepo) Map(routeMapping *models.RouteMapping) {
	fake.mapMutex.Lock()
	fake.mapArgsForCall = append(fake.mapArgsForCall, struct {
		routeMapping *models.RouteMapping
	}{routeMapping})
	fake.recordInvocation("Map", []interface{}{routeMapping})
	fake.mapMutex.Unlock()
	if fake.MapStub != nil {
		fake.MapStub(routeMapping)
	}
}

func (fake *RouteMappingsRepo) MapCallCount() int {
	fake.mapMutex.RLock()
	defer fake.mapMutex.RUnlock()
	return len(fake.mapArgsForCall)
}

func (fake *RouteMappingsRepo) MapArgsForCall(i int) *models.RouteMapping {
	fake.mapMutex.RLock()
	defer fake.mapMutex.RUnlock()
	return fake.mapArgsForCall[i].routeMapping
}

func (fake *RouteMappingsRepo) Unmap(routeMapping *models.RouteMapping) {
	fake.unmapMutex.Lock()
	fake.unmapArgsForCall = append(fake.unmapArgsForCall, struct {
		routeMapping *models.RouteMapping
	}{routeMapping})
	fake.recordInvocation("Unmap", []interface{}{routeMapping})
	fake.unmapMutex.Unlock()
	if fake.UnmapStub != nil {
		fake.UnmapStub(routeMapping)
	}
}

func (fake *RouteMappingsRepo) UnmapCallCount() int {
	fake.unmapMutex.RLock()
	defer fake.unmapMutex.RUnlock()
	return len(fake.unmapArgsForCall)
}

func (fake *RouteMappingsRepo) UnmapArgsForCall(i int) *models.RouteMapping {
	fake.unmapMutex.RLock()
	defer fake.unmapMutex.RUnlock()
	return fake.unmapArgsForCall[i].routeMapping
}

func (fake *RouteMappingsRepo) Sync(routeMappings []*models.RouteMapping) {
	var routeMappingsCopy []*models.RouteMapping
	if routeMappings != nil {
		routeMappingsCopy = make([]*models.RouteMapping, len(routeMappings))
		copy(routeMappingsCopy, routeMappings)
	}
	fake.syncMutex.Lock()
	fake.syncArgsForCall = append(fake.syncArgsForCall, struct {
		routeMappings []*models.RouteMapping
	}{routeMappingsCopy})
	fake.recordInvocation("Sync", []interface{}{routeMappingsCopy})
	fake.syncMutex.Unlock()
	if fake.SyncStub != nil {
		fake.SyncStub(routeMappings)
	}
}

func (fake *RouteMappingsRepo) SyncCallCount() int {
	fake.syncMutex.RLock()
	defer fake.syncMutex.RUnlock()
	return len(fake.syncArgsForCall)
}

func (fake *RouteMappingsRepo) SyncArgsForCall(i int) []*models.RouteMapping {
	fake.syncMutex.RLock()
	defer fake.syncMutex.RUnlock()
	return fake.syncArgsForCall[i].routeMappings
}

func (fake *RouteMappingsRepo) List() map[string]*models.RouteMapping {
	fake.listMutex.Lock()
	ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)]
	fake.listArgsForCall = append(fake.listArgsForCall, struct{}{})
	fake.recordInvocation("List", []interface{}{})
	fake.listMutex.Unlock()
	if fake.ListStub != nil {
		return fake.ListStub()
	}
	if specificReturn {
		return ret.result1
	}
	return fake.listReturns.result1
}

func (fake *RouteMappingsRepo) ListCallCount() int {
	fake.listMutex.RLock()
	defer fake.listMutex.RUnlock()
	return len(fake.listArgsForCall)
}

func (fake *RouteMappingsRepo) ListReturns(result1 map[string]*models.RouteMapping) {
	fake.ListStub = nil
	fake.listReturns = struct {
		result1 map[string]*models.RouteMapping
	}{result1}
}

func (fake *RouteMappingsRepo) ListReturnsOnCall(i int, result1 map[string]*models.RouteMapping) {
	fake.ListStub = nil
	if fake.listReturnsOnCall == nil {
		fake.listReturnsOnCall = make(map[int]struct {
			result1 map[string]*models.RouteMapping
		})
	}
	fake.listReturnsOnCall[i] = struct {
		result1 map[string]*models.RouteMapping
	}{result1}
}

func (fake *RouteMappingsRepo) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.getCalculatedWeightMutex.RLock()
	defer fake.getCalculatedWeightMutex.RUnlock()
	fake.mapMutex.RLock()
	defer fake.mapMutex.RUnlock()
	fake.unmapMutex.RLock()
	defer fake.unmapMutex.RUnlock()
	fake.syncMutex.RLock()
	defer fake.syncMutex.RUnlock()
	fake.listMutex.RLock()
	defer fake.listMutex.RUnlock()
	return fake.invocations
}

func (fake *RouteMappingsRepo) 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)
}