fake_worker_lifecycle.go

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

import (
	"sync"

	"github.com/concourse/atc/dbng"
)

type FakeWorkerLifecycle struct {
	StallUnresponsiveWorkersStub        func() ([]string, error)
	stallUnresponsiveWorkersMutex       sync.RWMutex
	stallUnresponsiveWorkersArgsForCall []struct{}
	stallUnresponsiveWorkersReturns     struct {
		result1 []string
		result2 error
	}
	stallUnresponsiveWorkersReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	LandFinishedLandingWorkersStub        func() ([]string, error)
	landFinishedLandingWorkersMutex       sync.RWMutex
	landFinishedLandingWorkersArgsForCall []struct{}
	landFinishedLandingWorkersReturns     struct {
		result1 []string
		result2 error
	}
	landFinishedLandingWorkersReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	DeleteFinishedRetiringWorkersStub        func() ([]string, error)
	deleteFinishedRetiringWorkersMutex       sync.RWMutex
	deleteFinishedRetiringWorkersArgsForCall []struct{}
	deleteFinishedRetiringWorkersReturns     struct {
		result1 []string
		result2 error
	}
	deleteFinishedRetiringWorkersReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeWorkerLifecycle) StallUnresponsiveWorkers() ([]string, error) {
	fake.stallUnresponsiveWorkersMutex.Lock()
	ret, specificReturn := fake.stallUnresponsiveWorkersReturnsOnCall[len(fake.stallUnresponsiveWorkersArgsForCall)]
	fake.stallUnresponsiveWorkersArgsForCall = append(fake.stallUnresponsiveWorkersArgsForCall, struct{}{})
	fake.recordInvocation("StallUnresponsiveWorkers", []interface{}{})
	fake.stallUnresponsiveWorkersMutex.Unlock()
	if fake.StallUnresponsiveWorkersStub != nil {
		return fake.StallUnresponsiveWorkersStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.stallUnresponsiveWorkersReturns.result1, fake.stallUnresponsiveWorkersReturns.result2
}

func (fake *FakeWorkerLifecycle) StallUnresponsiveWorkersCallCount() int {
	fake.stallUnresponsiveWorkersMutex.RLock()
	defer fake.stallUnresponsiveWorkersMutex.RUnlock()
	return len(fake.stallUnresponsiveWorkersArgsForCall)
}

func (fake *FakeWorkerLifecycle) StallUnresponsiveWorkersReturns(result1 []string, result2 error) {
	fake.StallUnresponsiveWorkersStub = nil
	fake.stallUnresponsiveWorkersReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeWorkerLifecycle) StallUnresponsiveWorkersReturnsOnCall(i int, result1 []string, result2 error) {
	fake.StallUnresponsiveWorkersStub = nil
	if fake.stallUnresponsiveWorkersReturnsOnCall == nil {
		fake.stallUnresponsiveWorkersReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.stallUnresponsiveWorkersReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeWorkerLifecycle) LandFinishedLandingWorkers() ([]string, error) {
	fake.landFinishedLandingWorkersMutex.Lock()
	ret, specificReturn := fake.landFinishedLandingWorkersReturnsOnCall[len(fake.landFinishedLandingWorkersArgsForCall)]
	fake.landFinishedLandingWorkersArgsForCall = append(fake.landFinishedLandingWorkersArgsForCall, struct{}{})
	fake.recordInvocation("LandFinishedLandingWorkers", []interface{}{})
	fake.landFinishedLandingWorkersMutex.Unlock()
	if fake.LandFinishedLandingWorkersStub != nil {
		return fake.LandFinishedLandingWorkersStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.landFinishedLandingWorkersReturns.result1, fake.landFinishedLandingWorkersReturns.result2
}

func (fake *FakeWorkerLifecycle) LandFinishedLandingWorkersCallCount() int {
	fake.landFinishedLandingWorkersMutex.RLock()
	defer fake.landFinishedLandingWorkersMutex.RUnlock()
	return len(fake.landFinishedLandingWorkersArgsForCall)
}

func (fake *FakeWorkerLifecycle) LandFinishedLandingWorkersReturns(result1 []string, result2 error) {
	fake.LandFinishedLandingWorkersStub = nil
	fake.landFinishedLandingWorkersReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeWorkerLifecycle) LandFinishedLandingWorkersReturnsOnCall(i int, result1 []string, result2 error) {
	fake.LandFinishedLandingWorkersStub = nil
	if fake.landFinishedLandingWorkersReturnsOnCall == nil {
		fake.landFinishedLandingWorkersReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.landFinishedLandingWorkersReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeWorkerLifecycle) DeleteFinishedRetiringWorkers() ([]string, error) {
	fake.deleteFinishedRetiringWorkersMutex.Lock()
	ret, specificReturn := fake.deleteFinishedRetiringWorkersReturnsOnCall[len(fake.deleteFinishedRetiringWorkersArgsForCall)]
	fake.deleteFinishedRetiringWorkersArgsForCall = append(fake.deleteFinishedRetiringWorkersArgsForCall, struct{}{})
	fake.recordInvocation("DeleteFinishedRetiringWorkers", []interface{}{})
	fake.deleteFinishedRetiringWorkersMutex.Unlock()
	if fake.DeleteFinishedRetiringWorkersStub != nil {
		return fake.DeleteFinishedRetiringWorkersStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.deleteFinishedRetiringWorkersReturns.result1, fake.deleteFinishedRetiringWorkersReturns.result2
}

func (fake *FakeWorkerLifecycle) DeleteFinishedRetiringWorkersCallCount() int {
	fake.deleteFinishedRetiringWorkersMutex.RLock()
	defer fake.deleteFinishedRetiringWorkersMutex.RUnlock()
	return len(fake.deleteFinishedRetiringWorkersArgsForCall)
}

func (fake *FakeWorkerLifecycle) DeleteFinishedRetiringWorkersReturns(result1 []string, result2 error) {
	fake.DeleteFinishedRetiringWorkersStub = nil
	fake.deleteFinishedRetiringWorkersReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeWorkerLifecycle) DeleteFinishedRetiringWorkersReturnsOnCall(i int, result1 []string, result2 error) {
	fake.DeleteFinishedRetiringWorkersStub = nil
	if fake.deleteFinishedRetiringWorkersReturnsOnCall == nil {
		fake.deleteFinishedRetiringWorkersReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.deleteFinishedRetiringWorkersReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeWorkerLifecycle) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.stallUnresponsiveWorkersMutex.RLock()
	defer fake.stallUnresponsiveWorkersMutex.RUnlock()
	fake.landFinishedLandingWorkersMutex.RLock()
	defer fake.landFinishedLandingWorkersMutex.RUnlock()
	fake.deleteFinishedRetiringWorkersMutex.RLock()
	defer fake.deleteFinishedRetiringWorkersMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeWorkerLifecycle) 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 _ dbng.WorkerLifecycle = new(FakeWorkerLifecycle)