TaskRepository.go

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

package mocks

import (
	context "context"

	entity "github.com/azisuazusa/todo-cli/internal/domain/entity"
	mock "github.com/stretchr/testify/mock"
)

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

type TaskRepository_Expecter struct {
	mock *mock.Mock
}

func (_m *TaskRepository) EXPECT() *TaskRepository_Expecter {
	return &TaskRepository_Expecter{mock: &_m.Mock}
}

// Delete provides a mock function with given fields: ctx, id
func (_m *TaskRepository) Delete(ctx context.Context, id string) error {
	ret := _m.Called(ctx, id)

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

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

	return r0
}

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

// Delete is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *TaskRepository_Expecter) Delete(ctx interface{}, id interface{}) *TaskRepository_Delete_Call {
	return &TaskRepository_Delete_Call{Call: _e.mock.On("Delete", ctx, id)}
}

func (_c *TaskRepository_Delete_Call) Run(run func(ctx context.Context, id string)) *TaskRepository_Delete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

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

func (_c *TaskRepository_Delete_Call) RunAndReturn(run func(context.Context, string) error) *TaskRepository_Delete_Call {
	_c.Call.Return(run)
	return _c
}

// GetByID provides a mock function with given fields: ctx, id
func (_m *TaskRepository) GetByID(ctx context.Context, id string) (entity.Task, error) {
	ret := _m.Called(ctx, id)

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

	var r0 entity.Task
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (entity.Task, error)); ok {
		return rf(ctx, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) entity.Task); ok {
		r0 = rf(ctx, id)
	} else {
		r0 = ret.Get(0).(entity.Task)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetByID is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *TaskRepository_Expecter) GetByID(ctx interface{}, id interface{}) *TaskRepository_GetByID_Call {
	return &TaskRepository_GetByID_Call{Call: _e.mock.On("GetByID", ctx, id)}
}

func (_c *TaskRepository_GetByID_Call) Run(run func(ctx context.Context, id string)) *TaskRepository_GetByID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *TaskRepository_GetByID_Call) Return(_a0 entity.Task, _a1 error) *TaskRepository_GetByID_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TaskRepository_GetByID_Call) RunAndReturn(run func(context.Context, string) (entity.Task, error)) *TaskRepository_GetByID_Call {
	_c.Call.Return(run)
	return _c
}

// GetStartedTask provides a mock function with given fields: ctx
func (_m *TaskRepository) GetStartedTask(ctx context.Context) (entity.Task, error) {
	ret := _m.Called(ctx)

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

	var r0 entity.Task
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context) (entity.Task, error)); ok {
		return rf(ctx)
	}
	if rf, ok := ret.Get(0).(func(context.Context) entity.Task); ok {
		r0 = rf(ctx)
	} else {
		r0 = ret.Get(0).(entity.Task)
	}

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

	return r0, r1
}

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

// GetStartedTask is a helper method to define mock.On call
//   - ctx context.Context
func (_e *TaskRepository_Expecter) GetStartedTask(ctx interface{}) *TaskRepository_GetStartedTask_Call {
	return &TaskRepository_GetStartedTask_Call{Call: _e.mock.On("GetStartedTask", ctx)}
}

func (_c *TaskRepository_GetStartedTask_Call) Run(run func(ctx context.Context)) *TaskRepository_GetStartedTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context))
	})
	return _c
}

func (_c *TaskRepository_GetStartedTask_Call) Return(_a0 entity.Task, _a1 error) *TaskRepository_GetStartedTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TaskRepository_GetStartedTask_Call) RunAndReturn(run func(context.Context) (entity.Task, error)) *TaskRepository_GetStartedTask_Call {
	_c.Call.Return(run)
	return _c
}

// GetUncompleteParentTasks provides a mock function with given fields: ctx, projectID
func (_m *TaskRepository) GetUncompleteParentTasks(ctx context.Context, projectID string) (entity.Tasks, error) {
	ret := _m.Called(ctx, projectID)

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

	var r0 entity.Tasks
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (entity.Tasks, error)); ok {
		return rf(ctx, projectID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) entity.Tasks); ok {
		r0 = rf(ctx, projectID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(entity.Tasks)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, projectID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUncompleteParentTasks is a helper method to define mock.On call
//   - ctx context.Context
//   - projectID string
func (_e *TaskRepository_Expecter) GetUncompleteParentTasks(ctx interface{}, projectID interface{}) *TaskRepository_GetUncompleteParentTasks_Call {
	return &TaskRepository_GetUncompleteParentTasks_Call{Call: _e.mock.On("GetUncompleteParentTasks", ctx, projectID)}
}

func (_c *TaskRepository_GetUncompleteParentTasks_Call) Run(run func(ctx context.Context, projectID string)) *TaskRepository_GetUncompleteParentTasks_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *TaskRepository_GetUncompleteParentTasks_Call) Return(_a0 entity.Tasks, _a1 error) *TaskRepository_GetUncompleteParentTasks_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TaskRepository_GetUncompleteParentTasks_Call) RunAndReturn(run func(context.Context, string) (entity.Tasks, error)) *TaskRepository_GetUncompleteParentTasks_Call {
	_c.Call.Return(run)
	return _c
}

