fake_release_index.go

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

import (
	"sync"

	boshrel "github.com/cloudfoundry/bosh-cli/release"
	boshrelman "github.com/cloudfoundry/bosh-cli/release/manifest"
	"github.com/cloudfoundry/bosh-cli/releasedir"
	semver "github.com/cppforlife/go-semi-semantic/version"
)

type FakeReleaseIndex struct {
	LastVersionStub        func(name string) (*semver.Version, error)
	lastVersionMutex       sync.RWMutex
	lastVersionArgsForCall []struct {
		name string
	}
	lastVersionReturns struct {
		result1 *semver.Version
		result2 error
	}
	lastVersionReturnsOnCall map[int]struct {
		result1 *semver.Version
		result2 error
	}
	ContainsStub        func(boshrel.Release) (bool, error)
	containsMutex       sync.RWMutex
	containsArgsForCall []struct {
		arg1 boshrel.Release
	}
	containsReturns struct {
		result1 bool
		result2 error
	}
	containsReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	AddStub        func(boshrelman.Manifest) error
	addMutex       sync.RWMutex
	addArgsForCall []struct {
		arg1 boshrelman.Manifest
	}
	addReturns struct {
		result1 error
	}
	addReturnsOnCall map[int]struct {
		result1 error
	}
	ManifestPathStub        func(name, version string) string
	manifestPathMutex       sync.RWMutex
	manifestPathArgsForCall []struct {
		name    string
		version string
	}
	manifestPathReturns struct {
		result1 string
	}
	manifestPathReturnsOnCall map[int]struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeReleaseIndex) LastVersion(name string) (*semver.Version, error) {
	fake.lastVersionMutex.Lock()
	ret, specificReturn := fake.lastVersionReturnsOnCall[len(fake.lastVersionArgsForCall)]
	fake.lastVersionArgsForCall = append(fake.lastVersionArgsForCall, struct {
		name string
	}{name})
	fake.recordInvocation("LastVersion", []interface{}{name})
	fake.lastVersionMutex.Unlock()
	if fake.LastVersionStub != nil {
		return fake.LastVersionStub(name)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.lastVersionReturns.result1, fake.lastVersionReturns.result2
}

func (fake *FakeReleaseIndex) LastVersionCallCount() int {
	fake.lastVersionMutex.RLock()
	defer fake.lastVersionMutex.RUnlock()
	return len(fake.lastVersionArgsForCall)
}

func (fake *FakeReleaseIndex) LastVersionArgsForCall(i int) string {
	fake.lastVersionMutex.RLock()
	defer fake.lastVersionMutex.RUnlock()
	return fake.lastVersionArgsForCall[i].name
}

func (fake *FakeReleaseIndex) LastVersionReturns(result1 *semver.Version, result2 error) {
	fake.LastVersionStub = nil
	fake.lastVersionReturns = struct {
		result1 *semver.Version
		result2 error
	}{result1, result2}
}

func (fake *FakeReleaseIndex) LastVersionReturnsOnCall(i int, result1 *semver.Version, result2 error) {
	fake.LastVersionStub = nil
	if fake.lastVersionReturnsOnCall == nil {
		fake.lastVersionReturnsOnCall = make(map[int]struct {
			result1 *semver.Version
			result2 error
		})
	}
	fake.lastVersionReturnsOnCall[i] = struct {
		result1 *semver.Version
		result2 error
	}{result1, result2}
}

func (fake *FakeReleaseIndex) Contains(arg1 boshrel.Release) (bool, error) {
	fake.containsMutex.Lock()
	ret, specificReturn := fake.containsReturnsOnCall[len(fake.containsArgsForCall)]
	fake.containsArgsForCall = append(fake.containsArgsForCall, struct {
		arg1 boshrel.Release
	}{arg1})
	fake.recordInvocation("Contains", []interface{}{arg1})
	fake.containsMutex.Unlock()
	if fake.ContainsStub != nil {
		return fake.ContainsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.containsReturns.result1, fake.containsReturns.result2
}

func (fake *FakeReleaseIndex) ContainsCallCount() int {
	fake.containsMutex.RLock()
	defer fake.containsMutex.RUnlock()
	return len(fake.containsArgsForCall)
}

func (fake *FakeReleaseIndex) ContainsArgsForCall(i int) boshrel.Release {
	fake.containsMutex.RLock()
	defer fake.containsMutex.RUnlock()
	return fake.containsArgsForCall[i].arg1
}

func (fake *FakeReleaseIndex) ContainsReturns(result1 bool, result2 error) {
	fake.ContainsStub = nil
	fake.containsReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeReleaseIndex) ContainsReturnsOnCall(i int, result1 bool, result2 error) {
	fake.ContainsStub = nil
	if fake.containsReturnsOnCall == nil {
		fake.containsReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.containsReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeReleaseIndex) Add(arg1 boshrelman.Manifest) error {
	fake.addMutex.Lock()
	ret, specificReturn := fake.addReturnsOnCall[len(fake.addArgsForCall)]
	fake.addArgsForCall = append(fake.addArgsForCall, struct {
		arg1 boshrelman.Manifest
	}{arg1})
	fake.recordInvocation("Add", []interface{}{arg1})
	fake.addMutex.Unlock()
	if fake.AddStub != nil {
		return fake.AddStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.addReturns.result1
}

func (fake *FakeReleaseIndex) AddCallCount() int {
	fake.addMutex.RLock()
	defer fake.addMutex.RUnlock()
	return len(fake.addArgsForCall)
}

func (fake *FakeReleaseIndex) AddArgsForCall(i int) boshrelman.Manifest {
	fake.addMutex.RLock()
	defer fake.addMutex.RUnlock()
	return fake.addArgsForCall[i].arg1
}

func (fake *FakeReleaseIndex) AddReturns(result1 error) {
	fake.AddStub = nil
	fake.addReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeReleaseIndex) AddReturnsOnCall(i int, result1 error) {
	fake.AddStub = nil
	if fake.addReturnsOnCall == nil {
		fake.addReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.addReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeReleaseIndex) ManifestPath(name string, version string) string {
	fake.manifestPathMutex.Lock()
	ret, specificReturn := fake.manifestPathReturnsOnCall[len(fake.manifestPathArgsForCall)]
	fake.manifestPathArgsForCall = append(fake.manifestPathArgsForCall, struct {
		name    string
		version string
	}{name, version})
	fake.recordInvocation("ManifestPath", []interface{}{name, version})
	fake.manifestPathMutex.Unlock()
	if fake.ManifestPathStub != nil {
		return fake.ManifestPathStub(name, version)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.manifestPathReturns.result1
}

func (fake *FakeReleaseIndex) ManifestPathCallCount() int {
	fake.manifestPathMutex.RLock()
	defer fake.manifestPathMutex.RUnlock()
	return len(fake.manifestPathArgsForCall)
}

func (fake *FakeReleaseIndex) ManifestPathArgsForCall(i int) (string, string) {
	fake.manifestPathMutex.RLock()
	defer fake.manifestPathMutex.RUnlock()
	return fake.manifestPathArgsForCall[i].name, fake.manifestPathArgsForCall[i].version
}

func (fake *FakeReleaseIndex) ManifestPathReturns(result1 string) {
	fake.ManifestPathStub = nil
	fake.manifestPathReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeReleaseIndex) ManifestPathReturnsOnCall(i int, result1 string) {
	fake.ManifestPathStub = nil
	if fake.manifestPathReturnsOnCall == nil {
		fake.manifestPathReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.manifestPathReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeReleaseIndex) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.lastVersionMutex.RLock()
	defer fake.lastVersionMutex.RUnlock()
	fake.containsMutex.RLock()
	defer fake.containsMutex.RUnlock()
	fake.addMutex.RLock()
	defer fake.addMutex.RUnlock()
	fake.manifestPathMutex.RLock()
	defer fake.manifestPathMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeReleaseIndex) 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 _ releasedir.ReleaseIndex = new(FakeReleaseIndex)