github.com/liamawhite/cli-with-i18n@v6.32.1-0.20171122084555-dede0a5c3448+incompatible/cf/actors/actorsfakes/fake_service_plan_actor.go

// This file was generated by counterfeiter
package actorsfakes

import (
	"sync"

	"github.com/liamawhite/cli-with-i18n/cf/actors"
)

type FakeServicePlanActor struct {
	FindServiceAccessStub        func(string, string) (actors.ServiceAccess, error)
	findServiceAccessMutex       sync.RWMutex
	findServiceAccessArgsForCall []struct {
		arg1 string
		arg2 string
	}
	findServiceAccessReturns struct {
		result1 actors.ServiceAccess
		result2 error
	}
	UpdateAllPlansForServiceStub        func(string, bool) error
	updateAllPlansForServiceMutex       sync.RWMutex
	updateAllPlansForServiceArgsForCall []struct {
		arg1 string
		arg2 bool
	}
	updateAllPlansForServiceReturns struct {
		result1 error
	}
	UpdateOrgForServiceStub        func(string, string, bool) error
	updateOrgForServiceMutex       sync.RWMutex
	updateOrgForServiceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 bool
	}
	updateOrgForServiceReturns struct {
		result1 error
	}
	UpdateSinglePlanForServiceStub        func(string, string, bool) error
	updateSinglePlanForServiceMutex       sync.RWMutex
	updateSinglePlanForServiceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 bool
	}
	updateSinglePlanForServiceReturns struct {
		result1 error
	}
	UpdatePlanAndOrgForServiceStub        func(string, string, string, bool) error
	updatePlanAndOrgForServiceMutex       sync.RWMutex
	updatePlanAndOrgForServiceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 bool
	}
	updatePlanAndOrgForServiceReturns struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeServicePlanActor) FindServiceAccess(arg1 string, arg2 string) (actors.ServiceAccess, error) {
	fake.findServiceAccessMutex.Lock()
	fake.findServiceAccessArgsForCall = append(fake.findServiceAccessArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("FindServiceAccess", []interface{}{arg1, arg2})
	fake.findServiceAccessMutex.Unlock()
	if fake.FindServiceAccessStub != nil {
		return fake.FindServiceAccessStub(arg1, arg2)
	} else {
		return fake.findServiceAccessReturns.result1, fake.findServiceAccessReturns.result2
	}
}

func (fake *FakeServicePlanActor) FindServiceAccessCallCount() int {
	fake.findServiceAccessMutex.RLock()
	defer fake.findServiceAccessMutex.RUnlock()
	return len(fake.findServiceAccessArgsForCall)
}

func (fake *FakeServicePlanActor) FindServiceAccessArgsForCall(i int) (string, string) {
	fake.findServiceAccessMutex.RLock()
	defer fake.findServiceAccessMutex.RUnlock()
	return fake.findServiceAccessArgsForCall[i].arg1, fake.findServiceAccessArgsForCall[i].arg2
}

func (fake *FakeServicePlanActor) FindServiceAccessReturns(result1 actors.ServiceAccess, result2 error) {
	fake.FindServiceAccessStub = nil
	fake.findServiceAccessReturns = struct {
		result1 actors.ServiceAccess
		result2 error
	}{result1, result2}
}

func (fake *FakeServicePlanActor) UpdateAllPlansForService(arg1 string, arg2 bool) error {
	fake.updateAllPlansForServiceMutex.Lock()
	fake.updateAllPlansForServiceArgsForCall = append(fake.updateAllPlansForServiceArgsForCall, struct {
		arg1 string
		arg2 bool
	}{arg1, arg2})
	fake.recordInvocation("UpdateAllPlansForService", []interface{}{arg1, arg2})
	fake.updateAllPlansForServiceMutex.Unlock()
	if fake.UpdateAllPlansForServiceStub != nil {
		return fake.UpdateAllPlansForServiceStub(arg1, arg2)
	} else {
		return fake.updateAllPlansForServiceReturns.result1
	}
}

func (fake *FakeServicePlanActor) UpdateAllPlansForServiceCallCount() int {
	fake.updateAllPlansForServiceMutex.RLock()
	defer fake.updateAllPlansForServiceMutex.RUnlock()
	return len(fake.updateAllPlansForServiceArgsForCall)
}

func (fake *FakeServicePlanActor) UpdateAllPlansForServiceArgsForCall(i int) (string, bool) {
	fake.updateAllPlansForServiceMutex.RLock()
	defer fake.updateAllPlansForServiceMutex.RUnlock()
	return fake.updateAllPlansForServiceArgsForCall[i].arg1, fake.updateAllPlansForServiceArgsForCall[i].arg2
}

func (fake *FakeServicePlanActor) UpdateAllPlansForServiceReturns(result1 error) {
	fake.UpdateAllPlansForServiceStub = nil
	fake.updateAllPlansForServiceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServicePlanActor) UpdateOrgForService(arg1 string, arg2 string, arg3 bool) error {
	fake.updateOrgForServiceMutex.Lock()
	fake.updateOrgForServiceArgsForCall = append(fake.updateOrgForServiceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 bool
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateOrgForService", []interface{}{arg1, arg2, arg3})
	fake.updateOrgForServiceMutex.Unlock()
	if fake.UpdateOrgForServiceStub != nil {
		return fake.UpdateOrgForServiceStub(arg1, arg2, arg3)
	} else {
		return fake.updateOrgForServiceReturns.result1
	}
}

func (fake *FakeServicePlanActor) UpdateOrgForServiceCallCount() int {
	fake.updateOrgForServiceMutex.RLock()
	defer fake.updateOrgForServiceMutex.RUnlock()
	return len(fake.updateOrgForServiceArgsForCall)
}

func (fake *FakeServicePlanActor) UpdateOrgForServiceArgsForCall(i int) (string, string, bool) {
	fake.updateOrgForServiceMutex.RLock()
	defer fake.updateOrgForServiceMutex.RUnlock()
	return fake.updateOrgForServiceArgsForCall[i].arg1, fake.updateOrgForServiceArgsForCall[i].arg2, fake.updateOrgForServiceArgsForCall[i].arg3
}

func (fake *FakeServicePlanActor) UpdateOrgForServiceReturns(result1 error) {
	fake.UpdateOrgForServiceStub = nil
	fake.updateOrgForServiceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServicePlanActor) UpdateSinglePlanForService(arg1 string, arg2 string, arg3 bool) error {
	fake.updateSinglePlanForServiceMutex.Lock()
	fake.updateSinglePlanForServiceArgsForCall = append(fake.updateSinglePlanForServiceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 bool
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateSinglePlanForService", []interface{}{arg1, arg2, arg3})
	fake.updateSinglePlanForServiceMutex.Unlock()
	if fake.UpdateSinglePlanForServiceStub != nil {
		return fake.UpdateSinglePlanForServiceStub(arg1, arg2, arg3)
	} else {
		return fake.updateSinglePlanForServiceReturns.result1
	}
}

func (fake *FakeServicePlanActor) UpdateSinglePlanForServiceCallCount() int {
	fake.updateSinglePlanForServiceMutex.RLock()
	defer fake.updateSinglePlanForServiceMutex.RUnlock()
	return len(fake.updateSinglePlanForServiceArgsForCall)
}

func (fake *FakeServicePlanActor) UpdateSinglePlanForServiceArgsForCall(i int) (string, string, bool) {
	fake.updateSinglePlanForServiceMutex.RLock()
	defer fake.updateSinglePlanForServiceMutex.RUnlock()
	return fake.updateSinglePlanForServiceArgsForCall[i].arg1, fake.updateSinglePlanForServiceArgsForCall[i].arg2, fake.updateSinglePlanForServiceArgsForCall[i].arg3
}

func (fake *FakeServicePlanActor) UpdateSinglePlanForServiceReturns(result1 error) {
	fake.UpdateSinglePlanForServiceStub = nil
	fake.updateSinglePlanForServiceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServicePlanActor) UpdatePlanAndOrgForService(arg1 string, arg2 string, arg3 string, arg4 bool) error {
	fake.updatePlanAndOrgForServiceMutex.Lock()
	fake.updatePlanAndOrgForServiceArgsForCall = append(fake.updatePlanAndOrgForServiceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 bool
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("UpdatePlanAndOrgForService", []interface{}{arg1, arg2, arg3, arg4})
	fake.updatePlanAndOrgForServiceMutex.Unlock()
	if fake.UpdatePlanAndOrgForServiceStub != nil {
		return fake.UpdatePlanAndOrgForServiceStub(arg1, arg2, arg3, arg4)
	} else {
		return fake.updatePlanAndOrgForServiceReturns.result1
	}
}

func (fake *FakeServicePlanActor) UpdatePlanAndOrgForServiceCallCount() int {
	fake.updatePlanAndOrgForServiceMutex.RLock()
	defer fake.updatePlanAndOrgForServiceMutex.RUnlock()
	return len(fake.updatePlanAndOrgForServiceArgsForCall)
}

func (fake *FakeServicePlanActor) UpdatePlanAndOrgForServiceArgsForCall(i int) (string, string, string, bool) {
	fake.updatePlanAndOrgForServiceMutex.RLock()
	defer fake.updatePlanAndOrgForServiceMutex.RUnlock()
	return fake.updatePlanAndOrgForServiceArgsForCall[i].arg1, fake.updatePlanAndOrgForServiceArgsForCall[i].arg2, fake.updatePlanAndOrgForServiceArgsForCall[i].arg3, fake.updatePlanAndOrgForServiceArgsForCall[i].arg4
}

func (fake *FakeServicePlanActor) UpdatePlanAndOrgForServiceReturns(result1 error) {
	fake.UpdatePlanAndOrgForServiceStub = nil
	fake.updatePlanAndOrgForServiceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeServicePlanActor) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.findServiceAccessMutex.RLock()
	defer fake.findServiceAccessMutex.RUnlock()
	fake.updateAllPlansForServiceMutex.RLock()
	defer fake.updateAllPlansForServiceMutex.RUnlock()
	fake.updateOrgForServiceMutex.RLock()
	defer fake.updateOrgForServiceMutex.RUnlock()
	fake.updateSinglePlanForServiceMutex.RLock()
	defer fake.updateSinglePlanForServiceMutex.RUnlock()
	fake.updatePlanAndOrgForServiceMutex.RLock()
	defer fake.updatePlanAndOrgForServiceMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeServicePlanActor) 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 _ actors.ServicePlanActor = new(FakeServicePlanActor)