fake_extracted_stemcell.go

// This file was generated by counterfeiter
package stemcellfakes

import (
	"sync"

	"github.com/cloudfoundry/bosh-cli/stemcell"
	"github.com/cloudfoundry/bosh-utils/property"
)

type FakeExtractedStemcell struct {
	ManifestStub        func() stemcell.Manifest
	manifestMutex       sync.RWMutex
	manifestArgsForCall []struct{}
	manifestReturns     struct {
		result1 stemcell.Manifest
	}
	CleanupStub        func() error
	cleanupMutex       sync.RWMutex
	cleanupArgsForCall []struct{}
	cleanupReturns     struct {
		result1 error
	}
	OsAndVersionStub        func() string
	osAndVersionMutex       sync.RWMutex
	osAndVersionArgsForCall []struct{}
	osAndVersionReturns     struct {
		result1 string
	}
	SetNameStub        func(string)
	setNameMutex       sync.RWMutex
	setNameArgsForCall []struct {
		arg1 string
	}
	SetVersionStub        func(string)
	setVersionMutex       sync.RWMutex
	setVersionArgsForCall []struct {
		arg1 string
	}
	SetCloudPropertiesStub        func(property.Map)
	setCloudPropertiesMutex       sync.RWMutex
	setCloudPropertiesArgsForCall []struct {
		arg1 property.Map
	}
	GetExtractedPathStub        func() string
	getExtractedPathMutex       sync.RWMutex
	getExtractedPathArgsForCall []struct{}
	getExtractedPathReturns     struct {
		result1 string
	}
	PackStub        func(string) error
	packMutex       sync.RWMutex
	packArgsForCall []struct {
		arg1 string
	}
	packReturns struct {
		result1 error
	}
	StringStub        func() string
	stringMutex       sync.RWMutex
	stringArgsForCall []struct{}
	stringReturns     struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeExtractedStemcell) Manifest() stemcell.Manifest {
	fake.manifestMutex.Lock()
	fake.manifestArgsForCall = append(fake.manifestArgsForCall, struct{}{})
	fake.recordInvocation("Manifest", []interface{}{})
	fake.manifestMutex.Unlock()
	if fake.ManifestStub != nil {
		return fake.ManifestStub()
	} else {
		return fake.manifestReturns.result1
	}
}

func (fake *FakeExtractedStemcell) ManifestCallCount() int {
	fake.manifestMutex.RLock()
	defer fake.manifestMutex.RUnlock()
	return len(fake.manifestArgsForCall)
}

func (fake *FakeExtractedStemcell) ManifestReturns(result1 stemcell.Manifest) {
	fake.ManifestStub = nil
	fake.manifestReturns = struct {
		result1 stemcell.Manifest
	}{result1}
}

func (fake *FakeExtractedStemcell) Cleanup() error {
	fake.cleanupMutex.Lock()
	fake.cleanupArgsForCall = append(fake.cleanupArgsForCall, struct{}{})
	fake.recordInvocation("Cleanup", []interface{}{})
	fake.cleanupMutex.Unlock()
	if fake.CleanupStub != nil {
		return fake.CleanupStub()
	} else {
		return fake.cleanupReturns.result1
	}
}

func (fake *FakeExtractedStemcell) CleanupCallCount() int {
	fake.cleanupMutex.RLock()
	defer fake.cleanupMutex.RUnlock()
	return len(fake.cleanupArgsForCall)
}

func (fake *FakeExtractedStemcell) CleanupReturns(result1 error) {
	fake.CleanupStub = nil
	fake.cleanupReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeExtractedStemcell) OsAndVersion() string {
	fake.osAndVersionMutex.Lock()
	fake.osAndVersionArgsForCall = append(fake.osAndVersionArgsForCall, struct{}{})
	fake.recordInvocation("OsAndVersion", []interface{}{})
	fake.osAndVersionMutex.Unlock()
	if fake.OsAndVersionStub != nil {
		return fake.OsAndVersionStub()
	} else {
		return fake.osAndVersionReturns.result1
	}
}

func (fake *FakeExtractedStemcell) OsAndVersionCallCount() int {
	fake.osAndVersionMutex.RLock()
	defer fake.osAndVersionMutex.RUnlock()
	return len(fake.osAndVersionArgsForCall)
}

