AsyncAgentService_GetTaskClient.go

// Code generated by mockery v1.0.1. DO NOT EDIT.

package mocks

import (
	context "context"

	admin "github.com/flyteorg/flyte/flyteidl/gen/pb-go/flyteidl/admin"

	metadata "google.golang.org/grpc/metadata"

	mock "github.com/stretchr/testify/mock"
)

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

type AsyncAgentService_GetTaskClient_CloseSend struct {
	*mock.Call
}

func (_m AsyncAgentService_GetTaskClient_CloseSend) Return(_a0 error) *AsyncAgentService_GetTaskClient_CloseSend {
	return &AsyncAgentService_GetTaskClient_CloseSend{Call: _m.Call.Return(_a0)}
}

func (_m *AsyncAgentService_GetTaskClient) OnCloseSend() *AsyncAgentService_GetTaskClient_CloseSend {
	c_call := _m.On("CloseSend")
	return &AsyncAgentService_GetTaskClient_CloseSend{Call: c_call}
}

func (_m *AsyncAgentService_GetTaskClient) OnCloseSendMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_CloseSend {
	c_call := _m.On("CloseSend", matchers...)
	return &AsyncAgentService_GetTaskClient_CloseSend{Call: c_call}
}

// CloseSend provides a mock function with given fields:
func (_m *AsyncAgentService_GetTaskClient) CloseSend() error {
	ret := _m.Called()

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

	return r0
}

type AsyncAgentService_GetTaskClient_Context struct {
	*mock.Call
}

func (_m AsyncAgentService_GetTaskClient_Context) Return(_a0 context.Context) *AsyncAgentService_GetTaskClient_Context {
	return &AsyncAgentService_GetTaskClient_Context{Call: _m.Call.Return(_a0)}
}

func (_m *AsyncAgentService_GetTaskClient) OnContext() *AsyncAgentService_GetTaskClient_Context {
	c_call := _m.On("Context")
	return &AsyncAgentService_GetTaskClient_Context{Call: c_call}
}

func (_m *AsyncAgentService_GetTaskClient) OnContextMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_Context {
	c_call := _m.On("Context", matchers...)
	return &AsyncAgentService_GetTaskClient_Context{Call: c_call}
}

// Context provides a mock function with given fields:
func (_m *AsyncAgentService_GetTaskClient) Context() context.Context {
	ret := _m.Called()

	var r0 context.Context
	if rf, ok := ret.Get(0).(func() context.Context); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(context.Context)
		}
	}

	return r0
}

type AsyncAgentService_GetTaskClient_Header struct {
	*mock.Call
}

