fake_ceph_client.go

// This file was generated by counterfeiter
package cephfakes

import (
	"sync"

	"code.cloudfoundry.org/cephbroker/cephbroker"
	"code.cloudfoundry.org/voldriver"
)

type FakeClient struct {
	IsFilesystemMountedStub        func(voldriver.Env) bool
	isFilesystemMountedMutex       sync.RWMutex
	isFilesystemMountedArgsForCall []struct {
		arg1 voldriver.Env
	}
	isFilesystemMountedReturns struct {
		result1 bool
	}
	MountFileSystemStub        func(voldriver.Env, string) (string, error)
	mountFileSystemMutex       sync.RWMutex
	mountFileSystemArgsForCall []struct {
		arg1 voldriver.Env
		arg2 string
	}
	mountFileSystemReturns struct {
		result1 string
		result2 error
	}
	CreateShareStub        func(voldriver.Env, string) (string, error)
	createShareMutex       sync.RWMutex
	createShareArgsForCall []struct {
		arg1 voldriver.Env
		arg2 string
	}
	createShareReturns struct {
		result1 string
		result2 error
	}
	DeleteShareStub        func(voldriver.Env, string) error
	deleteShareMutex       sync.RWMutex
	deleteShareArgsForCall []struct {
		arg1 voldriver.Env
		arg2 string
	}
	deleteShareReturns struct {
		result1 error
	}
	GetPathsForShareStub        func(voldriver.Env, string) (string, string, error)
	getPathsForShareMutex       sync.RWMutex
	getPathsForShareArgsForCall []struct {
		arg1 voldriver.Env
		arg2 string
	}
	getPathsForShareReturns struct {
		result1 string
		result2 string
		result3 error
	}
	GetConfigDetailsStub        func(voldriver.Env) (string, string, error)
	getConfigDetailsMutex       sync.RWMutex
	getConfigDetailsArgsForCall []struct {
		arg1 voldriver.Env
	}
	getConfigDetailsReturns struct {
		result1 string
		result2 string
		result3 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeClient) IsFilesystemMounted(arg1 voldriver.Env) bool {
	fake.isFilesystemMountedMutex.Lock()
	fake.isFilesystemMountedArgsForCall = append(fake.isFilesystemMountedArgsForCall, struct {
		arg1 voldriver.Env
	}{arg1})
	fake.recordInvocation("IsFilesystemMounted", []interface{}{arg1})
	fake.isFilesystemMountedMutex.Unlock()
	if fake.IsFilesystemMountedStub != nil {
		return fake.IsFilesystemMountedStub(arg1)
	} else {
		return fake.isFilesystemMountedReturns.result1
	}
}

func (fake *FakeClient) IsFilesystemMountedCallCount() int {
	fake.isFilesystemMountedMutex.RLock()
	defer fake.isFilesystemMountedMutex.RUnlock()
	return len(fake.isFilesystemMountedArgsForCall)
}

func (fake *FakeClient) IsFilesystemMountedArgsForCall(i int) voldriver.Env {
	fake.isFilesystemMountedMutex.RLock()
	defer fake.isFilesystemMountedMutex.RUnlock()
	return fake.isFilesystemMountedArgsForCall[i].arg1
}

func (fake *FakeClient) IsFilesystemMountedReturns(result1 bool) {
	fake.IsFilesystemMountedStub = nil
	fake.isFilesystemMountedReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeClient) MountFileSystem(arg1 voldriver.Env, arg2 string) (string, error) {
	fake.mountFileSystemMutex.Lock()
	fake.mountFileSystemArgsForCall = append(fake.mountFileSystemArgsForCall, struct {
		arg1 voldriver.Env
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("MountFileSystem", []interface{}{arg1, arg2})
	fake.mountFileSystemMutex.Unlock()
	if fake.MountFileSystemStub != nil {
		return fake.MountFileSystemStub(arg1, arg2)
	} else {
		return fake.mountFileSystemReturns.result1, fake.mountFileSystemReturns.result2
	}
}

func (fake *FakeClient) MountFileSystemCallCount() int {
	fake.mountFileSystemMutex.RLock()
	defer fake.mountFileSystemMutex.RUnlock()
	return len(fake.mountFileSystemArgsForCall)
}

func (fake *FakeClient) MountFileSystemArgsForCall(i int) (voldriver.Env, string) {
	fake.mountFileSystemMutex.RLock()
	defer fake.mountFileSystemMutex.RUnlock()
	return fake.mountFileSystemArgsForCall[i].arg1, fake.mountFileSystemArgsForCall[i].arg2
}

func (fake *FakeClient) MountFileSystemReturns(result1 string, result2 error) {
	fake.MountFileSystemStub = nil
	fake.mountFileSystemReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) CreateShare(arg1 voldriver.Env, arg2 string) (string, error) {
	fake.createShareMutex.Lock()
	fake.createShareArgsForCall = append(fake.createShareArgsForCall, struct {
		arg1 voldriver.Env
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreateShare", []interface{}{arg1, arg2})
	fake.createShareMutex.Unlock()
	if fake.CreateShareStub != nil {
		return fake.CreateShareStub(arg1, arg2)
	} else {
		return fake.createShareReturns.result1, fake.createShareReturns.result2
	}
}

func (fake *FakeClient) CreateShareCallCount() int {
	fake.createShareMutex.RLock()
	defer fake.createShareMutex.RUnlock()
	return len(fake.createShareArgsForCall)
}

func (fake *FakeClient) CreateShareArgsForCall(i int) (voldriver.Env, string) {
	fake.createShareMutex.RLock()
	defer fake.createShareMutex.RUnlock()
	return fake.createShareArgsForCall[i].arg1, fake.createShareArgsForCall[i].arg2
}

func (fake *FakeClient) CreateShareReturns(result1 string, result2 error) {
	fake.CreateShareStub = nil
	fake.createShareReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) DeleteShare(arg1 voldriver.Env, arg2 string) error {
	fake.deleteShareMutex.Lock()
	fake.deleteShareArgsForCall = append(fake.deleteShareArgsForCall, struct {
		arg1 voldriver.Env
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteShare", []interface{}{arg1, arg2})
	fake.deleteShareMutex.Unlock()
	if fake.DeleteShareStub != nil {
		return fake.DeleteShareStub(arg1, arg2)
	} else {
		return fake.deleteShareReturns.result1
	}
}

func (fake *FakeClient) DeleteShareCallCount() int {
	fake.deleteShareMutex.RLock()
	defer fake.deleteShareMutex.RUnlock()
	return len(fake.deleteShareArgsForCall)
}

func (fake *FakeClient) DeleteShareArgsForCall(i int) (voldriver.Env, string) {
	fake.deleteShareMutex.RLock()
	defer fake.deleteShareMutex.RUnlock()
	return fake.deleteShareArgsForCall[i].arg1, fake.deleteShareArgsForCall[i].arg2
}

func (fake *FakeClient) DeleteShareReturns(result1 error) {
	fake.DeleteShareStub = nil
	fake.deleteShareReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClient) GetPathsForShare(arg1 voldriver.Env, arg2 string) (string, string, error) {
	fake.getPathsForShareMutex.Lock()
	fake.getPathsForShareArgsForCall = append(fake.getPathsForShareArgsForCall, struct {
		arg1 voldriver.Env
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetPathsForShare", []interface{}{arg1, arg2})
	fake.getPathsForShareMutex.Unlock()
	if fake.GetPathsForShareStub != nil {
		return fake.GetPathsForShareStub(arg1, arg2)
	} else {
		return fake.getPathsForShareReturns.result1, fake.getPathsForShareReturns.result2, fake.getPathsForShareReturns.result3
	}
}

func (fake *FakeClient) GetPathsForShareCallCount() int {
	fake.getPathsForShareMutex.RLock()
	defer fake.getPathsForShareMutex.RUnlock()
	return len(fake.getPathsForShareArgsForCall)
}

func (fake *FakeClient) GetPathsForShareArgsForCall(i int) (voldriver.Env, string) {
	fake.getPathsForShareMutex.RLock()
	defer fake.getPathsForShareMutex.RUnlock()
	return fake.getPathsForShareArgsForCall[i].arg1, fake.getPathsForShareArgsForCall[i].arg2
}

func (fake *FakeClient) GetPathsForShareReturns(result1 string, result2 string, result3 error) {
	fake.GetPathsForShareStub = nil
	fake.getPathsForShareReturns = struct {
		result1 string
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeClient) GetConfigDetails(arg1 voldriver.Env) (string, string, error) {
	fake.getConfigDetailsMutex.Lock()
	fake.getConfigDetailsArgsForCall = append(fake.getConfigDetailsArgsForCall, struct {
		arg1 voldriver.Env
	}{arg1})
	fake.recordInvocation("GetConfigDetails", []interface{}{arg1})
	fake.getConfigDetailsMutex.Unlock()
	if fake.GetConfigDetailsStub != nil {
		return fake.GetConfigDetailsStub(arg1)
	} else {
		return fake.getConfigDetailsReturns.result1, fake.getConfigDetailsReturns.result2, fake.getConfigDetailsReturns.result3
	}
}

func (fake *FakeClient) GetConfigDetailsCallCount() int {
	fake.getConfigDetailsMutex.RLock()
	defer fake.getConfigDetailsMutex.RUnlock()
	return len(fake.getConfigDetailsArgsForCall)
}

func (fake *FakeClient) GetConfigDetailsArgsForCall(i int) voldriver.Env {
	fake.getConfigDetailsMutex.RLock()
	defer fake.getConfigDetailsMutex.RUnlock()
	return fake.getConfigDetailsArgsForCall[i].arg1
}

func (fake *FakeClient) GetConfigDetailsReturns(result1 string, result2 string, result3 error) {
	fake.GetConfigDetailsStub = nil
	fake.getConfigDetailsReturns = struct {
		result1 string
		result2 string
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeClient) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.isFilesystemMountedMutex.RLock()
	defer fake.isFilesystemMountedMutex.RUnlock()
	fake.mountFileSystemMutex.RLock()
	defer fake.mountFileSystemMutex.RUnlock()
	fake.createShareMutex.RLock()
	defer fake.createShareMutex.RUnlock()
	fake.deleteShareMutex.RLock()
	defer fake.deleteShareMutex.RUnlock()
	fake.getPathsForShareMutex.RLock()
	defer fake.getPathsForShareMutex.RUnlock()
	fake.getConfigDetailsMutex.RLock()
	defer fake.getConfigDetailsMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeClient) 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 _ cephbroker.Client = new(FakeClient)