mock_TestServiceServer.go

// Code generated by mockery v2.34.2. DO NOT EDIT.

package mocks

import (
	context "context"

	testproto "github.com/avos-io/goat/gen/testproto"
	mock "github.com/stretchr/testify/mock"
)

// MockTestServiceServer is an autogenerated mock type for the TestServiceServer type
type MockTestServiceServer struct {
	mock.Mock
}

type MockTestServiceServer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTestServiceServer) EXPECT() *MockTestServiceServer_Expecter {
	return &MockTestServiceServer_Expecter{mock: &_m.Mock}
}

// BidiStream provides a mock function with given fields: _a0
func (_m *MockTestServiceServer) BidiStream(_a0 testproto.TestService_BidiStreamServer) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(testproto.TestService_BidiStreamServer) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockTestServiceServer_BidiStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BidiStream'
type MockTestServiceServer_BidiStream_Call struct {
	*mock.Call
}

// BidiStream is a helper method to define mock.On call
//   - _a0 testproto.TestService_BidiStreamServer
func (_e *MockTestServiceServer_Expecter) BidiStream(_a0 interface{}) *MockTestServiceServer_BidiStream_Call {
	return &MockTestServiceServer_BidiStream_Call{Call: _e.mock.On("BidiStream", _a0)}
}

func (_c *MockTestServiceServer_BidiStream_Call) Run(run func(_a0 testproto.TestService_BidiStreamServer)) *MockTestServiceServer_BidiStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(testproto.TestService_BidiStreamServer))
	})
	return _c
}

func (_c *MockTestServiceServer_BidiStream_Call) Return(_a0 error) *MockTestServiceServer_BidiStream_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockTestServiceServer_BidiStream_Call) RunAndReturn(run func(testproto.TestService_BidiStreamServer) error) *MockTestServiceServer_BidiStream_Call {
	_c.Call.Return(run)
	return _c
}

// ClientStream provides a mock function with given fields: _a0
func (_m *MockTestServiceServer) ClientStream(_a0 testproto.TestService_ClientStreamServer) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(testproto.TestService_ClientStreamServer) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockTestServiceServer_ClientStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientStream'
type MockTestServiceServer_ClientStream_Call struct {
	*mock.Call
}

// ClientStream is a helper method to define mock.On call
//   - _a0 testproto.TestService_ClientStreamServer
func (_e *MockTestServiceServer_Expecter) ClientStream(_a0 interface{}) *MockTestServiceServer_ClientStream_Call {
	return &MockTestServiceServer_ClientStream_Call{Call: _e.mock.On("ClientStream", _a0)}
}

func (_c *MockTestServiceServer_ClientStream_Call) Run(run func(_a0 testproto.TestService_ClientStreamServer)) *MockTestServiceServer_ClientStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(testproto.TestService_ClientStreamServer))
	})
	return _c
}

func (_c *MockTestServiceServer_ClientStream_Call) Return(_a0 error) *MockTestServiceServer_ClientStream_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockTestServiceServer_ClientStream_Call) RunAndReturn(run func(testproto.TestService_ClientStreamServer) error) *MockTestServiceServer_ClientStream_Call {
	_c.Call.Return(run)
	return _c
}

// ServerStream provides a mock function with given fields: _a0, _a1
func (_m *MockTestServiceServer) ServerStream(_a0 *testproto.Msg, _a1 testproto.TestService_ServerStreamServer) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*testproto.Msg, testproto.TestService_ServerStreamServer) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockTestServiceServer_ServerStream_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServerStream'
type MockTestServiceServer_ServerStream_Call struct {
	*mock.Call
}

// ServerStream is a helper method to define mock.On call
//   - _a0 *testproto.Msg
//   - _a1 testproto.TestService_ServerStreamServer
func (_e *MockTestServiceServer_Expecter) ServerStream(_a0 interface{}, _a1 interface{}) *MockTestServiceServer_ServerStream_Call {
	return &MockTestServiceServer_ServerStream_Call{Call: _e.mock.On("ServerStream", _a0, _a1)}
}

