fake_ociruntime.go

// This file was generated by counterfeiter
package rundmcfakes

import (
	"sync"

	"code.cloudfoundry.org/garden"
	"code.cloudfoundry.org/guardian/gardener"
	"code.cloudfoundry.org/guardian/rundmc"
	"code.cloudfoundry.org/guardian/rundmc/runrunc"
	"code.cloudfoundry.org/lager"
)

type FakeOCIRuntime struct {
	CreateStub        func(log lager.Logger, bundlePath, id string, io garden.ProcessIO) error
	createMutex       sync.RWMutex
	createArgsForCall []struct {
		log        lager.Logger
		bundlePath string
		id         string
		io         garden.ProcessIO
	}
	createReturns struct {
		result1 error
	}
	ExecStub        func(log lager.Logger, id, bundlePath string, spec garden.ProcessSpec, io garden.ProcessIO) (garden.Process, error)
	execMutex       sync.RWMutex
	execArgsForCall []struct {
		log        lager.Logger
		id         string
		bundlePath string
		spec       garden.ProcessSpec
		io         garden.ProcessIO
	}
	execReturns struct {
		result1 garden.Process
		result2 error
	}
	AttachStub        func(log lager.Logger, id, bundlePath, processId string, io garden.ProcessIO) (garden.Process, error)
	attachMutex       sync.RWMutex
	attachArgsForCall []struct {
		log        lager.Logger
		id         string
		bundlePath string
		processId  string
		io         garden.ProcessIO
	}
	attachReturns struct {
		result1 garden.Process
		result2 error
	}
	KillStub        func(log lager.Logger, bundlePath string) error
	killMutex       sync.RWMutex
	killArgsForCall []struct {
		log        lager.Logger
		bundlePath string
	}
	killReturns struct {
		result1 error
	}
	DeleteStub        func(log lager.Logger, bundlePath string) error
	deleteMutex       sync.RWMutex
	deleteArgsForCall []struct {
		log        lager.Logger
		bundlePath string
	}
	deleteReturns struct {
		result1 error
	}
	StateStub        func(log lager.Logger, id string) (runrunc.State, error)
	stateMutex       sync.RWMutex
	stateArgsForCall []struct {
		log lager.Logger
		id  string
	}
	stateReturns struct {
		result1 runrunc.State
		result2 error
	}
	StatsStub        func(log lager.Logger, id string) (gardener.ActualContainerMetrics, error)
	statsMutex       sync.RWMutex
	statsArgsForCall []struct {
		log lager.Logger
		id  string
	}
	statsReturns struct {
		result1 gardener.ActualContainerMetrics
		result2 error
	}
	WatchEventsStub        func(log lager.Logger, id string, eventsNotifier runrunc.EventsNotifier) error
	watchEventsMutex       sync.RWMutex
	watchEventsArgsForCall []struct {
		log            lager.Logger
		id             string
		eventsNotifier runrunc.EventsNotifier
	}
	watchEventsReturns struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeOCIRuntime) Create(log lager.Logger, bundlePath string, id string, io garden.ProcessIO) error {
	fake.createMutex.Lock()
	fake.createArgsForCall = append(fake.createArgsForCall, struct {
		log        lager.Logger
		bundlePath string
		id         string
		io         garden.ProcessIO
	}{log, bundlePath, id, io})
	fake.recordInvocation("Create", []interface{}{log, bundlePath, id, io})
	fake.createMutex.Unlock()
	if fake.CreateStub != nil {
		return fake.CreateStub(log, bundlePath, id, io)
	} else {
		return fake.createReturns.result1
	}
}

func (fake *FakeOCIRuntime) CreateCallCount() int {
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	return len(fake.createArgsForCall)
}

func (fake *FakeOCIRuntime) CreateArgsForCall(i int) (lager.Logger, string, string, garden.ProcessIO) {
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	return fake.createArgsForCall[i].log, fake.createArgsForCall[i].bundlePath, fake.createArgsForCall[i].id, fake.createArgsForCall[i].io
}

func (fake *FakeOCIRuntime) CreateReturns(result1 error) {
	fake.CreateStub = nil
	fake.createReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeOCIRuntime) Exec(log lager.Logger, id string, bundlePath string, spec garden.ProcessSpec, io garden.ProcessIO) (garden.Process, error) {
	fake.execMutex.Lock()
	fake.execArgsForCall = append(fake.execArgsForCall, struct {
		log        lager.Logger
		id         string
		bundlePath string
		spec       garden.ProcessSpec
		io         garden.ProcessIO
	}{log, id, bundlePath, spec, io})
	fake.recordInvocation("Exec", []interface{}{log, id, bundlePath, spec, io})
	fake.execMutex.Unlock()
	if fake.ExecStub != nil {
		return fake.ExecStub(log, id, bundlePath, spec, io)
	} else {
		return fake.execReturns.result1, fake.execReturns.result2
	}
}

