// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package service

import (
	"context"
	"time"

	"github.com/CMSgov/bcda-app/bcda/constants"
	"github.com/CMSgov/bcda-app/bcda/models"
	"github.com/CMSgov/bcda-app/bcdaworker/queueing/worker_types"
	"github.com/pborman/uuid"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

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

type MockService_Expecter struct {
	mock *mock.Mock
}

func (_m *MockService) EXPECT() *MockService_Expecter {
	return &MockService_Expecter{mock: &_m.Mock}
}

// CancelJob provides a mock function for the type MockService
func (_mock *MockService) CancelJob(ctx context.Context, jobID uint) (uint, error) {
	ret := _mock.Called(ctx, jobID)

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

	var r0 uint
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint) (uint, error)); ok {
		return returnFunc(ctx, jobID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint) uint); ok {
		r0 = returnFunc(ctx, jobID)
	} else {
		r0 = ret.Get(0).(uint)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint) error); ok {
		r1 = returnFunc(ctx, jobID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// CancelJob is a helper method to define mock.On call
//   - ctx context.Context
//   - jobID uint
func (_e *MockService_Expecter) CancelJob(ctx interface{}, jobID interface{}) *MockService_CancelJob_Call {
	return &MockService_CancelJob_Call{Call: _e.mock.On("CancelJob", ctx, jobID)}
}

func (_c *MockService_CancelJob_Call) Run(run func(ctx context.Context, jobID uint)) *MockService_CancelJob_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint
		if args[1] != nil {
			arg1 = args[1].(uint)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockService_CancelJob_Call) Return(v uint, err error) *MockService_CancelJob_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *MockService_CancelJob_Call) RunAndReturn(run func(ctx context.Context, jobID uint) (uint, error)) *MockService_CancelJob_Call {
	_c.Call.Return(run)
	return _c
}

// FindOldCCLFFile provides a mock function for the type MockService
func (_mock *MockService) FindOldCCLFFile(ctx context.Context, cmsID string, since time.Time, cclfTimestamp time.Time) (uint, error) {
	ret := _mock.Called(ctx, cmsID, since, cclfTimestamp)

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

	var r0 uint
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, time.Time) (uint, error)); ok {
		return returnFunc(ctx, cmsID, since, cclfTimestamp)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, time.Time) uint); ok {
		r0 = returnFunc(ctx, cmsID, since, cclfTimestamp)
	} else {
		r0 = ret.Get(0).(uint)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, time.Time, time.Time) error); ok {
		r1 = returnFunc(ctx, cmsID, since, cclfTimestamp)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// FindOldCCLFFile is a helper method to define mock.On call
//   - ctx context.Context
//   - cmsID string
//   - since time.Time
//   - cclfTimestamp time.Time
func (_e *MockService_Expecter) FindOldCCLFFile(ctx interface{}, cmsID interface{}, since interface{}, cclfTimestamp interface{}) *MockService_FindOldCCLFFile_Call {
	return &MockService_FindOldCCLFFile_Call{Call: _e.mock.On("FindOldCCLFFile", ctx, cmsID, since, cclfTimestamp)}
}

func (_c *MockService_FindOldCCLFFile_Call) Run(run func(ctx context.Context, cmsID string, since time.Time, cclfTimestamp time.Time)) *MockService_FindOldCCLFFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		var arg3 time.Time
		if args[3] != nil {
			arg3 = args[3].(time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockService_FindOldCCLFFile_Call) Return(v uint, err error) *MockService_FindOldCCLFFile_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *MockService_FindOldCCLFFile_Call) RunAndReturn(run func(ctx context.Context, cmsID string, since time.Time, cclfTimestamp time.Time) (uint, error)) *MockService_FindOldCCLFFile_Call {
	_c.Call.Return(run)
	return _c
}

// GetACOConfigForID provides a mock function for the type MockService
func (_mock *MockService) GetACOConfigForID(cmsID string) (*ACOConfig, bool) {
	ret := _mock.Called(cmsID)

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

	var r0 *ACOConfig
	var r1 bool
	if returnFunc, ok := ret.Get(0).(func(string) (*ACOConfig, bool)); ok {
		return returnFunc(cmsID)
	}
	if returnFunc, ok := ret.Get(0).(func(string) *ACOConfig); ok {
		r0 = returnFunc(cmsID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ACOConfig)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) bool); ok {
		r1 = returnFunc(cmsID)
	} else {
		r1 = ret.Get(1).(bool)
	}
	return r0, r1
}

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