func (fake *FakeExtractedStemcell) OsAndVersionReturns(result1 string) {
	fake.OsAndVersionStub = nil
	fake.osAndVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeExtractedStemcell) SetName(arg1 string) {
	fake.setNameMutex.Lock()
	fake.setNameArgsForCall = append(fake.setNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetName", []interface{}{arg1})
	fake.setNameMutex.Unlock()
	if fake.SetNameStub != nil {
		fake.SetNameStub(arg1)
	}
}

func (fake *FakeExtractedStemcell) SetNameCallCount() int {
	fake.setNameMutex.RLock()
	defer fake.setNameMutex.RUnlock()
	return len(fake.setNameArgsForCall)
}

func (fake *FakeExtractedStemcell) SetNameArgsForCall(i int) string {
	fake.setNameMutex.RLock()
	defer fake.setNameMutex.RUnlock()
	return fake.setNameArgsForCall[i].arg1
}

func (fake *FakeExtractedStemcell) SetVersion(arg1 string) {
	fake.setVersionMutex.Lock()
	fake.setVersionArgsForCall = append(fake.setVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("SetVersion", []interface{}{arg1})
	fake.setVersionMutex.Unlock()
	if fake.SetVersionStub != nil {
		fake.SetVersionStub(arg1)
	}
}

func (fake *FakeExtractedStemcell) SetVersionCallCount() int {
	fake.setVersionMutex.RLock()
	defer fake.setVersionMutex.RUnlock()
	return len(fake.setVersionArgsForCall)
}

func (fake *FakeExtractedStemcell) SetVersionArgsForCall(i int) string {
	fake.setVersionMutex.RLock()
	defer fake.setVersionMutex.RUnlock()
	return fake.setVersionArgsForCall[i].arg1
}

func (fake *FakeExtractedStemcell) SetCloudProperties(arg1 property.Map) {
	fake.setCloudPropertiesMutex.Lock()
	fake.setCloudPropertiesArgsForCall = append(fake.setCloudPropertiesArgsForCall, struct {
		arg1 property.Map
	}{arg1})
	fake.recordInvocation("SetCloudProperties", []interface{}{arg1})
	fake.setCloudPropertiesMutex.Unlock()
	if fake.SetCloudPropertiesStub != nil {
		fake.SetCloudPropertiesStub(arg1)
	}
}

func (fake *FakeExtractedStemcell) SetCloudPropertiesCallCount() int {
	fake.setCloudPropertiesMutex.RLock()
	defer fake.setCloudPropertiesMutex.RUnlock()
	return len(fake.setCloudPropertiesArgsForCall)
}

func (fake *FakeExtractedStemcell) SetCloudPropertiesArgsForCall(i int) property.Map {
	fake.setCloudPropertiesMutex.RLock()
	defer fake.setCloudPropertiesMutex.RUnlock()
	return fake.setCloudPropertiesArgsForCall[i].arg1
}

func (fake *FakeExtractedStemcell) GetExtractedPath() string {
	fake.getExtractedPathMutex.Lock()
	fake.getExtractedPathArgsForCall = append(fake.getExtractedPathArgsForCall, struct{}{})
	fake.recordInvocation("GetExtractedPath", []interface{}{})
	fake.getExtractedPathMutex.Unlock()
	if fake.GetExtractedPathStub != nil {
		return fake.GetExtractedPathStub()
	} else {
		return fake.getExtractedPathReturns.result1
	}
}

func (fake *FakeExtractedStemcell) GetExtractedPathCallCount() int {
	fake.getExtractedPathMutex.RLock()
	defer fake.getExtractedPathMutex.RUnlock()
	return len(fake.getExtractedPathArgsForCall)
}

func (fake *FakeExtractedStemcell) GetExtractedPathReturns(result1 string) {
	fake.GetExtractedPathStub = nil
	fake.getExtractedPathReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeExtractedStemcell) Pack(arg1 string) error {
	fake.packMutex.Lock()
	fake.packArgsForCall = append(fake.packArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("Pack", []interface{}{arg1})
	fake.packMutex.Unlock()
	if fake.PackStub != nil {
		return fake.PackStub(arg1)
	} else {
		return fake.packReturns.result1
	}
}

func (fake *FakeExtractedStemcell) PackCallCount() int {
	fake.packMutex.RLock()
	defer fake.packMutex.RUnlock()
	return len(fake.packArgsForCall)
}

func (fake *FakeExtractedStemcell) PackArgsForCall(i int) string {
	fake.packMutex.RLock()
	defer fake.packMutex.RUnlock()
	return fake.packArgsForCall[i].arg1
}

func (fake *FakeExtractedStemcell) PackReturns(result1 error) {
	fake.PackStub = nil
	fake.packReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeExtractedStemcell) String() string {
	fake.stringMutex.Lock()
	fake.stringArgsForCall = append(fake.stringArgsForCall, struct{}{})
	fake.recordInvocation("String", []interface{}{})
	fake.stringMutex.Unlock()
	if fake.StringStub != nil {
		return fake.StringStub()
	} else {
		return fake.stringReturns.result1
	}
}

func (fake *FakeExtractedStemcell) StringCallCount() int {
	fake.stringMutex.RLock()
	defer fake.stringMutex.RUnlock()
	return len(fake.stringArgsForCall)
}

func (fake *FakeExtractedStemcell) StringReturns(result1 string) {
	fake.StringStub = nil
	fake.stringReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeExtractedStemcell) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.manifestMutex.RLock()
	defer fake.manifestMutex.RUnlock()
	fake.cleanupMutex.RLock()
	defer fake.cleanupMutex.RUnlock()
	fake.osAndVersionMutex.RLock()
	defer fake.osAndVersionMutex.RUnlock()
	fake.setNameMutex.RLock()
	defer fake.setNameMutex.RUnlock()
	fake.setVersionMutex.RLock()
	defer fake.setVersionMutex.RUnlock()
	fake.setCloudPropertiesMutex.RLock()
	defer fake.setCloudPropertiesMutex.RUnlock()
	fake.getExtractedPathMutex.RLock()
	defer fake.getExtractedPathMutex.RUnlock()
	fake.packMutex.RLock()
	defer fake.packMutex.RUnlock()
	fake.stringMutex.RLock()
	defer fake.stringMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeExtractedStemcell) 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 _ stemcell.ExtractedStemcell = new(FakeExtractedStemcell)