func (fake *FakeOCIRuntime) ExecCallCount() int {
	fake.execMutex.RLock()
	defer fake.execMutex.RUnlock()
	return len(fake.execArgsForCall)
}

func (fake *FakeOCIRuntime) ExecArgsForCall(i int) (lager.Logger, string, string, garden.ProcessSpec, garden.ProcessIO) {
	fake.execMutex.RLock()
	defer fake.execMutex.RUnlock()
	return fake.execArgsForCall[i].log, fake.execArgsForCall[i].id, fake.execArgsForCall[i].bundlePath, fake.execArgsForCall[i].spec, fake.execArgsForCall[i].io
}

func (fake *FakeOCIRuntime) ExecReturns(result1 garden.Process, result2 error) {
	fake.ExecStub = nil
	fake.execReturns = struct {
		result1 garden.Process
		result2 error
	}{result1, result2}
}

func (fake *FakeOCIRuntime) Attach(log lager.Logger, id string, bundlePath string, processId string, io garden.ProcessIO) (garden.Process, error) {
	fake.attachMutex.Lock()
	fake.attachArgsForCall = append(fake.attachArgsForCall, struct {
		log        lager.Logger
		id         string
		bundlePath string
		processId  string
		io         garden.ProcessIO
	}{log, id, bundlePath, processId, io})
	fake.recordInvocation("Attach", []interface{}{log, id, bundlePath, processId, io})
	fake.attachMutex.Unlock()
	if fake.AttachStub != nil {
		return fake.AttachStub(log, id, bundlePath, processId, io)
	} else {
		return fake.attachReturns.result1, fake.attachReturns.result2
	}
}

func (fake *FakeOCIRuntime) AttachCallCount() int {
	fake.attachMutex.RLock()
	defer fake.attachMutex.RUnlock()
	return len(fake.attachArgsForCall)
}

func (fake *FakeOCIRuntime) AttachArgsForCall(i int) (lager.Logger, string, string, string, garden.ProcessIO) {
	fake.attachMutex.RLock()
	defer fake.attachMutex.RUnlock()
	return fake.attachArgsForCall[i].log, fake.attachArgsForCall[i].id, fake.attachArgsForCall[i].bundlePath, fake.attachArgsForCall[i].processId, fake.attachArgsForCall[i].io
}

func (fake *FakeOCIRuntime) AttachReturns(result1 garden.Process, result2 error) {
	fake.AttachStub = nil
	fake.attachReturns = struct {
		result1 garden.Process
		result2 error
	}{result1, result2}
}

func (fake *FakeOCIRuntime) Kill(log lager.Logger, bundlePath string) error {
	fake.killMutex.Lock()
	fake.killArgsForCall = append(fake.killArgsForCall, struct {
		log        lager.Logger
		bundlePath string
	}{log, bundlePath})
	fake.recordInvocation("Kill", []interface{}{log, bundlePath})
	fake.killMutex.Unlock()
	if fake.KillStub != nil {
		return fake.KillStub(log, bundlePath)
	} else {
		return fake.killReturns.result1
	}
}

func (fake *FakeOCIRuntime) KillCallCount() int {
	fake.killMutex.RLock()
	defer fake.killMutex.RUnlock()
	return len(fake.killArgsForCall)
}

func (fake *FakeOCIRuntime) KillArgsForCall(i int) (lager.Logger, string) {
	fake.killMutex.RLock()
	defer fake.killMutex.RUnlock()
	return fake.killArgsForCall[i].log, fake.killArgsForCall[i].bundlePath
}

func (fake *FakeOCIRuntime) KillReturns(result1 error) {
	fake.KillStub = nil
	fake.killReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeOCIRuntime) Delete(log lager.Logger, bundlePath string) error {
	fake.deleteMutex.Lock()
	fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct {
		log        lager.Logger
		bundlePath string
	}{log, bundlePath})
	fake.recordInvocation("Delete", []interface{}{log, bundlePath})
	fake.deleteMutex.Unlock()
	if fake.DeleteStub != nil {
		return fake.DeleteStub(log, bundlePath)
	} else {
		return fake.deleteReturns.result1
	}
}

func (fake *FakeOCIRuntime) DeleteCallCount() int {
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	return len(fake.deleteArgsForCall)
}

func (fake *FakeOCIRuntime) DeleteArgsForCall(i int) (lager.Logger, string) {
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	return fake.deleteArgsForCall[i].log, fake.deleteArgsForCall[i].bundlePath
}