func (_m AsyncAgentService_GetTaskClient_Header) Return(_a0 metadata.MD, _a1 error) *AsyncAgentService_GetTaskClient_Header {
	return &AsyncAgentService_GetTaskClient_Header{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AsyncAgentService_GetTaskClient) OnHeader() *AsyncAgentService_GetTaskClient_Header {
	c_call := _m.On("Header")
	return &AsyncAgentService_GetTaskClient_Header{Call: c_call}
}

func (_m *AsyncAgentService_GetTaskClient) OnHeaderMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_Header {
	c_call := _m.On("Header", matchers...)
	return &AsyncAgentService_GetTaskClient_Header{Call: c_call}
}

// Header provides a mock function with given fields:
func (_m *AsyncAgentService_GetTaskClient) Header() (metadata.MD, error) {
	ret := _m.Called()

	var r0 metadata.MD
	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(metadata.MD)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AsyncAgentService_GetTaskClient_Recv struct {
	*mock.Call
}

func (_m AsyncAgentService_GetTaskClient_Recv) Return(_a0 *admin.GetTaskResponse, _a1 error) *AsyncAgentService_GetTaskClient_Recv {
	return &AsyncAgentService_GetTaskClient_Recv{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AsyncAgentService_GetTaskClient) OnRecv() *AsyncAgentService_GetTaskClient_Recv {
	c_call := _m.On("Recv")
	return &AsyncAgentService_GetTaskClient_Recv{Call: c_call}
}

func (_m *AsyncAgentService_GetTaskClient) OnRecvMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_Recv {
	c_call := _m.On("Recv", matchers...)
	return &AsyncAgentService_GetTaskClient_Recv{Call: c_call}
}

// Recv provides a mock function with given fields:
func (_m *AsyncAgentService_GetTaskClient) Recv() (*admin.GetTaskResponse, error) {
	ret := _m.Called()

	var r0 *admin.GetTaskResponse
	if rf, ok := ret.Get(0).(func() *admin.GetTaskResponse); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.GetTaskResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AsyncAgentService_GetTaskClient_RecvMsg struct {
	*mock.Call
}

func (_m AsyncAgentService_GetTaskClient_RecvMsg) Return(_a0 error) *AsyncAgentService_GetTaskClient_RecvMsg {
	return &AsyncAgentService_GetTaskClient_RecvMsg{Call: _m.Call.Return(_a0)}
}

func (_m *AsyncAgentService_GetTaskClient) OnRecvMsg(m interface{}) *AsyncAgentService_GetTaskClient_RecvMsg {
	c_call := _m.On("RecvMsg", m)
	return &AsyncAgentService_GetTaskClient_RecvMsg{Call: c_call}
}

func (_m *AsyncAgentService_GetTaskClient) OnRecvMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_RecvMsg {
	c_call := _m.On("RecvMsg", matchers...)
	return &AsyncAgentService_GetTaskClient_RecvMsg{Call: c_call}
}

// RecvMsg provides a mock function with given fields: m
func (_m *AsyncAgentService_GetTaskClient) RecvMsg(m interface{}) error {
	ret := _m.Called(m)

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

	return r0
}

type AsyncAgentService_GetTaskClient_SendMsg struct {
	*mock.Call
}

func (_m AsyncAgentService_GetTaskClient_SendMsg) Return(_a0 error) *AsyncAgentService_GetTaskClient_SendMsg {
	return &AsyncAgentService_GetTaskClient_SendMsg{Call: _m.Call.Return(_a0)}
}

func (_m *AsyncAgentService_GetTaskClient) OnSendMsg(m interface{}) *AsyncAgentService_GetTaskClient_SendMsg {
	c_call := _m.On("SendMsg", m)
	return &AsyncAgentService_GetTaskClient_SendMsg{Call: c_call}
}

func (_m *AsyncAgentService_GetTaskClient) OnSendMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_SendMsg {
	c_call := _m.On("SendMsg", matchers...)
	return &AsyncAgentService_GetTaskClient_SendMsg{Call: c_call}
}

// SendMsg provides a mock function with given fields: m
func (_m *AsyncAgentService_GetTaskClient) SendMsg(m interface{}) error {
	ret := _m.Called(m)

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

	return r0
}

type AsyncAgentService_GetTaskClient_Trailer struct {
	*mock.Call
}

func (_m AsyncAgentService_GetTaskClient_Trailer) Return(_a0 metadata.MD) *AsyncAgentService_GetTaskClient_Trailer {
	return &AsyncAgentService_GetTaskClient_Trailer{Call: _m.Call.Return(_a0)}
}

func (_m *AsyncAgentService_GetTaskClient) OnTrailer() *AsyncAgentService_GetTaskClient_Trailer {
	c_call := _m.On("Trailer")
	return &AsyncAgentService_GetTaskClient_Trailer{Call: c_call}
}

func (_m *AsyncAgentService_GetTaskClient) OnTrailerMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_Trailer {
	c_call := _m.On("Trailer", matchers...)
	return &AsyncAgentService_GetTaskClient_Trailer{Call: c_call}
}

// Trailer provides a mock function with given fields:
func (_m *AsyncAgentService_GetTaskClient) Trailer() metadata.MD {
	ret := _m.Called()

	var r0 metadata.MD
	if rf, ok := ret.Get(0).(func() metadata.MD); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(metadata.MD)
		}
	}

	return r0
}