mirror of
https://codeberg.org/crowci/crow.git
synced 2025-06-12 22:02:01 +03:00
719 lines
22 KiB
Go
719 lines
22 KiB
Go
// Code generated by mockery v2.53.0. DO NOT EDIT.
|
|
|
|
package proto
|
|
|
|
import (
|
|
context "context"
|
|
|
|
proto "codeberg.org/crowci/crow/v3/pipeline/rpc/proto"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// MockCrowServer is an autogenerated mock type for the CrowServer type
|
|
type MockCrowServer struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockCrowServer_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockCrowServer) EXPECT() *MockCrowServer_Expecter {
|
|
return &MockCrowServer_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// Done provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) Done(_a0 context.Context, _a1 *proto.DoneRequest) (*proto.Empty, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Done")
|
|
}
|
|
|
|
var r0 *proto.Empty
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.DoneRequest) (*proto.Empty, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.DoneRequest) *proto.Empty); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.Empty)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.DoneRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_Done_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Done'
|
|
type MockCrowServer_Done_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Done is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.DoneRequest
|
|
func (_e *MockCrowServer_Expecter) Done(_a0 interface{}, _a1 interface{}) *MockCrowServer_Done_Call {
|
|
return &MockCrowServer_Done_Call{Call: _e.mock.On("Done", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_Done_Call) Run(run func(_a0 context.Context, _a1 *proto.DoneRequest)) *MockCrowServer_Done_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.DoneRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Done_Call) Return(_a0 *proto.Empty, _a1 error) *MockCrowServer_Done_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Done_Call) RunAndReturn(run func(context.Context, *proto.DoneRequest) (*proto.Empty, error)) *MockCrowServer_Done_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Extend provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) Extend(_a0 context.Context, _a1 *proto.ExtendRequest) (*proto.Empty, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Extend")
|
|
}
|
|
|
|
var r0 *proto.Empty
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.ExtendRequest) (*proto.Empty, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.ExtendRequest) *proto.Empty); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.Empty)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.ExtendRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_Extend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Extend'
|
|
type MockCrowServer_Extend_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Extend is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.ExtendRequest
|
|
func (_e *MockCrowServer_Expecter) Extend(_a0 interface{}, _a1 interface{}) *MockCrowServer_Extend_Call {
|
|
return &MockCrowServer_Extend_Call{Call: _e.mock.On("Extend", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_Extend_Call) Run(run func(_a0 context.Context, _a1 *proto.ExtendRequest)) *MockCrowServer_Extend_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.ExtendRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Extend_Call) Return(_a0 *proto.Empty, _a1 error) *MockCrowServer_Extend_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Extend_Call) RunAndReturn(run func(context.Context, *proto.ExtendRequest) (*proto.Empty, error)) *MockCrowServer_Extend_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Init provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) Init(_a0 context.Context, _a1 *proto.InitRequest) (*proto.Empty, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Init")
|
|
}
|
|
|
|
var r0 *proto.Empty
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.InitRequest) (*proto.Empty, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.InitRequest) *proto.Empty); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.Empty)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.InitRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init'
|
|
type MockCrowServer_Init_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Init is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.InitRequest
|
|
func (_e *MockCrowServer_Expecter) Init(_a0 interface{}, _a1 interface{}) *MockCrowServer_Init_Call {
|
|
return &MockCrowServer_Init_Call{Call: _e.mock.On("Init", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_Init_Call) Run(run func(_a0 context.Context, _a1 *proto.InitRequest)) *MockCrowServer_Init_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.InitRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Init_Call) Return(_a0 *proto.Empty, _a1 error) *MockCrowServer_Init_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Init_Call) RunAndReturn(run func(context.Context, *proto.InitRequest) (*proto.Empty, error)) *MockCrowServer_Init_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Log provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) Log(_a0 context.Context, _a1 *proto.LogRequest) (*proto.Empty, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Log")
|
|
}
|
|
|
|
var r0 *proto.Empty
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.LogRequest) (*proto.Empty, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.LogRequest) *proto.Empty); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.Empty)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.LogRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_Log_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Log'
|
|
type MockCrowServer_Log_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Log is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.LogRequest
|
|
func (_e *MockCrowServer_Expecter) Log(_a0 interface{}, _a1 interface{}) *MockCrowServer_Log_Call {
|
|
return &MockCrowServer_Log_Call{Call: _e.mock.On("Log", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_Log_Call) Run(run func(_a0 context.Context, _a1 *proto.LogRequest)) *MockCrowServer_Log_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.LogRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Log_Call) Return(_a0 *proto.Empty, _a1 error) *MockCrowServer_Log_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Log_Call) RunAndReturn(run func(context.Context, *proto.LogRequest) (*proto.Empty, error)) *MockCrowServer_Log_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Next provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) Next(_a0 context.Context, _a1 *proto.NextRequest) (*proto.NextResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Next")
|
|
}
|
|
|
|
var r0 *proto.NextResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.NextRequest) (*proto.NextResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.NextRequest) *proto.NextResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.NextResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.NextRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_Next_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Next'
|
|
type MockCrowServer_Next_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Next is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.NextRequest
|
|
func (_e *MockCrowServer_Expecter) Next(_a0 interface{}, _a1 interface{}) *MockCrowServer_Next_Call {
|
|
return &MockCrowServer_Next_Call{Call: _e.mock.On("Next", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_Next_Call) Run(run func(_a0 context.Context, _a1 *proto.NextRequest)) *MockCrowServer_Next_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.NextRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Next_Call) Return(_a0 *proto.NextResponse, _a1 error) *MockCrowServer_Next_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Next_Call) RunAndReturn(run func(context.Context, *proto.NextRequest) (*proto.NextResponse, error)) *MockCrowServer_Next_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RegisterAgent provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) RegisterAgent(_a0 context.Context, _a1 *proto.RegisterAgentRequest) (*proto.RegisterAgentResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RegisterAgent")
|
|
}
|
|
|
|
var r0 *proto.RegisterAgentResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.RegisterAgentRequest) (*proto.RegisterAgentResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.RegisterAgentRequest) *proto.RegisterAgentResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.RegisterAgentResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.RegisterAgentRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_RegisterAgent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterAgent'
|
|
type MockCrowServer_RegisterAgent_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RegisterAgent is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.RegisterAgentRequest
|
|
func (_e *MockCrowServer_Expecter) RegisterAgent(_a0 interface{}, _a1 interface{}) *MockCrowServer_RegisterAgent_Call {
|
|
return &MockCrowServer_RegisterAgent_Call{Call: _e.mock.On("RegisterAgent", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_RegisterAgent_Call) Run(run func(_a0 context.Context, _a1 *proto.RegisterAgentRequest)) *MockCrowServer_RegisterAgent_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.RegisterAgentRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_RegisterAgent_Call) Return(_a0 *proto.RegisterAgentResponse, _a1 error) *MockCrowServer_RegisterAgent_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_RegisterAgent_Call) RunAndReturn(run func(context.Context, *proto.RegisterAgentRequest) (*proto.RegisterAgentResponse, error)) *MockCrowServer_RegisterAgent_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ReportHealth provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) ReportHealth(_a0 context.Context, _a1 *proto.ReportHealthRequest) (*proto.Empty, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ReportHealth")
|
|
}
|
|
|
|
var r0 *proto.Empty
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.ReportHealthRequest) (*proto.Empty, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.ReportHealthRequest) *proto.Empty); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.Empty)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.ReportHealthRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_ReportHealth_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReportHealth'
|
|
type MockCrowServer_ReportHealth_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ReportHealth is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.ReportHealthRequest
|
|
func (_e *MockCrowServer_Expecter) ReportHealth(_a0 interface{}, _a1 interface{}) *MockCrowServer_ReportHealth_Call {
|
|
return &MockCrowServer_ReportHealth_Call{Call: _e.mock.On("ReportHealth", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_ReportHealth_Call) Run(run func(_a0 context.Context, _a1 *proto.ReportHealthRequest)) *MockCrowServer_ReportHealth_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.ReportHealthRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_ReportHealth_Call) Return(_a0 *proto.Empty, _a1 error) *MockCrowServer_ReportHealth_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_ReportHealth_Call) RunAndReturn(run func(context.Context, *proto.ReportHealthRequest) (*proto.Empty, error)) *MockCrowServer_ReportHealth_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UnregisterAgent provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) UnregisterAgent(_a0 context.Context, _a1 *proto.Empty) (*proto.Empty, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UnregisterAgent")
|
|
}
|
|
|
|
var r0 *proto.Empty
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.Empty) (*proto.Empty, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.Empty) *proto.Empty); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.Empty)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.Empty) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_UnregisterAgent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnregisterAgent'
|
|
type MockCrowServer_UnregisterAgent_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UnregisterAgent is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.Empty
|
|
func (_e *MockCrowServer_Expecter) UnregisterAgent(_a0 interface{}, _a1 interface{}) *MockCrowServer_UnregisterAgent_Call {
|
|
return &MockCrowServer_UnregisterAgent_Call{Call: _e.mock.On("UnregisterAgent", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_UnregisterAgent_Call) Run(run func(_a0 context.Context, _a1 *proto.Empty)) *MockCrowServer_UnregisterAgent_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.Empty))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_UnregisterAgent_Call) Return(_a0 *proto.Empty, _a1 error) *MockCrowServer_UnregisterAgent_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_UnregisterAgent_Call) RunAndReturn(run func(context.Context, *proto.Empty) (*proto.Empty, error)) *MockCrowServer_UnregisterAgent_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Update provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) Update(_a0 context.Context, _a1 *proto.UpdateRequest) (*proto.Empty, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Update")
|
|
}
|
|
|
|
var r0 *proto.Empty
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.UpdateRequest) (*proto.Empty, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.UpdateRequest) *proto.Empty); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.Empty)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.UpdateRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
|
|
type MockCrowServer_Update_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Update is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.UpdateRequest
|
|
func (_e *MockCrowServer_Expecter) Update(_a0 interface{}, _a1 interface{}) *MockCrowServer_Update_Call {
|
|
return &MockCrowServer_Update_Call{Call: _e.mock.On("Update", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_Update_Call) Run(run func(_a0 context.Context, _a1 *proto.UpdateRequest)) *MockCrowServer_Update_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.UpdateRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Update_Call) Return(_a0 *proto.Empty, _a1 error) *MockCrowServer_Update_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Update_Call) RunAndReturn(run func(context.Context, *proto.UpdateRequest) (*proto.Empty, error)) *MockCrowServer_Update_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Version provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) Version(_a0 context.Context, _a1 *proto.Empty) (*proto.VersionResponse, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Version")
|
|
}
|
|
|
|
var r0 *proto.VersionResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.Empty) (*proto.VersionResponse, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.Empty) *proto.VersionResponse); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.VersionResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.Empty) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_Version_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Version'
|
|
type MockCrowServer_Version_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Version is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.Empty
|
|
func (_e *MockCrowServer_Expecter) Version(_a0 interface{}, _a1 interface{}) *MockCrowServer_Version_Call {
|
|
return &MockCrowServer_Version_Call{Call: _e.mock.On("Version", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_Version_Call) Run(run func(_a0 context.Context, _a1 *proto.Empty)) *MockCrowServer_Version_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.Empty))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Version_Call) Return(_a0 *proto.VersionResponse, _a1 error) *MockCrowServer_Version_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Version_Call) RunAndReturn(run func(context.Context, *proto.Empty) (*proto.VersionResponse, error)) *MockCrowServer_Version_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Wait provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockCrowServer) Wait(_a0 context.Context, _a1 *proto.WaitRequest) (*proto.Empty, error) {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Wait")
|
|
}
|
|
|
|
var r0 *proto.Empty
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.WaitRequest) (*proto.Empty, error)); ok {
|
|
return rf(_a0, _a1)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *proto.WaitRequest) *proto.Empty); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*proto.Empty)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *proto.WaitRequest) error); ok {
|
|
r1 = rf(_a0, _a1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockCrowServer_Wait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Wait'
|
|
type MockCrowServer_Wait_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Wait is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 *proto.WaitRequest
|
|
func (_e *MockCrowServer_Expecter) Wait(_a0 interface{}, _a1 interface{}) *MockCrowServer_Wait_Call {
|
|
return &MockCrowServer_Wait_Call{Call: _e.mock.On("Wait", _a0, _a1)}
|
|
}
|
|
|
|
func (_c *MockCrowServer_Wait_Call) Run(run func(_a0 context.Context, _a1 *proto.WaitRequest)) *MockCrowServer_Wait_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*proto.WaitRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Wait_Call) Return(_a0 *proto.Empty, _a1 error) *MockCrowServer_Wait_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_Wait_Call) RunAndReturn(run func(context.Context, *proto.WaitRequest) (*proto.Empty, error)) *MockCrowServer_Wait_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// mustEmbedUnimplementedCrowServer provides a mock function with no fields
|
|
func (_m *MockCrowServer) mustEmbedUnimplementedCrowServer() {
|
|
_m.Called()
|
|
}
|
|
|
|
// MockCrowServer_mustEmbedUnimplementedCrowServer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'mustEmbedUnimplementedCrowServer'
|
|
type MockCrowServer_mustEmbedUnimplementedCrowServer_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// mustEmbedUnimplementedCrowServer is a helper method to define mock.On call
|
|
func (_e *MockCrowServer_Expecter) mustEmbedUnimplementedCrowServer() *MockCrowServer_mustEmbedUnimplementedCrowServer_Call {
|
|
return &MockCrowServer_mustEmbedUnimplementedCrowServer_Call{Call: _e.mock.On("mustEmbedUnimplementedCrowServer")}
|
|
}
|
|
|
|
func (_c *MockCrowServer_mustEmbedUnimplementedCrowServer_Call) Run(run func()) *MockCrowServer_mustEmbedUnimplementedCrowServer_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_mustEmbedUnimplementedCrowServer_Call) Return() *MockCrowServer_mustEmbedUnimplementedCrowServer_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockCrowServer_mustEmbedUnimplementedCrowServer_Call) RunAndReturn(run func()) *MockCrowServer_mustEmbedUnimplementedCrowServer_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockCrowServer creates a new instance of MockCrowServer. 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 NewMockCrowServer(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockCrowServer {
|
|
mock := &MockCrowServer{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|