fake_release_index.go

// This file was generated by counterfeiter
package releasedirfakes

import (
	"sync"

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

type FakeReleaseIndex struct {
	LastVersionStub        func(name string) (*version.Version, error)
	lastVersionMutex       sync.RWMutex
	lastVersionArgsForCall []struct {
		name string
	}
	lastVersionReturns struct {
		result1 *version.Version
		result2 error
	}
	ContainsStub        func(release.Release) (bool, error)
	containsMutex       sync.RWMutex
	containsArgsForCall []struct {
		arg1 release.Release
	}
	containsReturns struct {
		result1 bool
		result2 error
	}
	AddStub        func(manifest.Manifest) error
	addMutex       sync.RWMutex
	addArgsForCall []struct {
		arg1 manifest.Manifest
	}
	addReturns struct {
		result1 error
	}
	ManifestPathStub        func(name, version string) string
	manifestPathMutex       sync.RWMutex
	manifestPathArgsForCall []struct {
		name    string
		version string
	}
	manifestPathReturns struct {
		result1 string
	}
	ArchivePathStub        func(release.Release) (string, error)
	archivePathMutex       sync.RWMutex
	archivePathArgsForCall []struct {
		arg1 release.Release
	}
	archivePathReturns struct {
		result1 string
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeReleaseIndex) LastVersion(name string) (*version.Version, error) {
	fake.lastVersionMutex.Lock()
	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)
	} else {
		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 *version.Version, result2 error) {
	fake.LastVersionStub = nil
	fake.lastVersionReturns = struct {
		result1 *version.Version
		result2 error
	}{result1, result2}
}

func (fake *FakeReleaseIndex) Contains(arg1 release.Release) (bool, error) {
	fake.containsMutex.Lock()
	fake.containsArgsForCall = append(fake.containsArgsForCall, struct {
		arg1 release.Release
	}{arg1})
	fake.recordInvocation("Contains", []interface{}{arg1})
	fake.containsMutex.Unlock()
	if fake.ContainsStub != nil {
		return fake.ContainsStub(arg1)
	} else {
		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) release.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) Add(arg1 manifest.Manifest) error {
	fake.addMutex.Lock()
	fake.addArgsForCall = append(fake.addArgsForCall, struct {
		arg1 manifest.Manifest
	}{arg1})
	fake.recordInvocation("Add", []interface{}{arg1})
	fake.addMutex.Unlock()
	if fake.AddStub != nil {
		return fake.AddStub(arg1)
	} else {
		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) manifest.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) ManifestPath(name string, version string) string {
	fake.manifestPathMutex.Lock()
	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)
	} else {
		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) ArchivePath(arg1 release.Release) (string, error) {
	fake.archivePathMutex.Lock()
	fake.archivePathArgsForCall = append(fake.archivePathArgsForCall, struct {
		arg1 release.Release
	}{arg1})
	fake.recordInvocation("ArchivePath", []interface{}{arg1})
	fake.archivePathMutex.Unlock()
	if fake.ArchivePathStub != nil {
		return fake.ArchivePathStub(arg1)
	} else {
		return fake.archivePathReturns.result1, fake.archivePathReturns.result2
	}
}

func (fake *FakeReleaseIndex) ArchivePathCallCount() int {
	fake.archivePathMutex.RLock()
	defer fake.archivePathMutex.RUnlock()
	return len(fake.archivePathArgsForCall)
}

func (fake *FakeReleaseIndex) ArchivePathArgsForCall(i int) release.Release {
	fake.archivePathMutex.RLock()
	defer fake.archivePathMutex.RUnlock()
	return fake.archivePathArgsForCall[i].arg1
}

func (fake *FakeReleaseIndex) ArchivePathReturns(result1 string, result2 error) {
	fake.ArchivePathStub = nil
	fake.archivePathReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

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()
	fake.archivePathMutex.RLock()
	defer fake.archivePathMutex.RUnlock()
	return fake.invocations
}

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)