// GetACOConfigForID is a helper method to define mock.On call
//   - cmsID string
func (_e *MockService_Expecter) GetACOConfigForID(cmsID interface{}) *MockService_GetACOConfigForID_Call {
	return &MockService_GetACOConfigForID_Call{Call: _e.mock.On("GetACOConfigForID", cmsID)}
}

func (_c *MockService_GetACOConfigForID_Call) Run(run func(cmsID string)) *MockService_GetACOConfigForID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockService_GetACOConfigForID_Call) Return(aCOConfig *ACOConfig, b bool) *MockService_GetACOConfigForID_Call {
	_c.Call.Return(aCOConfig, b)
	return _c
}

func (_c *MockService_GetACOConfigForID_Call) RunAndReturn(run func(cmsID string) (*ACOConfig, bool)) *MockService_GetACOConfigForID_Call {
	_c.Call.Return(run)
	return _c
}

// GetCutoffTime provides a mock function for the type MockService
func (_mock *MockService) GetCutoffTime(ctx context.Context, reqType constants.DataRequestType, since time.Time, timeConstraints TimeConstraints, fileType models.CCLFFileType) (time.Time, string) {
	ret := _mock.Called(ctx, reqType, since, timeConstraints, fileType)

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

	var r0 time.Time
	var r1 string
	if returnFunc, ok := ret.Get(0).(func(context.Context, constants.DataRequestType, time.Time, TimeConstraints, models.CCLFFileType) (time.Time, string)); ok {
		return returnFunc(ctx, reqType, since, timeConstraints, fileType)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, constants.DataRequestType, time.Time, TimeConstraints, models.CCLFFileType) time.Time); ok {
		r0 = returnFunc(ctx, reqType, since, timeConstraints, fileType)
	} else {
		r0 = ret.Get(0).(time.Time)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, constants.DataRequestType, time.Time, TimeConstraints, models.CCLFFileType) string); ok {
		r1 = returnFunc(ctx, reqType, since, timeConstraints, fileType)
	} else {
		r1 = ret.Get(1).(string)
	}
	return r0, r1
}

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

// GetCutoffTime is a helper method to define mock.On call
//   - ctx context.Context
//   - reqType constants.DataRequestType
//   - since time.Time
//   - timeConstraints TimeConstraints
//   - fileType models.CCLFFileType
func (_e *MockService_Expecter) GetCutoffTime(ctx interface{}, reqType interface{}, since interface{}, timeConstraints interface{}, fileType interface{}) *MockService_GetCutoffTime_Call {
	return &MockService_GetCutoffTime_Call{Call: _e.mock.On("GetCutoffTime", ctx, reqType, since, timeConstraints, fileType)}
}

func (_c *MockService_GetCutoffTime_Call) Run(run func(ctx context.Context, reqType constants.DataRequestType, since time.Time, timeConstraints TimeConstraints, fileType models.CCLFFileType)) *MockService_GetCutoffTime_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 constants.DataRequestType
		if args[1] != nil {
			arg1 = args[1].(constants.DataRequestType)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		var arg3 TimeConstraints
		if args[3] != nil {
			arg3 = args[3].(TimeConstraints)
		}
		var arg4 models.CCLFFileType
		if args[4] != nil {
			arg4 = args[4].(models.CCLFFileType)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MockService_GetCutoffTime_Call) Return(time1 time.Time, s string) *MockService_GetCutoffTime_Call {
	_c.Call.Return(time1, s)
	return _c
}

func (_c *MockService_GetCutoffTime_Call) RunAndReturn(run func(ctx context.Context, reqType constants.DataRequestType, since time.Time, timeConstraints TimeConstraints, fileType models.CCLFFileType) (time.Time, string)) *MockService_GetCutoffTime_Call {
	_c.Call.Return(run)
	return _c
}

// GetJobAndKeys provides a mock function for the type MockService
func (_mock *MockService) GetJobAndKeys(ctx context.Context, jobID uint) (*models.Job, []*models.JobKey, error) {
	ret := _mock.Called(ctx, jobID)

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

	var r0 *models.Job
	var r1 []*models.JobKey
	var r2 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint) (*models.Job, []*models.JobKey, error)); ok {
		return returnFunc(ctx, jobID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint) *models.Job); ok {
		r0 = returnFunc(ctx, jobID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*models.Job)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint) []*models.JobKey); ok {
		r1 = returnFunc(ctx, jobID)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).([]*models.JobKey)
		}
	}
	if returnFunc, ok := ret.Get(2).(func(context.Context, uint) error); ok {
		r2 = returnFunc(ctx, jobID)
	} else {
		r2 = ret.Error(2)
	}
	return r0, r1, r2
}

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

