task_client_mock.go

// Code generated by mockery. DO NOT EDIT.

package sdkclients

import (
	apiutils "github.com/clumio-code/clumio-go-sdk/api_utils"
	mock "github.com/stretchr/testify/mock"

	models "github.com/clumio-code/clumio-go-sdk/models"
)

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

type MockTaskClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTaskClient) EXPECT() *MockTaskClient_Expecter {
	return &MockTaskClient_Expecter{mock: &_m.Mock}
}

// ListTasks provides a mock function with given fields: limit, start, filter
func (_m *MockTaskClient) ListTasks(limit *int64, start *string, filter *string) (*models.ListTasksResponse, *apiutils.APIError) {
	ret := _m.Called(limit, start, filter)

	if len(ret) == 0 {
		panic("no return value specified for ListTasks")
	}

	var r0 *models.ListTasksResponse
	var r1 *apiutils.APIError
	if rf, ok := ret.Get(0).(func(*int64, *string, *string) (*models.ListTasksResponse, *apiutils.APIError)); ok {
		return rf(limit, start, filter)
	}
	if rf, ok := ret.Get(0).(func(*int64, *string, *string) *models.ListTasksResponse); ok {
		r0 = rf(limit, start, filter)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*models.ListTasksResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(*int64, *string, *string) *apiutils.APIError); ok {
		r1 = rf(limit, start, filter)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*apiutils.APIError)
		}
	}

	return r0, r1
}

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

// ListTasks is a helper method to define mock.On call
//   - limit *int64
//   - start *string
//   - filter *string
func (_e *MockTaskClient_Expecter) ListTasks(limit interface{}, start interface{}, filter interface{}) *MockTaskClient_ListTasks_Call {
	return &MockTaskClient_ListTasks_Call{Call: _e.mock.On("ListTasks", limit, start, filter)}
}

func (_c *MockTaskClient_ListTasks_Call) Run(run func(limit *int64, start *string, filter *string)) *MockTaskClient_ListTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*int64), args[1].(*string), args[2].(*string))
	})
	return _c
}

func (_c *MockTaskClient_ListTasks_Call) Return(_a0 *models.ListTasksResponse, _a1 *apiutils.APIError) *MockTaskClient_ListTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTaskClient_ListTasks_Call) RunAndReturn(run func(*int64, *string, *string) (*models.ListTasksResponse, *apiutils.APIError)) *MockTaskClient_ListTasks_Call {
	_c.Call.Return(run)
	return _c
}

// ReadTask provides a mock function with given fields: taskId
func (_m *MockTaskClient) ReadTask(taskId string) (*models.ReadTaskResponse, *apiutils.APIError) {
	ret := _m.Called(taskId)

	if len(ret) == 0 {
		panic("no return value specified for ReadTask")
	}

	var r0 *models.ReadTaskResponse
	var r1 *apiutils.APIError
	if rf, ok := ret.Get(0).(func(string) (*models.ReadTaskResponse, *apiutils.APIError)); ok {
		return rf(taskId)
	}
	if rf, ok := ret.Get(0).(func(string) *models.ReadTaskResponse); ok {
		r0 = rf(taskId)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*models.ReadTaskResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(string) *apiutils.APIError); ok {
		r1 = rf(taskId)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*apiutils.APIError)
		}
	}

	return r0, r1
}

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

// ReadTask is a helper method to define mock.On call
//   - taskId string
func (_e *MockTaskClient_Expecter) ReadTask(taskId interface{}) *MockTaskClient_ReadTask_Call {
	return &MockTaskClient_ReadTask_Call{Call: _e.mock.On("ReadTask", taskId)}
}

func (_c *MockTaskClient_ReadTask_Call) Run(run func(taskId string)) *MockTaskClient_ReadTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockTaskClient_ReadTask_Call) Return(_a0 *models.ReadTaskResponse, _a1 *apiutils.APIError) *MockTaskClient_ReadTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTaskClient_ReadTask_Call) RunAndReturn(run func(string) (*models.ReadTaskResponse, *apiutils.APIError)) *MockTaskClient_ReadTask_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateTask provides a mock function with given fields: taskId, body
func (_m *MockTaskClient) UpdateTask(taskId string, body *models.UpdateTaskV1Request) (*models.UpdateTaskResponse, *apiutils.APIError) {
	ret := _m.Called(taskId, body)

	if len(ret) == 0 {
		panic("no return value specified for UpdateTask")
	}

	var r0 *models.UpdateTaskResponse
	var r1 *apiutils.APIError
	if rf, ok := ret.Get(0).(func(string, *models.UpdateTaskV1Request) (*models.UpdateTaskResponse, *apiutils.APIError)); ok {
		return rf(taskId, body)
	}
	if rf, ok := ret.Get(0).(func(string, *models.UpdateTaskV1Request) *models.UpdateTaskResponse); ok {
		r0 = rf(taskId, body)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*models.UpdateTaskResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(string, *models.UpdateTaskV1Request) *apiutils.APIError); ok {
		r1 = rf(taskId, body)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*apiutils.APIError)
		}
	}

	return r0, r1
}

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

// UpdateTask is a helper method to define mock.On call
//   - taskId string
//   - body *models.UpdateTaskV1Request
func (_e *MockTaskClient_Expecter) UpdateTask(taskId interface{}, body interface{}) *MockTaskClient_UpdateTask_Call {
	return &MockTaskClient_UpdateTask_Call{Call: _e.mock.On("UpdateTask", taskId, body)}
}

func (_c *MockTaskClient_UpdateTask_Call) Run(run func(taskId string, body *models.UpdateTaskV1Request)) *MockTaskClient_UpdateTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(*models.UpdateTaskV1Request))
	})
	return _c
}

func (_c *MockTaskClient_UpdateTask_Call) Return(_a0 *models.UpdateTaskResponse, _a1 *apiutils.APIError) *MockTaskClient_UpdateTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockTaskClient_UpdateTask_Call) RunAndReturn(run func(string, *models.UpdateTaskV1Request) (*models.UpdateTaskResponse, *apiutils.APIError)) *MockTaskClient_UpdateTask_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockTaskClient creates a new instance of MockTaskClient. 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 NewMockTaskClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTaskClient {
	mock := &MockTaskClient{}
	mock.Mock.Test(t)

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

	return mock
}