func (_c *MockTestServiceServer_ServerStream_Call) Run(run func(_a0 *testproto.Msg, _a1 testproto.TestService_ServerStreamServer)) *MockTestServiceServer_ServerStream_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*testproto.Msg), args[1].(testproto.TestService_ServerStreamServer))
	})
	return _c
}

func (_c *MockTestServiceServer_ServerStream_Call) Return(_a0 error) *MockTestServiceServer_ServerStream_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockTestServiceServer_ServerStream_Call) RunAndReturn(run func(*testproto.Msg, testproto.TestService_ServerStreamServer) error) *MockTestServiceServer_ServerStream_Call {
	_c.Call.Return(run)
	return _c
}

// ServerStreamThatSleeps provides a mock function with given fields: _a0, _a1
func (_m *MockTestServiceServer) ServerStreamThatSleeps(_a0 *testproto.Msg, _a1 testproto.TestService_ServerStreamThatSleepsServer) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*testproto.Msg, testproto.TestService_ServerStreamThatSleepsServer) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockTestServiceServer_ServerStreamThatSleeps_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServerStreamThatSleeps'
type MockTestServiceServer_ServerStreamThatSleeps_Call struct {
	*mock.Call
}

// ServerStreamThatSleeps is a helper method to define mock.On call
//   - _a0 *testproto.Msg
//   - _a1 testproto.TestService_ServerStreamThatSleepsServer
func (_e *MockTestServiceServer_Expecter) ServerStreamThatSleeps(_a0 interface{}, _a1 interface{}) *MockTestServiceServer_ServerStreamThatSleeps_Call {
	return &MockTestServiceServer_ServerStreamThatSleeps_Call{Call: _e.mock.On("ServerStreamThatSleeps", _a0, _a1)}
}

func (_c *MockTestServiceServer_ServerStreamThatSleeps_Call) Run(run func(_a0 *testproto.Msg, _a1 testproto.TestService_ServerStreamThatSleepsServer)) *MockTestServiceServer_ServerStreamThatSleeps_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*testproto.Msg), args[1].(testproto.TestService_ServerStreamThatSleepsServer))
	})
	return _c
}

func (_c *MockTestServiceServer_ServerStreamThatSleeps_Call) Return(_a0 error) *MockTestServiceServer_ServerStreamThatSleeps_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockTestServiceServer_ServerStreamThatSleeps_Call) RunAndReturn(run func(*testproto.Msg, testproto.TestService_ServerStreamThatSleepsServer) error) *MockTestServiceServer_ServerStreamThatSleeps_Call {
	_c.Call.Return(run)
	return _c
}

// Unary provides a mock function with given fields: _a0, _a1
func (_m *MockTestServiceServer) Unary(_a0 context.Context, _a1 *testproto.Msg) (*testproto.Msg, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *testproto.Msg
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *testproto.Msg) (*testproto.Msg, error)); ok {
		return rf(_a0, _a1)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *testproto.Msg) *testproto.Msg); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*testproto.Msg)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *testproto.Msg) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockTestServiceServer_Unary_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unary'
type MockTestServiceServer_Unary_Call struct {
	*mock.Call
}

// Unary is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *testproto.Msg
func (_e *MockTestServiceServer_Expecter) Unary(_a0 interface{}, _a1 interface{}) *MockTestServiceServer_Unary_Call {
	return &MockTestServiceServer_Unary_Call{Call: _e.mock.On("Unary", _a0, _a1)}
}

func (_c *MockTestServiceServer_Unary_Call) Run(run func(_a0 context.Context, _a1 *testproto.Msg)) *MockTestServiceServer_Unary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*testproto.Msg))
	})
	return _c
}

func (_c *MockTestServiceServer_Unary_Call) Return(_a0 *testproto.Msg, _a1 error) *MockTestServiceServer_Unary_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTestServiceServer_Unary_Call) RunAndReturn(run func(context.Context, *testproto.Msg) (*testproto.Msg, error)) *MockTestServiceServer_Unary_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockTestServiceServer creates a new instance of MockTestServiceServer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockTestServiceServer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTestServiceServer {
	mock := &MockTestServiceServer{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}