// GetJobAndKeys is a helper method to define mock.On call
//   - ctx context.Context
//   - jobID uint
func (_e *MockService_Expecter) GetJobAndKeys(ctx interface{}, jobID interface{}) *MockService_GetJobAndKeys_Call {
	return &MockService_GetJobAndKeys_Call{Call: _e.mock.On("GetJobAndKeys", ctx, jobID)}
}

func (_c *MockService_GetJobAndKeys_Call) Run(run func(ctx context.Context, jobID uint)) *MockService_GetJobAndKeys_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint
		if args[1] != nil {
			arg1 = args[1].(uint)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockService_GetJobAndKeys_Call) Return(job *models.Job, jobKeys []*models.JobKey, err error) *MockService_GetJobAndKeys_Call {
	_c.Call.Return(job, jobKeys, err)
	return _c
}

func (_c *MockService_GetJobAndKeys_Call) RunAndReturn(run func(ctx context.Context, jobID uint) (*models.Job, []*models.JobKey, error)) *MockService_GetJobAndKeys_Call {
	_c.Call.Return(run)
	return _c
}

// GetJobKey provides a mock function for the type MockService
func (_mock *MockService) GetJobKey(ctx context.Context, jobID uint, filename string) (*models.JobKey, error) {
	ret := _mock.Called(ctx, jobID, filename)

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

	var r0 *models.JobKey
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint, string) (*models.JobKey, error)); ok {
		return returnFunc(ctx, jobID, filename)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint, string) *models.JobKey); ok {
		r0 = returnFunc(ctx, jobID, filename)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*models.JobKey)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint, string) error); ok {
		r1 = returnFunc(ctx, jobID, filename)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetJobKey is a helper method to define mock.On call
//   - ctx context.Context
//   - jobID uint
//   - filename string
func (_e *MockService_Expecter) GetJobKey(ctx interface{}, jobID interface{}, filename interface{}) *MockService_GetJobKey_Call {
	return &MockService_GetJobKey_Call{Call: _e.mock.On("GetJobKey", ctx, jobID, filename)}
}

func (_c *MockService_GetJobKey_Call) Run(run func(ctx context.Context, jobID uint, filename string)) *MockService_GetJobKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint
		if args[1] != nil {
			arg1 = args[1].(uint)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockService_GetJobKey_Call) Return(jobKey *models.JobKey, err error) *MockService_GetJobKey_Call {
	_c.Call.Return(jobKey, err)
	return _c
}

func (_c *MockService_GetJobKey_Call) RunAndReturn(run func(ctx context.Context, jobID uint, filename string) (*models.JobKey, error)) *MockService_GetJobKey_Call {
	_c.Call.Return(run)
	return _c
}

// GetJobPriority provides a mock function for the type MockService
func (_mock *MockService) GetJobPriority(acoID string, resourceType string, sinceParam bool) int16 {
	ret := _mock.Called(acoID, resourceType, sinceParam)

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

	var r0 int16
	if returnFunc, ok := ret.Get(0).(func(string, string, bool) int16); ok {
		r0 = returnFunc(acoID, resourceType, sinceParam)
	} else {
		r0 = ret.Get(0).(int16)
	}
	return r0
}

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

// GetJobPriority is a helper method to define mock.On call
//   - acoID string
//   - resourceType string
//   - sinceParam bool
func (_e *MockService_Expecter) GetJobPriority(acoID interface{}, resourceType interface{}, sinceParam interface{}) *MockService_GetJobPriority_Call {
	return &MockService_GetJobPriority_Call{Call: _e.mock.On("GetJobPriority", acoID, resourceType, sinceParam)}
}

func (_c *MockService_GetJobPriority_Call) Run(run func(acoID string, resourceType string, sinceParam bool)) *MockService_GetJobPriority_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockService_GetJobPriority_Call) Return(n int16) *MockService_GetJobPriority_Call {
	_c.Call.Return(n)
	return _c
}