func (fake *FakeOCIRuntime) DeleteReturns(result1 error) {
	fake.DeleteStub = nil
	fake.deleteReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeOCIRuntime) State(log lager.Logger, id string) (runrunc.State, error) {
	fake.stateMutex.Lock()
	fake.stateArgsForCall = append(fake.stateArgsForCall, struct {
		log lager.Logger
		id  string
	}{log, id})
	fake.recordInvocation("State", []interface{}{log, id})
	fake.stateMutex.Unlock()
	if fake.StateStub != nil {
		return fake.StateStub(log, id)
	} else {
		return fake.stateReturns.result1, fake.stateReturns.result2
	}
}

func (fake *FakeOCIRuntime) StateCallCount() int {
	fake.stateMutex.RLock()
	defer fake.stateMutex.RUnlock()
	return len(fake.stateArgsForCall)
}

func (fake *FakeOCIRuntime) StateArgsForCall(i int) (lager.Logger, string) {
	fake.stateMutex.RLock()
	defer fake.stateMutex.RUnlock()
	return fake.stateArgsForCall[i].log, fake.stateArgsForCall[i].id
}

func (fake *FakeOCIRuntime) StateReturns(result1 runrunc.State, result2 error) {
	fake.StateStub = nil
	fake.stateReturns = struct {
		result1 runrunc.State
		result2 error
	}{result1, result2}
}

func (fake *FakeOCIRuntime) Stats(log lager.Logger, id string) (gardener.ActualContainerMetrics, error) {
	fake.statsMutex.Lock()
	fake.statsArgsForCall = append(fake.statsArgsForCall, struct {
		log lager.Logger
		id  string
	}{log, id})
	fake.recordInvocation("Stats", []interface{}{log, id})
	fake.statsMutex.Unlock()
	if fake.StatsStub != nil {
		return fake.StatsStub(log, id)
	} else {
		return fake.statsReturns.result1, fake.statsReturns.result2
	}
}

func (fake *FakeOCIRuntime) StatsCallCount() int {
	fake.statsMutex.RLock()
	defer fake.statsMutex.RUnlock()
	return len(fake.statsArgsForCall)
}

func (fake *FakeOCIRuntime) StatsArgsForCall(i int) (lager.Logger, string) {
	fake.statsMutex.RLock()
	defer fake.statsMutex.RUnlock()
	return fake.statsArgsForCall[i].log, fake.statsArgsForCall[i].id
}

func (fake *FakeOCIRuntime) StatsReturns(result1 gardener.ActualContainerMetrics, result2 error) {
	fake.StatsStub = nil
	fake.statsReturns = struct {
		result1 gardener.ActualContainerMetrics
		result2 error
	}{result1, result2}
}

func (fake *FakeOCIRuntime) WatchEvents(log lager.Logger, id string, eventsNotifier runrunc.EventsNotifier) error {
	fake.watchEventsMutex.Lock()
	fake.watchEventsArgsForCall = append(fake.watchEventsArgsForCall, struct {
		log            lager.Logger
		id             string
		eventsNotifier runrunc.EventsNotifier
	}{log, id, eventsNotifier})
	fake.recordInvocation("WatchEvents", []interface{}{log, id, eventsNotifier})
	fake.watchEventsMutex.Unlock()
	if fake.WatchEventsStub != nil {
		return fake.WatchEventsStub(log, id, eventsNotifier)
	} else {
		return fake.watchEventsReturns.result1
	}
}

func (fake *FakeOCIRuntime) WatchEventsCallCount() int {
	fake.watchEventsMutex.RLock()
	defer fake.watchEventsMutex.RUnlock()
	return len(fake.watchEventsArgsForCall)
}

func (fake *FakeOCIRuntime) WatchEventsArgsForCall(i int) (lager.Logger, string, runrunc.EventsNotifier) {
	fake.watchEventsMutex.RLock()
	defer fake.watchEventsMutex.RUnlock()
	return fake.watchEventsArgsForCall[i].log, fake.watchEventsArgsForCall[i].id, fake.watchEventsArgsForCall[i].eventsNotifier
}

func (fake *FakeOCIRuntime) WatchEventsReturns(result1 error) {
	fake.WatchEventsStub = nil
	fake.watchEventsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeOCIRuntime) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	fake.execMutex.RLock()
	defer fake.execMutex.RUnlock()
	fake.attachMutex.RLock()
	defer fake.attachMutex.RUnlock()
	fake.killMutex.RLock()
	defer fake.killMutex.RUnlock()
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	fake.stateMutex.RLock()
	defer fake.stateMutex.RUnlock()
	fake.statsMutex.RLock()
	defer fake.statsMutex.RUnlock()
	fake.watchEventsMutex.RLock()
	defer fake.watchEventsMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeOCIRuntime) 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 _ rundmc.OCIRuntime = new(FakeOCIRuntime)