stemcell_service.go

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

import (
	"sync"
)

type StemcellService struct {
	FromDirectoriesStub        func([]string) (map[string]any, error)
	fromDirectoriesMutex       sync.RWMutex
	fromDirectoriesArgsForCall []struct {
		arg1 []string
	}
	fromDirectoriesReturns struct {
		result1 map[string]any
		result2 error
	}
	fromDirectoriesReturnsOnCall map[int]struct {
		result1 map[string]any
		result2 error
	}
	FromKilnfileStub        func(string) (map[string]any, error)
	fromKilnfileMutex       sync.RWMutex
	fromKilnfileArgsForCall []struct {
		arg1 string
	}
	fromKilnfileReturns struct {
		result1 map[string]any
		result2 error
	}
	fromKilnfileReturnsOnCall map[int]struct {
		result1 map[string]any
		result2 error
	}
	FromTarballStub        func(string) (any, error)
	fromTarballMutex       sync.RWMutex
	fromTarballArgsForCall []struct {
		arg1 string
	}
	fromTarballReturns struct {
		result1 any
		result2 error
	}
	fromTarballReturnsOnCall map[int]struct {
		result1 any
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *StemcellService) FromDirectories(arg1 []string) (map[string]any, error) {
	var arg1Copy []string
	if arg1 != nil {
		arg1Copy = make([]string, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.fromDirectoriesMutex.Lock()
	ret, specificReturn := fake.fromDirectoriesReturnsOnCall[len(fake.fromDirectoriesArgsForCall)]
	fake.fromDirectoriesArgsForCall = append(fake.fromDirectoriesArgsForCall, struct {
		arg1 []string
	}{arg1Copy})
	stub := fake.FromDirectoriesStub
	fakeReturns := fake.fromDirectoriesReturns
	fake.recordInvocation("FromDirectories", []interface{}{arg1Copy})
	fake.fromDirectoriesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *StemcellService) FromDirectoriesCallCount() int {
	fake.fromDirectoriesMutex.RLock()
	defer fake.fromDirectoriesMutex.RUnlock()
	return len(fake.fromDirectoriesArgsForCall)
}

func (fake *StemcellService) FromDirectoriesCalls(stub func([]string) (map[string]any, error)) {
	fake.fromDirectoriesMutex.Lock()
	defer fake.fromDirectoriesMutex.Unlock()
	fake.FromDirectoriesStub = stub
}

func (fake *StemcellService) FromDirectoriesArgsForCall(i int) []string {
	fake.fromDirectoriesMutex.RLock()
	defer fake.fromDirectoriesMutex.RUnlock()
	argsForCall := fake.fromDirectoriesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *StemcellService) FromDirectoriesReturns(result1 map[string]any, result2 error) {
	fake.fromDirectoriesMutex.Lock()
	defer fake.fromDirectoriesMutex.Unlock()
	fake.FromDirectoriesStub = nil
	fake.fromDirectoriesReturns = struct {
		result1 map[string]any
		result2 error
	}{result1, result2}
}

func (fake *StemcellService) FromDirectoriesReturnsOnCall(i int, result1 map[string]any, result2 error) {
	fake.fromDirectoriesMutex.Lock()
	defer fake.fromDirectoriesMutex.Unlock()
	fake.FromDirectoriesStub = nil
	if fake.fromDirectoriesReturnsOnCall == nil {
		fake.fromDirectoriesReturnsOnCall = make(map[int]struct {
			result1 map[string]any
			result2 error
		})
	}
	fake.fromDirectoriesReturnsOnCall[i] = struct {
		result1 map[string]any
		result2 error
	}{result1, result2}
}

func (fake *StemcellService) FromKilnfile(arg1 string) (map[string]any, error) {
	fake.fromKilnfileMutex.Lock()
	ret, specificReturn := fake.fromKilnfileReturnsOnCall[len(fake.fromKilnfileArgsForCall)]
	fake.fromKilnfileArgsForCall = append(fake.fromKilnfileArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.FromKilnfileStub
	fakeReturns := fake.fromKilnfileReturns
	fake.recordInvocation("FromKilnfile", []interface{}{arg1})
	fake.fromKilnfileMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *StemcellService) FromKilnfileCallCount() int {
	fake.fromKilnfileMutex.RLock()
	defer fake.fromKilnfileMutex.RUnlock()
	return len(fake.fromKilnfileArgsForCall)
}

func (fake *StemcellService) FromKilnfileCalls(stub func(string) (map[string]any, error)) {
	fake.fromKilnfileMutex.Lock()
	defer fake.fromKilnfileMutex.Unlock()
	fake.FromKilnfileStub = stub
}

func (fake *StemcellService) FromKilnfileArgsForCall(i int) string {
	fake.fromKilnfileMutex.RLock()
	defer fake.fromKilnfileMutex.RUnlock()
	argsForCall := fake.fromKilnfileArgsForCall[i]
	return argsForCall.arg1
}

func (fake *StemcellService) FromKilnfileReturns(result1 map[string]any, result2 error) {
	fake.fromKilnfileMutex.Lock()
	defer fake.fromKilnfileMutex.Unlock()
	fake.FromKilnfileStub = nil
	fake.fromKilnfileReturns = struct {
		result1 map[string]any
		result2 error
	}{result1, result2}
}

func (fake *StemcellService) FromKilnfileReturnsOnCall(i int, result1 map[string]any, result2 error) {
	fake.fromKilnfileMutex.Lock()
	defer fake.fromKilnfileMutex.Unlock()
	fake.FromKilnfileStub = nil
	if fake.fromKilnfileReturnsOnCall == nil {
		fake.fromKilnfileReturnsOnCall = make(map[int]struct {
			result1 map[string]any
			result2 error
		})
	}
	fake.fromKilnfileReturnsOnCall[i] = struct {
		result1 map[string]any
		result2 error
	}{result1, result2}
}

func (fake *StemcellService) FromTarball(arg1 string) (any, error) {
	fake.fromTarballMutex.Lock()
	ret, specificReturn := fake.fromTarballReturnsOnCall[len(fake.fromTarballArgsForCall)]
	fake.fromTarballArgsForCall = append(fake.fromTarballArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.FromTarballStub
	fakeReturns := fake.fromTarballReturns
	fake.recordInvocation("FromTarball", []interface{}{arg1})
	fake.fromTarballMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *StemcellService) FromTarballCallCount() int {
	fake.fromTarballMutex.RLock()
	defer fake.fromTarballMutex.RUnlock()
	return len(fake.fromTarballArgsForCall)
}

func (fake *StemcellService) FromTarballCalls(stub func(string) (any, error)) {
	fake.fromTarballMutex.Lock()
	defer fake.fromTarballMutex.Unlock()
	fake.FromTarballStub = stub
}

func (fake *StemcellService) FromTarballArgsForCall(i int) string {
	fake.fromTarballMutex.RLock()
	defer fake.fromTarballMutex.RUnlock()
	argsForCall := fake.fromTarballArgsForCall[i]
	return argsForCall.arg1
}

func (fake *StemcellService) FromTarballReturns(result1 any, result2 error) {
	fake.fromTarballMutex.Lock()
	defer fake.fromTarballMutex.Unlock()
	fake.FromTarballStub = nil
	fake.fromTarballReturns = struct {
		result1 any
		result2 error
	}{result1, result2}
}

func (fake *StemcellService) FromTarballReturnsOnCall(i int, result1 any, result2 error) {
	fake.fromTarballMutex.Lock()
	defer fake.fromTarballMutex.Unlock()
	fake.FromTarballStub = nil
	if fake.fromTarballReturnsOnCall == nil {
		fake.fromTarballReturnsOnCall = make(map[int]struct {
			result1 any
			result2 error
		})
	}
	fake.fromTarballReturnsOnCall[i] = struct {
		result1 any
		result2 error
	}{result1, result2}
}

func (fake *StemcellService) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.fromDirectoriesMutex.RLock()
	defer fake.fromDirectoriesMutex.RUnlock()
	fake.fromKilnfileMutex.RLock()
	defer fake.fromKilnfileMutex.RUnlock()
	fake.fromTarballMutex.RLock()
	defer fake.fromTarballMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

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