fake_orphan_disk.go

// This file was generated by counterfeiter
package directorfakes

import (
	"sync"
	"time"

	"github.com/cloudfoundry/bosh-cli/director"
)

type FakeOrphanDisk struct {
	CIDStub        func() string
	cIDMutex       sync.RWMutex
	cIDArgsForCall []struct{}
	cIDReturns     struct {
		result1 string
	}
	SizeStub        func() uint64
	sizeMutex       sync.RWMutex
	sizeArgsForCall []struct{}
	sizeReturns     struct {
		result1 uint64
	}
	DeploymentStub        func() director.Deployment
	deploymentMutex       sync.RWMutex
	deploymentArgsForCall []struct{}
	deploymentReturns     struct {
		result1 director.Deployment
	}
	InstanceNameStub        func() string
	instanceNameMutex       sync.RWMutex
	instanceNameArgsForCall []struct{}
	instanceNameReturns     struct {
		result1 string
	}
	AZNameStub        func() string
	aZNameMutex       sync.RWMutex
	aZNameArgsForCall []struct{}
	aZNameReturns     struct {
		result1 string
	}
	OrphanedAtStub        func() time.Time
	orphanedAtMutex       sync.RWMutex
	orphanedAtArgsForCall []struct{}
	orphanedAtReturns     struct {
		result1 time.Time
	}
	DeleteStub        func() error
	deleteMutex       sync.RWMutex
	deleteArgsForCall []struct{}
	deleteReturns     struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeOrphanDisk) CID() string {
	fake.cIDMutex.Lock()
	fake.cIDArgsForCall = append(fake.cIDArgsForCall, struct{}{})
	fake.recordInvocation("CID", []interface{}{})
	fake.cIDMutex.Unlock()
	if fake.CIDStub != nil {
		return fake.CIDStub()
	} else {
		return fake.cIDReturns.result1
	}
}

func (fake *FakeOrphanDisk) CIDCallCount() int {
	fake.cIDMutex.RLock()
	defer fake.cIDMutex.RUnlock()
	return len(fake.cIDArgsForCall)
}

func (fake *FakeOrphanDisk) CIDReturns(result1 string) {
	fake.CIDStub = nil
	fake.cIDReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeOrphanDisk) Size() uint64 {
	fake.sizeMutex.Lock()
	fake.sizeArgsForCall = append(fake.sizeArgsForCall, struct{}{})
	fake.recordInvocation("Size", []interface{}{})
	fake.sizeMutex.Unlock()
	if fake.SizeStub != nil {
		return fake.SizeStub()
	} else {
		return fake.sizeReturns.result1
	}
}

func (fake *FakeOrphanDisk) SizeCallCount() int {
	fake.sizeMutex.RLock()
	defer fake.sizeMutex.RUnlock()
	return len(fake.sizeArgsForCall)
}

func (fake *FakeOrphanDisk) SizeReturns(result1 uint64) {
	fake.SizeStub = nil
	fake.sizeReturns = struct {
		result1 uint64
	}{result1}
}

func (fake *FakeOrphanDisk) Deployment() director.Deployment {
	fake.deploymentMutex.Lock()
	fake.deploymentArgsForCall = append(fake.deploymentArgsForCall, struct{}{})
	fake.recordInvocation("Deployment", []interface{}{})
	fake.deploymentMutex.Unlock()
	if fake.DeploymentStub != nil {
		return fake.DeploymentStub()
	} else {
		return fake.deploymentReturns.result1
	}
}

func (fake *FakeOrphanDisk) DeploymentCallCount() int {
	fake.deploymentMutex.RLock()
	defer fake.deploymentMutex.RUnlock()
	return len(fake.deploymentArgsForCall)
}

func (fake *FakeOrphanDisk) DeploymentReturns(result1 director.Deployment) {
	fake.DeploymentStub = nil
	fake.deploymentReturns = struct {
		result1 director.Deployment
	}{result1}
}