// GetUncompleteSubTask provides a mock function with given fields: ctx, projectID
func (_m *TaskRepository) GetUncompleteSubTask(ctx context.Context, projectID string) (map[string]entity.Tasks, error) {
	ret := _m.Called(ctx, projectID)

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

	var r0 map[string]entity.Tasks
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string) (map[string]entity.Tasks, error)); ok {
		return rf(ctx, projectID)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string) map[string]entity.Tasks); ok {
		r0 = rf(ctx, projectID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]entity.Tasks)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, projectID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetUncompleteSubTask is a helper method to define mock.On call
//   - ctx context.Context
//   - projectID string
func (_e *TaskRepository_Expecter) GetUncompleteSubTask(ctx interface{}, projectID interface{}) *TaskRepository_GetUncompleteSubTask_Call {
	return &TaskRepository_GetUncompleteSubTask_Call{Call: _e.mock.On("GetUncompleteSubTask", ctx, projectID)}
}

func (_c *TaskRepository_GetUncompleteSubTask_Call) Run(run func(ctx context.Context, projectID string)) *TaskRepository_GetUncompleteSubTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *TaskRepository_GetUncompleteSubTask_Call) Return(_a0 map[string]entity.Tasks, _a1 error) *TaskRepository_GetUncompleteSubTask_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *TaskRepository_GetUncompleteSubTask_Call) RunAndReturn(run func(context.Context, string) (map[string]entity.Tasks, error)) *TaskRepository_GetUncompleteSubTask_Call {
	_c.Call.Return(run)
	return _c
}

// Insert provides a mock function with given fields: ctx, _a1
func (_m *TaskRepository) Insert(ctx context.Context, _a1 entity.Task) error {
	ret := _m.Called(ctx, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, entity.Task) error); ok {
		r0 = rf(ctx, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Insert is a helper method to define mock.On call
//   - ctx context.Context
//   - _a1 entity.Task
func (_e *TaskRepository_Expecter) Insert(ctx interface{}, _a1 interface{}) *TaskRepository_Insert_Call {
	return &TaskRepository_Insert_Call{Call: _e.mock.On("Insert", ctx, _a1)}
}

func (_c *TaskRepository_Insert_Call) Run(run func(ctx context.Context, _a1 entity.Task)) *TaskRepository_Insert_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(entity.Task))
	})
	return _c
}

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

func (_c *TaskRepository_Insert_Call) RunAndReturn(run func(context.Context, entity.Task) error) *TaskRepository_Insert_Call {
	_c.Call.Return(run)
	return _c
}

// SetStartedTask provides a mock function with given fields: ctx, _a1
func (_m *TaskRepository) SetStartedTask(ctx context.Context, _a1 entity.Task) error {
	ret := _m.Called(ctx, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, entity.Task) error); ok {
		r0 = rf(ctx, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// SetStartedTask is a helper method to define mock.On call
//   - ctx context.Context
//   - _a1 entity.Task
func (_e *TaskRepository_Expecter) SetStartedTask(ctx interface{}, _a1 interface{}) *TaskRepository_SetStartedTask_Call {
	return &TaskRepository_SetStartedTask_Call{Call: _e.mock.On("SetStartedTask", ctx, _a1)}
}

func (_c *TaskRepository_SetStartedTask_Call) Run(run func(ctx context.Context, _a1 entity.Task)) *TaskRepository_SetStartedTask_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(entity.Task))
	})
	return _c
}

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

func (_c *TaskRepository_SetStartedTask_Call) RunAndReturn(run func(context.Context, entity.Task) error) *TaskRepository_SetStartedTask_Call {
	_c.Call.Return(run)
	return _c
}

// Update provides a mock function with given fields: ctx, _a1
func (_m *TaskRepository) Update(ctx context.Context, _a1 entity.Task) error {
	ret := _m.Called(ctx, _a1)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, entity.Task) error); ok {
		r0 = rf(ctx, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Update is a helper method to define mock.On call
//   - ctx context.Context
//   - _a1 entity.Task
func (_e *TaskRepository_Expecter) Update(ctx interface{}, _a1 interface{}) *TaskRepository_Update_Call {
	return &TaskRepository_Update_Call{Call: _e.mock.On("Update", ctx, _a1)}
}

func (_c *TaskRepository_Update_Call) Run(run func(ctx context.Context, _a1 entity.Task)) *TaskRepository_Update_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(entity.Task))
	})
	return _c
}

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

func (_c *TaskRepository_Update_Call) RunAndReturn(run func(context.Context, entity.Task) error) *TaskRepository_Update_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}