fake_iserver_client.go

// Code generated by counterfeiter. DO NOT EDIT.
package serverfakes

import (
	"context"
	"sync"

	"github.com/streamdal/streamdal/sdks/go/server"
	"github.com/streamdal/streamdal/sdks/go/types"
	"github.com/streamdal/streamdal/libs/protos/build/go/protos"
)

type FakeIServerClient struct {
	GetSetPipelinesCommandByServiceStub        func(context.Context, string) (*protos.GetSetPipelinesCommandsByServiceResponse, error)
	getSetPipelinesCommandByServiceMutex       sync.RWMutex
	getSetPipelinesCommandByServiceArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	getSetPipelinesCommandByServiceReturns struct {
		result1 *protos.GetSetPipelinesCommandsByServiceResponse
		result2 error
	}
	getSetPipelinesCommandByServiceReturnsOnCall map[int]struct {
		result1 *protos.GetSetPipelinesCommandsByServiceResponse
		result2 error
	}
	GetTailStreamStub        func(context.Context) (protos.Internal_SendTailClient, error)
	getTailStreamMutex       sync.RWMutex
	getTailStreamArgsForCall []struct {
		arg1 context.Context
	}
	getTailStreamReturns struct {
		result1 protos.Internal_SendTailClient
		result2 error
	}
	getTailStreamReturnsOnCall map[int]struct {
		result1 protos.Internal_SendTailClient
		result2 error
	}
	HeartBeatStub        func(context.Context, *protos.HeartbeatRequest) error
	heartBeatMutex       sync.RWMutex
	heartBeatArgsForCall []struct {
		arg1 context.Context
		arg2 *protos.HeartbeatRequest
	}
	heartBeatReturns struct {
		result1 error
	}
	heartBeatReturnsOnCall map[int]struct {
		result1 error
	}
	NewAudienceStub        func(context.Context, *protos.Audience, string) error
	newAudienceMutex       sync.RWMutex
	newAudienceArgsForCall []struct {
		arg1 context.Context
		arg2 *protos.Audience
		arg3 string
	}
	newAudienceReturns struct {
		result1 error
	}
	newAudienceReturnsOnCall map[int]struct {
		result1 error
	}
	NotifyStub        func(context.Context, *protos.Pipeline, *protos.PipelineStep, *protos.Audience, []byte, protos.NotifyRequest_ConditionType) error
	notifyMutex       sync.RWMutex
	notifyArgsForCall []struct {
		arg1 context.Context
		arg2 *protos.Pipeline
		arg3 *protos.PipelineStep
		arg4 *protos.Audience
		arg5 []byte
		arg6 protos.NotifyRequest_ConditionType
	}
	notifyReturns struct {
		result1 error
	}
	notifyReturnsOnCall map[int]struct {
		result1 error
	}
	ReconnectStub        func() error
	reconnectMutex       sync.RWMutex
	reconnectArgsForCall []struct {
	}
	reconnectReturns struct {
		result1 error
	}
	reconnectReturnsOnCall map[int]struct {
		result1 error
	}
	RegisterStub        func(context.Context, *protos.RegisterRequest) (protos.Internal_RegisterClient, error)
	registerMutex       sync.RWMutex
	registerArgsForCall []struct {
		arg1 context.Context
		arg2 *protos.RegisterRequest
	}
	registerReturns struct {
		result1 protos.Internal_RegisterClient
		result2 error
	}
	registerReturnsOnCall map[int]struct {
		result1 protos.Internal_RegisterClient
		result2 error
	}
	SendMetricsStub        func(context.Context, []*types.CounterEntry) error
	sendMetricsMutex       sync.RWMutex
	sendMetricsArgsForCall []struct {
		arg1 context.Context
		arg2 []*types.CounterEntry
	}
	sendMetricsReturns struct {
		result1 error
	}
	sendMetricsReturnsOnCall map[int]struct {
		result1 error
	}
	SendSchemaStub        func(context.Context, *protos.Audience, []byte) error
	sendSchemaMutex       sync.RWMutex
	sendSchemaArgsForCall []struct {
		arg1 context.Context
		arg2 *protos.Audience
		arg3 []byte
	}
	sendSchemaReturns struct {
		result1 error
	}
	sendSchemaReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeIServerClient) GetSetPipelinesCommandByService(arg1 context.Context, arg2 string) (*protos.GetSetPipelinesCommandsByServiceResponse, error) {
	fake.getSetPipelinesCommandByServiceMutex.Lock()
	ret, specificReturn := fake.getSetPipelinesCommandByServiceReturnsOnCall[len(fake.getSetPipelinesCommandByServiceArgsForCall)]
	fake.getSetPipelinesCommandByServiceArgsForCall = append(fake.getSetPipelinesCommandByServiceArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.GetSetPipelinesCommandByServiceStub
	fakeReturns := fake.getSetPipelinesCommandByServiceReturns
	fake.recordInvocation("GetSetPipelinesCommandByService", []interface{}{arg1, arg2})
	fake.getSetPipelinesCommandByServiceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeIServerClient) GetSetPipelinesCommandByServiceCallCount() int {
	fake.getSetPipelinesCommandByServiceMutex.RLock()
	defer fake.getSetPipelinesCommandByServiceMutex.RUnlock()
	return len(fake.getSetPipelinesCommandByServiceArgsForCall)
}

func (fake *FakeIServerClient) GetSetPipelinesCommandByServiceCalls(stub func(context.Context, string) (*protos.GetSetPipelinesCommandsByServiceResponse, error)) {
	fake.getSetPipelinesCommandByServiceMutex.Lock()
	defer fake.getSetPipelinesCommandByServiceMutex.Unlock()
	fake.GetSetPipelinesCommandByServiceStub = stub
}

func (fake *FakeIServerClient) GetSetPipelinesCommandByServiceArgsForCall(i int) (context.Context, string) {
	fake.getSetPipelinesCommandByServiceMutex.RLock()
	defer fake.getSetPipelinesCommandByServiceMutex.RUnlock()
	argsForCall := fake.getSetPipelinesCommandByServiceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeIServerClient) GetSetPipelinesCommandByServiceReturns(result1 *protos.GetSetPipelinesCommandsByServiceResponse, result2 error) {
	fake.getSetPipelinesCommandByServiceMutex.Lock()
	defer fake.getSetPipelinesCommandByServiceMutex.Unlock()
	fake.GetSetPipelinesCommandByServiceStub = nil
	fake.getSetPipelinesCommandByServiceReturns = struct {
		result1 *protos.GetSetPipelinesCommandsByServiceResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeIServerClient) GetSetPipelinesCommandByServiceReturnsOnCall(i int, result1 *protos.GetSetPipelinesCommandsByServiceResponse, result2 error) {
	fake.getSetPipelinesCommandByServiceMutex.Lock()
	defer fake.getSetPipelinesCommandByServiceMutex.Unlock()
	fake.GetSetPipelinesCommandByServiceStub = nil
	if fake.getSetPipelinesCommandByServiceReturnsOnCall == nil {
		fake.getSetPipelinesCommandByServiceReturnsOnCall = make(map[int]struct {
			result1 *protos.GetSetPipelinesCommandsByServiceResponse
			result2 error
		})
	}
	fake.getSetPipelinesCommandByServiceReturnsOnCall[i] = struct {
		result1 *protos.GetSetPipelinesCommandsByServiceResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeIServerClient) GetTailStream(arg1 context.Context) (protos.Internal_SendTailClient, error) {
	fake.getTailStreamMutex.Lock()
	ret, specificReturn := fake.getTailStreamReturnsOnCall[len(fake.getTailStreamArgsForCall)]
	fake.getTailStreamArgsForCall = append(fake.getTailStreamArgsForCall, struct {
		arg1 context.Context
	}{arg1})
	stub := fake.GetTailStreamStub
	fakeReturns := fake.getTailStreamReturns
	fake.recordInvocation("GetTailStream", []interface{}{arg1})
	fake.getTailStreamMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeIServerClient) GetTailStreamCallCount() int {
	fake.getTailStreamMutex.RLock()
	defer fake.getTailStreamMutex.RUnlock()
	return len(fake.getTailStreamArgsForCall)
}

func (fake *FakeIServerClient) GetTailStreamCalls(stub func(context.Context) (protos.Internal_SendTailClient, error)) {
	fake.getTailStreamMutex.Lock()
	defer fake.getTailStreamMutex.Unlock()
	fake.GetTailStreamStub = stub
}

func (fake *FakeIServerClient) GetTailStreamArgsForCall(i int) context.Context {
	fake.getTailStreamMutex.RLock()
	defer fake.getTailStreamMutex.RUnlock()
	argsForCall := fake.getTailStreamArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeIServerClient) GetTailStreamReturns(result1 protos.Internal_SendTailClient, result2 error) {
	fake.getTailStreamMutex.Lock()
	defer fake.getTailStreamMutex.Unlock()
	fake.GetTailStreamStub = nil
	fake.getTailStreamReturns = struct {
		result1 protos.Internal_SendTailClient
		result2 error
	}{result1, result2}
}

func (fake *FakeIServerClient) GetTailStreamReturnsOnCall(i int, result1 protos.Internal_SendTailClient, result2 error) {
	fake.getTailStreamMutex.Lock()
	defer fake.getTailStreamMutex.Unlock()
	fake.GetTailStreamStub = nil
	if fake.getTailStreamReturnsOnCall == nil {
		fake.getTailStreamReturnsOnCall = make(map[int]struct {
			result1 protos.Internal_SendTailClient
			result2 error
		})
	}
	fake.getTailStreamReturnsOnCall[i] = struct {
		result1 protos.Internal_SendTailClient
		result2 error
	}{result1, result2}
}

func (fake *FakeIServerClient) HeartBeat(arg1 context.Context, arg2 *protos.HeartbeatRequest) error {
	fake.heartBeatMutex.Lock()
	ret, specificReturn := fake.heartBeatReturnsOnCall[len(fake.heartBeatArgsForCall)]
	fake.heartBeatArgsForCall = append(fake.heartBeatArgsForCall, struct {
		arg1 context.Context
		arg2 *protos.HeartbeatRequest
	}{arg1, arg2})
	stub := fake.HeartBeatStub
	fakeReturns := fake.heartBeatReturns
	fake.recordInvocation("HeartBeat", []interface{}{arg1, arg2})
	fake.heartBeatMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeIServerClient) HeartBeatCallCount() int {
	fake.heartBeatMutex.RLock()
	defer fake.heartBeatMutex.RUnlock()
	return len(fake.heartBeatArgsForCall)
}

func (fake *FakeIServerClient) HeartBeatCalls(stub func(context.Context, *protos.HeartbeatRequest) error) {
	fake.heartBeatMutex.Lock()
	defer fake.heartBeatMutex.Unlock()
	fake.HeartBeatStub = stub
}

func (fake *FakeIServerClient) HeartBeatArgsForCall(i int) (context.Context, *protos.HeartbeatRequest) {
	fake.heartBeatMutex.RLock()
	defer fake.heartBeatMutex.RUnlock()
	argsForCall := fake.heartBeatArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeIServerClient) HeartBeatReturns(result1 error) {
	fake.heartBeatMutex.Lock()
	defer fake.heartBeatMutex.Unlock()
	fake.HeartBeatStub = nil
	fake.heartBeatReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) HeartBeatReturnsOnCall(i int, result1 error) {
	fake.heartBeatMutex.Lock()
	defer fake.heartBeatMutex.Unlock()
	fake.HeartBeatStub = nil
	if fake.heartBeatReturnsOnCall == nil {
		fake.heartBeatReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.heartBeatReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) NewAudience(arg1 context.Context, arg2 *protos.Audience, arg3 string) error {
	fake.newAudienceMutex.Lock()
	ret, specificReturn := fake.newAudienceReturnsOnCall[len(fake.newAudienceArgsForCall)]
	fake.newAudienceArgsForCall = append(fake.newAudienceArgsForCall, struct {
		arg1 context.Context
		arg2 *protos.Audience
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.NewAudienceStub
	fakeReturns := fake.newAudienceReturns
	fake.recordInvocation("NewAudience", []interface{}{arg1, arg2, arg3})
	fake.newAudienceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeIServerClient) NewAudienceCallCount() int {
	fake.newAudienceMutex.RLock()
	defer fake.newAudienceMutex.RUnlock()
	return len(fake.newAudienceArgsForCall)
}

func (fake *FakeIServerClient) NewAudienceCalls(stub func(context.Context, *protos.Audience, string) error) {
	fake.newAudienceMutex.Lock()
	defer fake.newAudienceMutex.Unlock()
	fake.NewAudienceStub = stub
}

func (fake *FakeIServerClient) NewAudienceArgsForCall(i int) (context.Context, *protos.Audience, string) {
	fake.newAudienceMutex.RLock()
	defer fake.newAudienceMutex.RUnlock()
	argsForCall := fake.newAudienceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeIServerClient) NewAudienceReturns(result1 error) {
	fake.newAudienceMutex.Lock()
	defer fake.newAudienceMutex.Unlock()
	fake.NewAudienceStub = nil
	fake.newAudienceReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) NewAudienceReturnsOnCall(i int, result1 error) {
	fake.newAudienceMutex.Lock()
	defer fake.newAudienceMutex.Unlock()
	fake.NewAudienceStub = nil
	if fake.newAudienceReturnsOnCall == nil {
		fake.newAudienceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.newAudienceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) Notify(arg1 context.Context, arg2 *protos.Pipeline, arg3 *protos.PipelineStep, arg4 *protos.Audience, arg5 []byte, arg6 protos.NotifyRequest_ConditionType) error {
	var arg5Copy []byte
	if arg5 != nil {
		arg5Copy = make([]byte, len(arg5))
		copy(arg5Copy, arg5)
	}
	fake.notifyMutex.Lock()
	ret, specificReturn := fake.notifyReturnsOnCall[len(fake.notifyArgsForCall)]
	fake.notifyArgsForCall = append(fake.notifyArgsForCall, struct {
		arg1 context.Context
		arg2 *protos.Pipeline
		arg3 *protos.PipelineStep
		arg4 *protos.Audience
		arg5 []byte
		arg6 protos.NotifyRequest_ConditionType
	}{arg1, arg2, arg3, arg4, arg5Copy, arg6})
	stub := fake.NotifyStub
	fakeReturns := fake.notifyReturns
	fake.recordInvocation("Notify", []interface{}{arg1, arg2, arg3, arg4, arg5Copy, arg6})
	fake.notifyMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeIServerClient) NotifyCallCount() int {
	fake.notifyMutex.RLock()
	defer fake.notifyMutex.RUnlock()
	return len(fake.notifyArgsForCall)
}

func (fake *FakeIServerClient) NotifyCalls(stub func(context.Context, *protos.Pipeline, *protos.PipelineStep, *protos.Audience, []byte, protos.NotifyRequest_ConditionType) error) {
	fake.notifyMutex.Lock()
	defer fake.notifyMutex.Unlock()
	fake.NotifyStub = stub
}

func (fake *FakeIServerClient) NotifyArgsForCall(i int) (context.Context, *protos.Pipeline, *protos.PipelineStep, *protos.Audience, []byte, protos.NotifyRequest_ConditionType) {
	fake.notifyMutex.RLock()
	defer fake.notifyMutex.RUnlock()
	argsForCall := fake.notifyArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
}

func (fake *FakeIServerClient) NotifyReturns(result1 error) {
	fake.notifyMutex.Lock()
	defer fake.notifyMutex.Unlock()
	fake.NotifyStub = nil
	fake.notifyReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) NotifyReturnsOnCall(i int, result1 error) {
	fake.notifyMutex.Lock()
	defer fake.notifyMutex.Unlock()
	fake.NotifyStub = nil
	if fake.notifyReturnsOnCall == nil {
		fake.notifyReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.notifyReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) Reconnect() error {
	fake.reconnectMutex.Lock()
	ret, specificReturn := fake.reconnectReturnsOnCall[len(fake.reconnectArgsForCall)]
	fake.reconnectArgsForCall = append(fake.reconnectArgsForCall, struct {
	}{})
	stub := fake.ReconnectStub
	fakeReturns := fake.reconnectReturns
	fake.recordInvocation("Reconnect", []interface{}{})
	fake.reconnectMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeIServerClient) ReconnectCallCount() int {
	fake.reconnectMutex.RLock()
	defer fake.reconnectMutex.RUnlock()
	return len(fake.reconnectArgsForCall)
}

func (fake *FakeIServerClient) ReconnectCalls(stub func() error) {
	fake.reconnectMutex.Lock()
	defer fake.reconnectMutex.Unlock()
	fake.ReconnectStub = stub
}

func (fake *FakeIServerClient) ReconnectReturns(result1 error) {
	fake.reconnectMutex.Lock()
	defer fake.reconnectMutex.Unlock()
	fake.ReconnectStub = nil
	fake.reconnectReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) ReconnectReturnsOnCall(i int, result1 error) {
	fake.reconnectMutex.Lock()
	defer fake.reconnectMutex.Unlock()
	fake.ReconnectStub = nil
	if fake.reconnectReturnsOnCall == nil {
		fake.reconnectReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.reconnectReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) Register(arg1 context.Context, arg2 *protos.RegisterRequest) (protos.Internal_RegisterClient, error) {
	fake.registerMutex.Lock()
	ret, specificReturn := fake.registerReturnsOnCall[len(fake.registerArgsForCall)]
	fake.registerArgsForCall = append(fake.registerArgsForCall, struct {
		arg1 context.Context
		arg2 *protos.RegisterRequest
	}{arg1, arg2})
	stub := fake.RegisterStub
	fakeReturns := fake.registerReturns
	fake.recordInvocation("Register", []interface{}{arg1, arg2})
	fake.registerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeIServerClient) RegisterCallCount() int {
	fake.registerMutex.RLock()
	defer fake.registerMutex.RUnlock()
	return len(fake.registerArgsForCall)
}

func (fake *FakeIServerClient) RegisterCalls(stub func(context.Context, *protos.RegisterRequest) (protos.Internal_RegisterClient, error)) {
	fake.registerMutex.Lock()
	defer fake.registerMutex.Unlock()
	fake.RegisterStub = stub
}

func (fake *FakeIServerClient) RegisterArgsForCall(i int) (context.Context, *protos.RegisterRequest) {
	fake.registerMutex.RLock()
	defer fake.registerMutex.RUnlock()
	argsForCall := fake.registerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeIServerClient) RegisterReturns(result1 protos.Internal_RegisterClient, result2 error) {
	fake.registerMutex.Lock()
	defer fake.registerMutex.Unlock()
	fake.RegisterStub = nil
	fake.registerReturns = struct {
		result1 protos.Internal_RegisterClient
		result2 error
	}{result1, result2}
}

func (fake *FakeIServerClient) RegisterReturnsOnCall(i int, result1 protos.Internal_RegisterClient, result2 error) {
	fake.registerMutex.Lock()
	defer fake.registerMutex.Unlock()
	fake.RegisterStub = nil
	if fake.registerReturnsOnCall == nil {
		fake.registerReturnsOnCall = make(map[int]struct {
			result1 protos.Internal_RegisterClient
			result2 error
		})
	}
	fake.registerReturnsOnCall[i] = struct {
		result1 protos.Internal_RegisterClient
		result2 error
	}{result1, result2}
}

func (fake *FakeIServerClient) SendMetrics(arg1 context.Context, arg2 []*types.CounterEntry) error {
	var arg2Copy []*types.CounterEntry
	if arg2 != nil {
		arg2Copy = make([]*types.CounterEntry, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.sendMetricsMutex.Lock()
	ret, specificReturn := fake.sendMetricsReturnsOnCall[len(fake.sendMetricsArgsForCall)]
	fake.sendMetricsArgsForCall = append(fake.sendMetricsArgsForCall, struct {
		arg1 context.Context
		arg2 []*types.CounterEntry
	}{arg1, arg2Copy})
	stub := fake.SendMetricsStub
	fakeReturns := fake.sendMetricsReturns
	fake.recordInvocation("SendMetrics", []interface{}{arg1, arg2Copy})
	fake.sendMetricsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeIServerClient) SendMetricsCallCount() int {
	fake.sendMetricsMutex.RLock()
	defer fake.sendMetricsMutex.RUnlock()
	return len(fake.sendMetricsArgsForCall)
}

func (fake *FakeIServerClient) SendMetricsCalls(stub func(context.Context, []*types.CounterEntry) error) {
	fake.sendMetricsMutex.Lock()
	defer fake.sendMetricsMutex.Unlock()
	fake.SendMetricsStub = stub
}

func (fake *FakeIServerClient) SendMetricsArgsForCall(i int) (context.Context, []*types.CounterEntry) {
	fake.sendMetricsMutex.RLock()
	defer fake.sendMetricsMutex.RUnlock()
	argsForCall := fake.sendMetricsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeIServerClient) SendMetricsReturns(result1 error) {
	fake.sendMetricsMutex.Lock()
	defer fake.sendMetricsMutex.Unlock()
	fake.SendMetricsStub = nil
	fake.sendMetricsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) SendMetricsReturnsOnCall(i int, result1 error) {
	fake.sendMetricsMutex.Lock()
	defer fake.sendMetricsMutex.Unlock()
	fake.SendMetricsStub = nil
	if fake.sendMetricsReturnsOnCall == nil {
		fake.sendMetricsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.sendMetricsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) SendSchema(arg1 context.Context, arg2 *protos.Audience, arg3 []byte) error {
	var arg3Copy []byte
	if arg3 != nil {
		arg3Copy = make([]byte, len(arg3))
		copy(arg3Copy, arg3)
	}
	fake.sendSchemaMutex.Lock()
	ret, specificReturn := fake.sendSchemaReturnsOnCall[len(fake.sendSchemaArgsForCall)]
	fake.sendSchemaArgsForCall = append(fake.sendSchemaArgsForCall, struct {
		arg1 context.Context
		arg2 *protos.Audience
		arg3 []byte
	}{arg1, arg2, arg3Copy})
	stub := fake.SendSchemaStub
	fakeReturns := fake.sendSchemaReturns
	fake.recordInvocation("SendSchema", []interface{}{arg1, arg2, arg3Copy})
	fake.sendSchemaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeIServerClient) SendSchemaCallCount() int {
	fake.sendSchemaMutex.RLock()
	defer fake.sendSchemaMutex.RUnlock()
	return len(fake.sendSchemaArgsForCall)
}

func (fake *FakeIServerClient) SendSchemaCalls(stub func(context.Context, *protos.Audience, []byte) error) {
	fake.sendSchemaMutex.Lock()
	defer fake.sendSchemaMutex.Unlock()
	fake.SendSchemaStub = stub
}

func (fake *FakeIServerClient) SendSchemaArgsForCall(i int) (context.Context, *protos.Audience, []byte) {
	fake.sendSchemaMutex.RLock()
	defer fake.sendSchemaMutex.RUnlock()
	argsForCall := fake.sendSchemaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeIServerClient) SendSchemaReturns(result1 error) {
	fake.sendSchemaMutex.Lock()
	defer fake.sendSchemaMutex.Unlock()
	fake.SendSchemaStub = nil
	fake.sendSchemaReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) SendSchemaReturnsOnCall(i int, result1 error) {
	fake.sendSchemaMutex.Lock()
	defer fake.sendSchemaMutex.Unlock()
	fake.SendSchemaStub = nil
	if fake.sendSchemaReturnsOnCall == nil {
		fake.sendSchemaReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.sendSchemaReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeIServerClient) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.getSetPipelinesCommandByServiceMutex.RLock()
	defer fake.getSetPipelinesCommandByServiceMutex.RUnlock()
	fake.getTailStreamMutex.RLock()
	defer fake.getTailStreamMutex.RUnlock()
	fake.heartBeatMutex.RLock()
	defer fake.heartBeatMutex.RUnlock()
	fake.newAudienceMutex.RLock()
	defer fake.newAudienceMutex.RUnlock()
	fake.notifyMutex.RLock()
	defer fake.notifyMutex.RUnlock()
	fake.reconnectMutex.RLock()
	defer fake.reconnectMutex.RUnlock()
	fake.registerMutex.RLock()
	defer fake.registerMutex.RUnlock()
	fake.sendMetricsMutex.RLock()
	defer fake.sendMetricsMutex.RUnlock()
	fake.sendSchemaMutex.RLock()
	defer fake.sendSchemaMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeIServerClient) 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 _ server.IServerClient = new(FakeIServerClient)