func (fake *FakeOrphanDisk) InstanceName() string {
	fake.instanceNameMutex.Lock()
	fake.instanceNameArgsForCall = append(fake.instanceNameArgsForCall, struct{}{})
	fake.recordInvocation("InstanceName", []interface{}{})
	fake.instanceNameMutex.Unlock()
	if fake.InstanceNameStub != nil {
		return fake.InstanceNameStub()
	} else {
		return fake.instanceNameReturns.result1
	}
}

func (fake *FakeOrphanDisk) InstanceNameCallCount() int {
	fake.instanceNameMutex.RLock()
	defer fake.instanceNameMutex.RUnlock()
	return len(fake.instanceNameArgsForCall)
}

func (fake *FakeOrphanDisk) InstanceNameReturns(result1 string) {
	fake.InstanceNameStub = nil
	fake.instanceNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeOrphanDisk) AZName() string {
	fake.aZNameMutex.Lock()
	fake.aZNameArgsForCall = append(fake.aZNameArgsForCall, struct{}{})
	fake.recordInvocation("AZName", []interface{}{})
	fake.aZNameMutex.Unlock()
	if fake.AZNameStub != nil {
		return fake.AZNameStub()
	} else {
		return fake.aZNameReturns.result1
	}
}

func (fake *FakeOrphanDisk) AZNameCallCount() int {
	fake.aZNameMutex.RLock()
	defer fake.aZNameMutex.RUnlock()
	return len(fake.aZNameArgsForCall)
}

func (fake *FakeOrphanDisk) AZNameReturns(result1 string) {
	fake.AZNameStub = nil
	fake.aZNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeOrphanDisk) OrphanedAt() time.Time {
	fake.orphanedAtMutex.Lock()
	fake.orphanedAtArgsForCall = append(fake.orphanedAtArgsForCall, struct{}{})
	fake.recordInvocation("OrphanedAt", []interface{}{})
	fake.orphanedAtMutex.Unlock()
	if fake.OrphanedAtStub != nil {
		return fake.OrphanedAtStub()
	} else {
		return fake.orphanedAtReturns.result1
	}
}

func (fake *FakeOrphanDisk) OrphanedAtCallCount() int {
	fake.orphanedAtMutex.RLock()
	defer fake.orphanedAtMutex.RUnlock()
	return len(fake.orphanedAtArgsForCall)
}

func (fake *FakeOrphanDisk) OrphanedAtReturns(result1 time.Time) {
	fake.OrphanedAtStub = nil
	fake.orphanedAtReturns = struct {
		result1 time.Time
	}{result1}
}

func (fake *FakeOrphanDisk) Delete() error {
	fake.deleteMutex.Lock()
	fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct{}{})
	fake.recordInvocation("Delete", []interface{}{})
	fake.deleteMutex.Unlock()
	if fake.DeleteStub != nil {
		return fake.DeleteStub()
	} else {
		return fake.deleteReturns.result1
	}
}

func (fake *FakeOrphanDisk) DeleteCallCount() int {
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	return len(fake.deleteArgsForCall)
}

func (fake *FakeOrphanDisk) DeleteReturns(result1 error) {
	fake.DeleteStub = nil
	fake.deleteReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeOrphanDisk) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.cIDMutex.RLock()
	defer fake.cIDMutex.RUnlock()
	fake.sizeMutex.RLock()
	defer fake.sizeMutex.RUnlock()
	fake.deploymentMutex.RLock()
	defer fake.deploymentMutex.RUnlock()
	fake.instanceNameMutex.RLock()
	defer fake.instanceNameMutex.RUnlock()
	fake.aZNameMutex.RLock()
	defer fake.aZNameMutex.RUnlock()
	fake.orphanedAtMutex.RLock()
	defer fake.orphanedAtMutex.RUnlock()
	fake.deleteMutex.RLock()
	defer fake.deleteMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeOrphanDisk) 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 _ director.OrphanDisk = new(FakeOrphanDisk)