func (_c *MockService_GetJobPriority_Call) RunAndReturn(run func(acoID string, resourceType string, sinceParam bool) int16) *MockService_GetJobPriority_Call {
	_c.Call.Return(run)
	return _c
}

// GetJobs provides a mock function for the type MockService
func (_mock *MockService) GetJobs(ctx context.Context, acoID uuid.UUID, statuses ...models.JobStatus) ([]*models.Job, error) {
	var tmpRet mock.Arguments
	if len(statuses) > 0 {
		tmpRet = _mock.Called(ctx, acoID, statuses)
	} else {
		tmpRet = _mock.Called(ctx, acoID)
	}
	ret := tmpRet

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

	var r0 []*models.Job
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, ...models.JobStatus) ([]*models.Job, error)); ok {
		return returnFunc(ctx, acoID, statuses...)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uuid.UUID, ...models.JobStatus) []*models.Job); ok {
		r0 = returnFunc(ctx, acoID, statuses...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*models.Job)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uuid.UUID, ...models.JobStatus) error); ok {
		r1 = returnFunc(ctx, acoID, statuses...)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetJobs is a helper method to define mock.On call
//   - ctx context.Context
//   - acoID uuid.UUID
//   - statuses ...models.JobStatus
func (_e *MockService_Expecter) GetJobs(ctx interface{}, acoID interface{}, statuses ...interface{}) *MockService_GetJobs_Call {
	return &MockService_GetJobs_Call{Call: _e.mock.On("GetJobs",
		append([]interface{}{ctx, acoID}, statuses...)...)}
}

func (_c *MockService_GetJobs_Call) Run(run func(ctx context.Context, acoID uuid.UUID, statuses ...models.JobStatus)) *MockService_GetJobs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uuid.UUID
		if args[1] != nil {
			arg1 = args[1].(uuid.UUID)
		}
		var arg2 []models.JobStatus
		var variadicArgs []models.JobStatus
		if len(args) > 2 {
			variadicArgs = args[2].([]models.JobStatus)
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

func (_c *MockService_GetJobs_Call) Return(jobs []*models.Job, err error) *MockService_GetJobs_Call {
	_c.Call.Return(jobs, err)
	return _c
}

func (_c *MockService_GetJobs_Call) RunAndReturn(run func(ctx context.Context, acoID uuid.UUID, statuses ...models.JobStatus) ([]*models.Job, error)) *MockService_GetJobs_Call {
	_c.Call.Return(run)
	return _c
}

// GetLatestCCLFFile provides a mock function for the type MockService
func (_mock *MockService) GetLatestCCLFFile(ctx context.Context, cmsID string, lowerBound time.Time, upperBound time.Time, fileType models.CCLFFileType) (*models.CCLFFile, error) {
	ret := _mock.Called(ctx, cmsID, lowerBound, upperBound, fileType)

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

	var r0 *models.CCLFFile
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, time.Time, models.CCLFFileType) (*models.CCLFFile, error)); ok {
		return returnFunc(ctx, cmsID, lowerBound, upperBound, fileType)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time, time.Time, models.CCLFFileType) *models.CCLFFile); ok {
		r0 = returnFunc(ctx, cmsID, lowerBound, upperBound, fileType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*models.CCLFFile)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, time.Time, time.Time, models.CCLFFileType) error); ok {
		r1 = returnFunc(ctx, cmsID, lowerBound, upperBound, fileType)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetLatestCCLFFile is a helper method to define mock.On call
//   - ctx context.Context
//   - cmsID string
//   - lowerBound time.Time
//   - upperBound time.Time
//   - fileType models.CCLFFileType
func (_e *MockService_Expecter) GetLatestCCLFFile(ctx interface{}, cmsID interface{}, lowerBound interface{}, upperBound interface{}, fileType interface{}) *MockService_GetLatestCCLFFile_Call {
	return &MockService_GetLatestCCLFFile_Call{Call: _e.mock.On("GetLatestCCLFFile", ctx, cmsID, lowerBound, upperBound, fileType)}
}

func (_c *MockService_GetLatestCCLFFile_Call) Run(run func(ctx context.Context, cmsID string, lowerBound time.Time, upperBound time.Time, fileType models.CCLFFileType)) *MockService_GetLatestCCLFFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		var arg3 time.Time
		if args[3] != nil {
			arg3 = args[3].(time.Time)
		}
		var arg4 models.CCLFFileType
		if args[4] != nil {
			arg4 = args[4].(models.CCLFFileType)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *MockService_GetLatestCCLFFile_Call) Return(cCLFFile *models.CCLFFile, err error) *MockService_GetLatestCCLFFile_Call {
	_c.Call.Return(cCLFFile, err)
	return _c
}

func (_c *MockService_GetLatestCCLFFile_Call) RunAndReturn(run func(ctx context.Context, cmsID string, lowerBound time.Time, upperBound time.Time, fileType models.CCLFFileType) (*models.CCLFFile, error)) *MockService_GetLatestCCLFFile_Call {
	_c.Call.Return(run)
	return _c
}

// GetQueJobs provides a mock function for the type MockService
func (_mock *MockService) GetQueJobs(ctx context.Context, args worker_types.PrepareJobArgs) ([]*worker_types.JobEnqueueArgs, error) {
	ret := _mock.Called(ctx, args)

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

	var r0 []*worker_types.JobEnqueueArgs
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, worker_types.PrepareJobArgs) ([]*worker_types.JobEnqueueArgs, error)); ok {
		return returnFunc(ctx, args)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, worker_types.PrepareJobArgs) []*worker_types.JobEnqueueArgs); ok {
		r0 = returnFunc(ctx, args)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*worker_types.JobEnqueueArgs)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, worker_types.PrepareJobArgs) error); ok {
		r1 = returnFunc(ctx, args)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetQueJobs is a helper method to define mock.On call
//   - ctx context.Context
//   - args worker_types.PrepareJobArgs
func (_e *MockService_Expecter) GetQueJobs(ctx interface{}, args interface{}) *MockService_GetQueJobs_Call {
	return &MockService_GetQueJobs_Call{Call: _e.mock.On("GetQueJobs", ctx, args)}
}

func (_c *MockService_GetQueJobs_Call) Run(run func(ctx context.Context, args worker_types.PrepareJobArgs)) *MockService_GetQueJobs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 worker_types.PrepareJobArgs
		if args[1] != nil {
			arg1 = args[1].(worker_types.PrepareJobArgs)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockService_GetQueJobs_Call) Return(queJobs []*worker_types.JobEnqueueArgs, err error) *MockService_GetQueJobs_Call {
	_c.Call.Return(queJobs, err)
	return _c
}

func (_c *MockService_GetQueJobs_Call) RunAndReturn(run func(ctx context.Context, args worker_types.PrepareJobArgs) ([]*worker_types.JobEnqueueArgs, error)) *MockService_GetQueJobs_Call {
	_c.Call.Return(run)
	return _c
}

// GetTimeConstraints provides a mock function for the type MockService
func (_mock *MockService) GetTimeConstraints(ctx context.Context, cmsID string) (TimeConstraints, error) {
	ret := _mock.Called(ctx, cmsID)

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

	var r0 TimeConstraints
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (TimeConstraints, error)); ok {
		return returnFunc(ctx, cmsID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) TimeConstraints); ok {
		r0 = returnFunc(ctx, cmsID)
	} else {
		r0 = ret.Get(0).(TimeConstraints)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, cmsID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetTimeConstraints is a helper method to define mock.On call
//   - ctx context.Context
//   - cmsID string
func (_e *MockService_Expecter) GetTimeConstraints(ctx interface{}, cmsID interface{}) *MockService_GetTimeConstraints_Call {
	return &MockService_GetTimeConstraints_Call{Call: _e.mock.On("GetTimeConstraints", ctx, cmsID)}
}

func (_c *MockService_GetTimeConstraints_Call) Run(run func(ctx context.Context, cmsID string)) *MockService_GetTimeConstraints_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockService_GetTimeConstraints_Call) Return(timeConstraints TimeConstraints, err error) *MockService_GetTimeConstraints_Call {
	_c.Call.Return(timeConstraints, err)
	return _c
}

func (_c *MockService_GetTimeConstraints_Call) RunAndReturn(run func(ctx context.Context, cmsID string) (TimeConstraints, error)) *MockService_GetTimeConstraints_Call {
	_c.Call.Return(run)
	return _c
}
