github.com/cloudfoundry-incubator/stembuild@v0.0.0-20211223202937-5b61d62226c6/remotemanager/remotemanagerfakes/fake_remote_manager.go

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

import (
	"sync"
	"time"

	"github.com/cloudfoundry-incubator/stembuild/remotemanager"
)

type FakeRemoteManager struct {
	CanLoginVMStub        func() error
	canLoginVMMutex       sync.RWMutex
	canLoginVMArgsForCall []struct {
	}
	canLoginVMReturns struct {
		result1 error
	}
	canLoginVMReturnsOnCall map[int]struct {
		result1 error
	}
	CanReachVMStub        func() error
	canReachVMMutex       sync.RWMutex
	canReachVMArgsForCall []struct {
	}
	canReachVMReturns struct {
		result1 error
	}
	canReachVMReturnsOnCall map[int]struct {
		result1 error
	}
	ExecuteCommandStub        func(string) (int, error)
	executeCommandMutex       sync.RWMutex
	executeCommandArgsForCall []struct {
		arg1 string
	}
	executeCommandReturns struct {
		result1 int
		result2 error
	}
	executeCommandReturnsOnCall map[int]struct {
		result1 int
		result2 error
	}
	ExecuteCommandWithTimeoutStub        func(string, time.Duration) (int, error)
	executeCommandWithTimeoutMutex       sync.RWMutex
	executeCommandWithTimeoutArgsForCall []struct {
		arg1 string
		arg2 time.Duration
	}
	executeCommandWithTimeoutReturns struct {
		result1 int
		result2 error
	}
	executeCommandWithTimeoutReturnsOnCall map[int]struct {
		result1 int
		result2 error
	}
	ExtractArchiveStub        func(string, string) error
	extractArchiveMutex       sync.RWMutex
	extractArchiveArgsForCall []struct {
		arg1 string
		arg2 string
	}
	extractArchiveReturns struct {
		result1 error
	}
	extractArchiveReturnsOnCall map[int]struct {
		result1 error
	}
	UploadArtifactStub        func(string, string) error
	uploadArtifactMutex       sync.RWMutex
	uploadArtifactArgsForCall []struct {
		arg1 string
		arg2 string
	}
	uploadArtifactReturns struct {
		result1 error
	}
	uploadArtifactReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeRemoteManager) CanLoginVM() error {
	fake.canLoginVMMutex.Lock()
	ret, specificReturn := fake.canLoginVMReturnsOnCall[len(fake.canLoginVMArgsForCall)]
	fake.canLoginVMArgsForCall = append(fake.canLoginVMArgsForCall, struct {
	}{})
	fake.recordInvocation("CanLoginVM", []interface{}{})
	fake.canLoginVMMutex.Unlock()
	if fake.CanLoginVMStub != nil {
		return fake.CanLoginVMStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.canLoginVMReturns
	return fakeReturns.result1
}

func (fake *FakeRemoteManager) CanLoginVMCallCount() int {
	fake.canLoginVMMutex.RLock()
	defer fake.canLoginVMMutex.RUnlock()
	return len(fake.canLoginVMArgsForCall)
}

func (fake *FakeRemoteManager) CanLoginVMCalls(stub func() error) {
	fake.canLoginVMMutex.Lock()
	defer fake.canLoginVMMutex.Unlock()
	fake.CanLoginVMStub = stub
}

func (fake *FakeRemoteManager) CanLoginVMReturns(result1 error) {
	fake.canLoginVMMutex.Lock()
	defer fake.canLoginVMMutex.Unlock()
	fake.CanLoginVMStub = nil
	fake.canLoginVMReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRemoteManager) CanLoginVMReturnsOnCall(i int, result1 error) {
	fake.canLoginVMMutex.Lock()
	defer fake.canLoginVMMutex.Unlock()
	fake.CanLoginVMStub = nil
	if fake.canLoginVMReturnsOnCall == nil {
		fake.canLoginVMReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.canLoginVMReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRemoteManager) CanReachVM() error {
	fake.canReachVMMutex.Lock()
	ret, specificReturn := fake.canReachVMReturnsOnCall[len(fake.canReachVMArgsForCall)]
	fake.canReachVMArgsForCall = append(fake.canReachVMArgsForCall, struct {
	}{})
	fake.recordInvocation("CanReachVM", []interface{}{})
	fake.canReachVMMutex.Unlock()
	if fake.CanReachVMStub != nil {
		return fake.CanReachVMStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.canReachVMReturns
	return fakeReturns.result1
}

func (fake *FakeRemoteManager) CanReachVMCallCount() int {
	fake.canReachVMMutex.RLock()
	defer fake.canReachVMMutex.RUnlock()
	return len(fake.canReachVMArgsForCall)
}

func (fake *FakeRemoteManager) CanReachVMCalls(stub func() error) {
	fake.canReachVMMutex.Lock()
	defer fake.canReachVMMutex.Unlock()
	fake.CanReachVMStub = stub
}

func (fake *FakeRemoteManager) CanReachVMReturns(result1 error) {
	fake.canReachVMMutex.Lock()
	defer fake.canReachVMMutex.Unlock()
	fake.CanReachVMStub = nil
	fake.canReachVMReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRemoteManager) CanReachVMReturnsOnCall(i int, result1 error) {
	fake.canReachVMMutex.Lock()
	defer fake.canReachVMMutex.Unlock()
	fake.CanReachVMStub = nil
	if fake.canReachVMReturnsOnCall == nil {
		fake.canReachVMReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.canReachVMReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRemoteManager) ExecuteCommand(arg1 string) (int, error) {
	fake.executeCommandMutex.Lock()
	ret, specificReturn := fake.executeCommandReturnsOnCall[len(fake.executeCommandArgsForCall)]
	fake.executeCommandArgsForCall = append(fake.executeCommandArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("ExecuteCommand", []interface{}{arg1})
	fake.executeCommandMutex.Unlock()
	if fake.ExecuteCommandStub != nil {
		return fake.ExecuteCommandStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.executeCommandReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRemoteManager) ExecuteCommandCallCount() int {
	fake.executeCommandMutex.RLock()
	defer fake.executeCommandMutex.RUnlock()
	return len(fake.executeCommandArgsForCall)
}

func (fake *FakeRemoteManager) ExecuteCommandCalls(stub func(string) (int, error)) {
	fake.executeCommandMutex.Lock()
	defer fake.executeCommandMutex.Unlock()
	fake.ExecuteCommandStub = stub
}

func (fake *FakeRemoteManager) ExecuteCommandArgsForCall(i int) string {
	fake.executeCommandMutex.RLock()
	defer fake.executeCommandMutex.RUnlock()
	argsForCall := fake.executeCommandArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeRemoteManager) ExecuteCommandReturns(result1 int, result2 error) {
	fake.executeCommandMutex.Lock()
	defer fake.executeCommandMutex.Unlock()
	fake.ExecuteCommandStub = nil
	fake.executeCommandReturns = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeRemoteManager) ExecuteCommandReturnsOnCall(i int, result1 int, result2 error) {
	fake.executeCommandMutex.Lock()
	defer fake.executeCommandMutex.Unlock()
	fake.ExecuteCommandStub = nil
	if fake.executeCommandReturnsOnCall == nil {
		fake.executeCommandReturnsOnCall = make(map[int]struct {
			result1 int
			result2 error
		})
	}
	fake.executeCommandReturnsOnCall[i] = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeRemoteManager) ExecuteCommandWithTimeout(arg1 string, arg2 time.Duration) (int, error) {
	fake.executeCommandWithTimeoutMutex.Lock()
	ret, specificReturn := fake.executeCommandWithTimeoutReturnsOnCall[len(fake.executeCommandWithTimeoutArgsForCall)]
	fake.executeCommandWithTimeoutArgsForCall = append(fake.executeCommandWithTimeoutArgsForCall, struct {
		arg1 string
		arg2 time.Duration
	}{arg1, arg2})
	fake.recordInvocation("ExecuteCommandWithTimeout", []interface{}{arg1, arg2})
	fake.executeCommandWithTimeoutMutex.Unlock()
	if fake.ExecuteCommandWithTimeoutStub != nil {
		return fake.ExecuteCommandWithTimeoutStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.executeCommandWithTimeoutReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRemoteManager) ExecuteCommandWithTimeoutCallCount() int {
	fake.executeCommandWithTimeoutMutex.RLock()
	defer fake.executeCommandWithTimeoutMutex.RUnlock()
	return len(fake.executeCommandWithTimeoutArgsForCall)
}

func (fake *FakeRemoteManager) ExecuteCommandWithTimeoutCalls(stub func(string, time.Duration) (int, error)) {
	fake.executeCommandWithTimeoutMutex.Lock()
	defer fake.executeCommandWithTimeoutMutex.Unlock()
	fake.ExecuteCommandWithTimeoutStub = stub
}

func (fake *FakeRemoteManager) ExecuteCommandWithTimeoutArgsForCall(i int) (string, time.Duration) {
	fake.executeCommandWithTimeoutMutex.RLock()
	defer fake.executeCommandWithTimeoutMutex.RUnlock()
	argsForCall := fake.executeCommandWithTimeoutArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRemoteManager) ExecuteCommandWithTimeoutReturns(result1 int, result2 error) {
	fake.executeCommandWithTimeoutMutex.Lock()
	defer fake.executeCommandWithTimeoutMutex.Unlock()
	fake.ExecuteCommandWithTimeoutStub = nil
	fake.executeCommandWithTimeoutReturns = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeRemoteManager) ExecuteCommandWithTimeoutReturnsOnCall(i int, result1 int, result2 error) {
	fake.executeCommandWithTimeoutMutex.Lock()
	defer fake.executeCommandWithTimeoutMutex.Unlock()
	fake.ExecuteCommandWithTimeoutStub = nil
	if fake.executeCommandWithTimeoutReturnsOnCall == nil {
		fake.executeCommandWithTimeoutReturnsOnCall = make(map[int]struct {
			result1 int
			result2 error
		})
	}
	fake.executeCommandWithTimeoutReturnsOnCall[i] = struct {
		result1 int
		result2 error
	}{result1, result2}
}

func (fake *FakeRemoteManager) ExtractArchive(arg1 string, arg2 string) error {
	fake.extractArchiveMutex.Lock()
	ret, specificReturn := fake.extractArchiveReturnsOnCall[len(fake.extractArchiveArgsForCall)]
	fake.extractArchiveArgsForCall = append(fake.extractArchiveArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("ExtractArchive", []interface{}{arg1, arg2})
	fake.extractArchiveMutex.Unlock()
	if fake.ExtractArchiveStub != nil {
		return fake.ExtractArchiveStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.extractArchiveReturns
	return fakeReturns.result1
}

func (fake *FakeRemoteManager) ExtractArchiveCallCount() int {
	fake.extractArchiveMutex.RLock()
	defer fake.extractArchiveMutex.RUnlock()
	return len(fake.extractArchiveArgsForCall)
}

func (fake *FakeRemoteManager) ExtractArchiveCalls(stub func(string, string) error) {
	fake.extractArchiveMutex.Lock()
	defer fake.extractArchiveMutex.Unlock()
	fake.ExtractArchiveStub = stub
}

func (fake *FakeRemoteManager) ExtractArchiveArgsForCall(i int) (string, string) {
	fake.extractArchiveMutex.RLock()
	defer fake.extractArchiveMutex.RUnlock()
	argsForCall := fake.extractArchiveArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRemoteManager) ExtractArchiveReturns(result1 error) {
	fake.extractArchiveMutex.Lock()
	defer fake.extractArchiveMutex.Unlock()
	fake.ExtractArchiveStub = nil
	fake.extractArchiveReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRemoteManager) ExtractArchiveReturnsOnCall(i int, result1 error) {
	fake.extractArchiveMutex.Lock()
	defer fake.extractArchiveMutex.Unlock()
	fake.ExtractArchiveStub = nil
	if fake.extractArchiveReturnsOnCall == nil {
		fake.extractArchiveReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.extractArchiveReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRemoteManager) UploadArtifact(arg1 string, arg2 string) error {
	fake.uploadArtifactMutex.Lock()
	ret, specificReturn := fake.uploadArtifactReturnsOnCall[len(fake.uploadArtifactArgsForCall)]
	fake.uploadArtifactArgsForCall = append(fake.uploadArtifactArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UploadArtifact", []interface{}{arg1, arg2})
	fake.uploadArtifactMutex.Unlock()
	if fake.UploadArtifactStub != nil {
		return fake.UploadArtifactStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.uploadArtifactReturns
	return fakeReturns.result1
}

func (fake *FakeRemoteManager) UploadArtifactCallCount() int {
	fake.uploadArtifactMutex.RLock()
	defer fake.uploadArtifactMutex.RUnlock()
	return len(fake.uploadArtifactArgsForCall)
}

func (fake *FakeRemoteManager) UploadArtifactCalls(stub func(string, string) error) {
	fake.uploadArtifactMutex.Lock()
	defer fake.uploadArtifactMutex.Unlock()
	fake.UploadArtifactStub = stub
}

func (fake *FakeRemoteManager) UploadArtifactArgsForCall(i int) (string, string) {
	fake.uploadArtifactMutex.RLock()
	defer fake.uploadArtifactMutex.RUnlock()
	argsForCall := fake.uploadArtifactArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRemoteManager) UploadArtifactReturns(result1 error) {
	fake.uploadArtifactMutex.Lock()
	defer fake.uploadArtifactMutex.Unlock()
	fake.UploadArtifactStub = nil
	fake.uploadArtifactReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRemoteManager) UploadArtifactReturnsOnCall(i int, result1 error) {
	fake.uploadArtifactMutex.Lock()
	defer fake.uploadArtifactMutex.Unlock()
	fake.UploadArtifactStub = nil
	if fake.uploadArtifactReturnsOnCall == nil {
		fake.uploadArtifactReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.uploadArtifactReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRemoteManager) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.canLoginVMMutex.RLock()
	defer fake.canLoginVMMutex.RUnlock()
	fake.canReachVMMutex.RLock()
	defer fake.canReachVMMutex.RUnlock()
	fake.executeCommandMutex.RLock()
	defer fake.executeCommandMutex.RUnlock()
	fake.executeCommandWithTimeoutMutex.RLock()
	defer fake.executeCommandWithTimeoutMutex.RUnlock()
	fake.extractArchiveMutex.RLock()
	defer fake.extractArchiveMutex.RUnlock()
	fake.uploadArtifactMutex.RLock()
	defer fake.uploadArtifactMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeRemoteManager) 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 _ remotemanager.RemoteManager = new(FakeRemoteManager)