791d877ff1
Implement the `deleteJob` API endpoint. Calling this endpoint will mark the job as "deletion requested", after which it's queued for actual deletion. This makes the API response fast, even when there is a lot of work to do in the background. A new background service "job deleter" keeps track of the queue of such jobs, and performs the actual deletion. It removes: - Shaman checkout for the job (but see below) - Manager-local files of the job (task logs, last-rendered images) - The job itself The removal is done in the above order, so the job is only removed from the database if the rest of the removal was succesful. Shaman checkouts are only removed if the job was submitted with Flamenco version 3.2. Earlier versions did not record enough information to reliably do this.
1273 lines
50 KiB
Go
1273 lines
50 KiB
Go
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: git.blender.org/flamenco/internal/manager/api_impl (interfaces: PersistenceService,ChangeBroadcaster,JobCompiler,LogStorage,ConfigService,TaskStateMachine,Shaman,LastRendered,LocalStorage,WorkerSleepScheduler,JobDeleter)
|
|
|
|
// Package mocks is a generated GoMock package.
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
io "io"
|
|
reflect "reflect"
|
|
|
|
config "git.blender.org/flamenco/internal/manager/config"
|
|
job_compilers "git.blender.org/flamenco/internal/manager/job_compilers"
|
|
last_rendered "git.blender.org/flamenco/internal/manager/last_rendered"
|
|
persistence "git.blender.org/flamenco/internal/manager/persistence"
|
|
api "git.blender.org/flamenco/pkg/api"
|
|
gomock "github.com/golang/mock/gomock"
|
|
zerolog "github.com/rs/zerolog"
|
|
)
|
|
|
|
// MockPersistenceService is a mock of PersistenceService interface.
|
|
type MockPersistenceService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockPersistenceServiceMockRecorder
|
|
}
|
|
|
|
// MockPersistenceServiceMockRecorder is the mock recorder for MockPersistenceService.
|
|
type MockPersistenceServiceMockRecorder struct {
|
|
mock *MockPersistenceService
|
|
}
|
|
|
|
// NewMockPersistenceService creates a new mock instance.
|
|
func NewMockPersistenceService(ctrl *gomock.Controller) *MockPersistenceService {
|
|
mock := &MockPersistenceService{ctrl: ctrl}
|
|
mock.recorder = &MockPersistenceServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockPersistenceService) EXPECT() *MockPersistenceServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// AddWorkerToJobBlocklist mocks base method.
|
|
func (m *MockPersistenceService) AddWorkerToJobBlocklist(arg0 context.Context, arg1 *persistence.Job, arg2 *persistence.Worker, arg3 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkerToJobBlocklist", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// AddWorkerToJobBlocklist indicates an expected call of AddWorkerToJobBlocklist.
|
|
func (mr *MockPersistenceServiceMockRecorder) AddWorkerToJobBlocklist(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkerToJobBlocklist", reflect.TypeOf((*MockPersistenceService)(nil).AddWorkerToJobBlocklist), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// AddWorkerToTaskFailedList mocks base method.
|
|
func (m *MockPersistenceService) AddWorkerToTaskFailedList(arg0 context.Context, arg1 *persistence.Task, arg2 *persistence.Worker) (int, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "AddWorkerToTaskFailedList", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(int)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// AddWorkerToTaskFailedList indicates an expected call of AddWorkerToTaskFailedList.
|
|
func (mr *MockPersistenceServiceMockRecorder) AddWorkerToTaskFailedList(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWorkerToTaskFailedList", reflect.TypeOf((*MockPersistenceService)(nil).AddWorkerToTaskFailedList), arg0, arg1, arg2)
|
|
}
|
|
|
|
// ClearFailureListOfJob mocks base method.
|
|
func (m *MockPersistenceService) ClearFailureListOfJob(arg0 context.Context, arg1 *persistence.Job) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ClearFailureListOfJob", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ClearFailureListOfJob indicates an expected call of ClearFailureListOfJob.
|
|
func (mr *MockPersistenceServiceMockRecorder) ClearFailureListOfJob(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearFailureListOfJob", reflect.TypeOf((*MockPersistenceService)(nil).ClearFailureListOfJob), arg0, arg1)
|
|
}
|
|
|
|
// ClearFailureListOfTask mocks base method.
|
|
func (m *MockPersistenceService) ClearFailureListOfTask(arg0 context.Context, arg1 *persistence.Task) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ClearFailureListOfTask", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ClearFailureListOfTask indicates an expected call of ClearFailureListOfTask.
|
|
func (mr *MockPersistenceServiceMockRecorder) ClearFailureListOfTask(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearFailureListOfTask", reflect.TypeOf((*MockPersistenceService)(nil).ClearFailureListOfTask), arg0, arg1)
|
|
}
|
|
|
|
// ClearJobBlocklist mocks base method.
|
|
func (m *MockPersistenceService) ClearJobBlocklist(arg0 context.Context, arg1 *persistence.Job) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ClearJobBlocklist", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// ClearJobBlocklist indicates an expected call of ClearJobBlocklist.
|
|
func (mr *MockPersistenceServiceMockRecorder) ClearJobBlocklist(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearJobBlocklist", reflect.TypeOf((*MockPersistenceService)(nil).ClearJobBlocklist), arg0, arg1)
|
|
}
|
|
|
|
// CountTaskFailuresOfWorker mocks base method.
|
|
func (m *MockPersistenceService) CountTaskFailuresOfWorker(arg0 context.Context, arg1 *persistence.Job, arg2 *persistence.Worker, arg3 string) (int, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CountTaskFailuresOfWorker", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(int)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CountTaskFailuresOfWorker indicates an expected call of CountTaskFailuresOfWorker.
|
|
func (mr *MockPersistenceServiceMockRecorder) CountTaskFailuresOfWorker(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountTaskFailuresOfWorker", reflect.TypeOf((*MockPersistenceService)(nil).CountTaskFailuresOfWorker), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// CreateWorker mocks base method.
|
|
func (m *MockPersistenceService) CreateWorker(arg0 context.Context, arg1 *persistence.Worker) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateWorker", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CreateWorker indicates an expected call of CreateWorker.
|
|
func (mr *MockPersistenceServiceMockRecorder) CreateWorker(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorker", reflect.TypeOf((*MockPersistenceService)(nil).CreateWorker), arg0, arg1)
|
|
}
|
|
|
|
// DeleteWorker mocks base method.
|
|
func (m *MockPersistenceService) DeleteWorker(arg0 context.Context, arg1 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteWorker", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteWorker indicates an expected call of DeleteWorker.
|
|
func (mr *MockPersistenceServiceMockRecorder) DeleteWorker(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorker", reflect.TypeOf((*MockPersistenceService)(nil).DeleteWorker), arg0, arg1)
|
|
}
|
|
|
|
// FetchJob mocks base method.
|
|
func (m *MockPersistenceService) FetchJob(arg0 context.Context, arg1 string) (*persistence.Job, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchJob", arg0, arg1)
|
|
ret0, _ := ret[0].(*persistence.Job)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchJob indicates an expected call of FetchJob.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchJob(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJob", reflect.TypeOf((*MockPersistenceService)(nil).FetchJob), arg0, arg1)
|
|
}
|
|
|
|
// FetchJobBlocklist mocks base method.
|
|
func (m *MockPersistenceService) FetchJobBlocklist(arg0 context.Context, arg1 string) ([]persistence.JobBlock, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchJobBlocklist", arg0, arg1)
|
|
ret0, _ := ret[0].([]persistence.JobBlock)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchJobBlocklist indicates an expected call of FetchJobBlocklist.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchJobBlocklist(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJobBlocklist", reflect.TypeOf((*MockPersistenceService)(nil).FetchJobBlocklist), arg0, arg1)
|
|
}
|
|
|
|
// FetchTask mocks base method.
|
|
func (m *MockPersistenceService) FetchTask(arg0 context.Context, arg1 string) (*persistence.Task, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchTask", arg0, arg1)
|
|
ret0, _ := ret[0].(*persistence.Task)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchTask indicates an expected call of FetchTask.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchTask(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTask", reflect.TypeOf((*MockPersistenceService)(nil).FetchTask), arg0, arg1)
|
|
}
|
|
|
|
// FetchTaskFailureList mocks base method.
|
|
func (m *MockPersistenceService) FetchTaskFailureList(arg0 context.Context, arg1 *persistence.Task) ([]*persistence.Worker, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchTaskFailureList", arg0, arg1)
|
|
ret0, _ := ret[0].([]*persistence.Worker)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchTaskFailureList indicates an expected call of FetchTaskFailureList.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchTaskFailureList(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTaskFailureList", reflect.TypeOf((*MockPersistenceService)(nil).FetchTaskFailureList), arg0, arg1)
|
|
}
|
|
|
|
// FetchWorker mocks base method.
|
|
func (m *MockPersistenceService) FetchWorker(arg0 context.Context, arg1 string) (*persistence.Worker, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchWorker", arg0, arg1)
|
|
ret0, _ := ret[0].(*persistence.Worker)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorker indicates an expected call of FetchWorker.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchWorker(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorker", reflect.TypeOf((*MockPersistenceService)(nil).FetchWorker), arg0, arg1)
|
|
}
|
|
|
|
// FetchWorkerTask mocks base method.
|
|
func (m *MockPersistenceService) FetchWorkerTask(arg0 context.Context, arg1 *persistence.Worker) (*persistence.Task, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchWorkerTask", arg0, arg1)
|
|
ret0, _ := ret[0].(*persistence.Task)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorkerTask indicates an expected call of FetchWorkerTask.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchWorkerTask(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkerTask", reflect.TypeOf((*MockPersistenceService)(nil).FetchWorkerTask), arg0, arg1)
|
|
}
|
|
|
|
// FetchWorkers mocks base method.
|
|
func (m *MockPersistenceService) FetchWorkers(arg0 context.Context) ([]*persistence.Worker, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchWorkers", arg0)
|
|
ret0, _ := ret[0].([]*persistence.Worker)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorkers indicates an expected call of FetchWorkers.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchWorkers(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkers", reflect.TypeOf((*MockPersistenceService)(nil).FetchWorkers), arg0)
|
|
}
|
|
|
|
// GetLastRenderedJobUUID mocks base method.
|
|
func (m *MockPersistenceService) GetLastRenderedJobUUID(arg0 context.Context) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetLastRenderedJobUUID", arg0)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetLastRenderedJobUUID indicates an expected call of GetLastRenderedJobUUID.
|
|
func (mr *MockPersistenceServiceMockRecorder) GetLastRenderedJobUUID(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastRenderedJobUUID", reflect.TypeOf((*MockPersistenceService)(nil).GetLastRenderedJobUUID), arg0)
|
|
}
|
|
|
|
// QueryJobTaskSummaries mocks base method.
|
|
func (m *MockPersistenceService) QueryJobTaskSummaries(arg0 context.Context, arg1 string) ([]*persistence.Task, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "QueryJobTaskSummaries", arg0, arg1)
|
|
ret0, _ := ret[0].([]*persistence.Task)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// QueryJobTaskSummaries indicates an expected call of QueryJobTaskSummaries.
|
|
func (mr *MockPersistenceServiceMockRecorder) QueryJobTaskSummaries(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryJobTaskSummaries", reflect.TypeOf((*MockPersistenceService)(nil).QueryJobTaskSummaries), arg0, arg1)
|
|
}
|
|
|
|
// QueryJobs mocks base method.
|
|
func (m *MockPersistenceService) QueryJobs(arg0 context.Context, arg1 api.JobsQuery) ([]*persistence.Job, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "QueryJobs", arg0, arg1)
|
|
ret0, _ := ret[0].([]*persistence.Job)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// QueryJobs indicates an expected call of QueryJobs.
|
|
func (mr *MockPersistenceServiceMockRecorder) QueryJobs(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryJobs", reflect.TypeOf((*MockPersistenceService)(nil).QueryJobs), arg0, arg1)
|
|
}
|
|
|
|
// RemoveFromJobBlocklist mocks base method.
|
|
func (m *MockPersistenceService) RemoveFromJobBlocklist(arg0 context.Context, arg1, arg2, arg3 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RemoveFromJobBlocklist", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// RemoveFromJobBlocklist indicates an expected call of RemoveFromJobBlocklist.
|
|
func (mr *MockPersistenceServiceMockRecorder) RemoveFromJobBlocklist(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFromJobBlocklist", reflect.TypeOf((*MockPersistenceService)(nil).RemoveFromJobBlocklist), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// SaveJobPriority mocks base method.
|
|
func (m *MockPersistenceService) SaveJobPriority(arg0 context.Context, arg1 *persistence.Job) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SaveJobPriority", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SaveJobPriority indicates an expected call of SaveJobPriority.
|
|
func (mr *MockPersistenceServiceMockRecorder) SaveJobPriority(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveJobPriority", reflect.TypeOf((*MockPersistenceService)(nil).SaveJobPriority), arg0, arg1)
|
|
}
|
|
|
|
// SaveTask mocks base method.
|
|
func (m *MockPersistenceService) SaveTask(arg0 context.Context, arg1 *persistence.Task) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SaveTask", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SaveTask indicates an expected call of SaveTask.
|
|
func (mr *MockPersistenceServiceMockRecorder) SaveTask(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTask", reflect.TypeOf((*MockPersistenceService)(nil).SaveTask), arg0, arg1)
|
|
}
|
|
|
|
// SaveTaskActivity mocks base method.
|
|
func (m *MockPersistenceService) SaveTaskActivity(arg0 context.Context, arg1 *persistence.Task) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SaveTaskActivity", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SaveTaskActivity indicates an expected call of SaveTaskActivity.
|
|
func (mr *MockPersistenceServiceMockRecorder) SaveTaskActivity(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTaskActivity", reflect.TypeOf((*MockPersistenceService)(nil).SaveTaskActivity), arg0, arg1)
|
|
}
|
|
|
|
// SaveWorker mocks base method.
|
|
func (m *MockPersistenceService) SaveWorker(arg0 context.Context, arg1 *persistence.Worker) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SaveWorker", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SaveWorker indicates an expected call of SaveWorker.
|
|
func (mr *MockPersistenceServiceMockRecorder) SaveWorker(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveWorker", reflect.TypeOf((*MockPersistenceService)(nil).SaveWorker), arg0, arg1)
|
|
}
|
|
|
|
// SaveWorkerStatus mocks base method.
|
|
func (m *MockPersistenceService) SaveWorkerStatus(arg0 context.Context, arg1 *persistence.Worker) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SaveWorkerStatus", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SaveWorkerStatus indicates an expected call of SaveWorkerStatus.
|
|
func (mr *MockPersistenceServiceMockRecorder) SaveWorkerStatus(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveWorkerStatus", reflect.TypeOf((*MockPersistenceService)(nil).SaveWorkerStatus), arg0, arg1)
|
|
}
|
|
|
|
// ScheduleTask mocks base method.
|
|
func (m *MockPersistenceService) ScheduleTask(arg0 context.Context, arg1 *persistence.Worker) (*persistence.Task, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ScheduleTask", arg0, arg1)
|
|
ret0, _ := ret[0].(*persistence.Task)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ScheduleTask indicates an expected call of ScheduleTask.
|
|
func (mr *MockPersistenceServiceMockRecorder) ScheduleTask(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleTask", reflect.TypeOf((*MockPersistenceService)(nil).ScheduleTask), arg0, arg1)
|
|
}
|
|
|
|
// SetLastRendered mocks base method.
|
|
func (m *MockPersistenceService) SetLastRendered(arg0 context.Context, arg1 *persistence.Job) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetLastRendered", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetLastRendered indicates an expected call of SetLastRendered.
|
|
func (mr *MockPersistenceServiceMockRecorder) SetLastRendered(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastRendered", reflect.TypeOf((*MockPersistenceService)(nil).SetLastRendered), arg0, arg1)
|
|
}
|
|
|
|
// StoreAuthoredJob mocks base method.
|
|
func (m *MockPersistenceService) StoreAuthoredJob(arg0 context.Context, arg1 job_compilers.AuthoredJob) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "StoreAuthoredJob", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// StoreAuthoredJob indicates an expected call of StoreAuthoredJob.
|
|
func (mr *MockPersistenceServiceMockRecorder) StoreAuthoredJob(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreAuthoredJob", reflect.TypeOf((*MockPersistenceService)(nil).StoreAuthoredJob), arg0, arg1)
|
|
}
|
|
|
|
// TaskTouchedByWorker mocks base method.
|
|
func (m *MockPersistenceService) TaskTouchedByWorker(arg0 context.Context, arg1 *persistence.Task) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TaskTouchedByWorker", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// TaskTouchedByWorker indicates an expected call of TaskTouchedByWorker.
|
|
func (mr *MockPersistenceServiceMockRecorder) TaskTouchedByWorker(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskTouchedByWorker", reflect.TypeOf((*MockPersistenceService)(nil).TaskTouchedByWorker), arg0, arg1)
|
|
}
|
|
|
|
// WorkerSeen mocks base method.
|
|
func (m *MockPersistenceService) WorkerSeen(arg0 context.Context, arg1 *persistence.Worker) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WorkerSeen", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// WorkerSeen indicates an expected call of WorkerSeen.
|
|
func (mr *MockPersistenceServiceMockRecorder) WorkerSeen(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerSeen", reflect.TypeOf((*MockPersistenceService)(nil).WorkerSeen), arg0, arg1)
|
|
}
|
|
|
|
// WorkersLeftToRun mocks base method.
|
|
func (m *MockPersistenceService) WorkersLeftToRun(arg0 context.Context, arg1 *persistence.Job, arg2 string) (map[string]bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WorkersLeftToRun", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(map[string]bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WorkersLeftToRun indicates an expected call of WorkersLeftToRun.
|
|
func (mr *MockPersistenceServiceMockRecorder) WorkersLeftToRun(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkersLeftToRun", reflect.TypeOf((*MockPersistenceService)(nil).WorkersLeftToRun), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockChangeBroadcaster is a mock of ChangeBroadcaster interface.
|
|
type MockChangeBroadcaster struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockChangeBroadcasterMockRecorder
|
|
}
|
|
|
|
// MockChangeBroadcasterMockRecorder is the mock recorder for MockChangeBroadcaster.
|
|
type MockChangeBroadcasterMockRecorder struct {
|
|
mock *MockChangeBroadcaster
|
|
}
|
|
|
|
// NewMockChangeBroadcaster creates a new mock instance.
|
|
func NewMockChangeBroadcaster(ctrl *gomock.Controller) *MockChangeBroadcaster {
|
|
mock := &MockChangeBroadcaster{ctrl: ctrl}
|
|
mock.recorder = &MockChangeBroadcasterMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockChangeBroadcaster) EXPECT() *MockChangeBroadcasterMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// BroadcastJobUpdate mocks base method.
|
|
func (m *MockChangeBroadcaster) BroadcastJobUpdate(arg0 api.SocketIOJobUpdate) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "BroadcastJobUpdate", arg0)
|
|
}
|
|
|
|
// BroadcastJobUpdate indicates an expected call of BroadcastJobUpdate.
|
|
func (mr *MockChangeBroadcasterMockRecorder) BroadcastJobUpdate(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastJobUpdate", reflect.TypeOf((*MockChangeBroadcaster)(nil).BroadcastJobUpdate), arg0)
|
|
}
|
|
|
|
// BroadcastLastRenderedImage mocks base method.
|
|
func (m *MockChangeBroadcaster) BroadcastLastRenderedImage(arg0 api.SocketIOLastRenderedUpdate) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "BroadcastLastRenderedImage", arg0)
|
|
}
|
|
|
|
// BroadcastLastRenderedImage indicates an expected call of BroadcastLastRenderedImage.
|
|
func (mr *MockChangeBroadcasterMockRecorder) BroadcastLastRenderedImage(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastLastRenderedImage", reflect.TypeOf((*MockChangeBroadcaster)(nil).BroadcastLastRenderedImage), arg0)
|
|
}
|
|
|
|
// BroadcastNewJob mocks base method.
|
|
func (m *MockChangeBroadcaster) BroadcastNewJob(arg0 api.SocketIOJobUpdate) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "BroadcastNewJob", arg0)
|
|
}
|
|
|
|
// BroadcastNewJob indicates an expected call of BroadcastNewJob.
|
|
func (mr *MockChangeBroadcasterMockRecorder) BroadcastNewJob(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastNewJob", reflect.TypeOf((*MockChangeBroadcaster)(nil).BroadcastNewJob), arg0)
|
|
}
|
|
|
|
// BroadcastNewWorker mocks base method.
|
|
func (m *MockChangeBroadcaster) BroadcastNewWorker(arg0 api.SocketIOWorkerUpdate) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "BroadcastNewWorker", arg0)
|
|
}
|
|
|
|
// BroadcastNewWorker indicates an expected call of BroadcastNewWorker.
|
|
func (mr *MockChangeBroadcasterMockRecorder) BroadcastNewWorker(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastNewWorker", reflect.TypeOf((*MockChangeBroadcaster)(nil).BroadcastNewWorker), arg0)
|
|
}
|
|
|
|
// BroadcastWorkerUpdate mocks base method.
|
|
func (m *MockChangeBroadcaster) BroadcastWorkerUpdate(arg0 api.SocketIOWorkerUpdate) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "BroadcastWorkerUpdate", arg0)
|
|
}
|
|
|
|
// BroadcastWorkerUpdate indicates an expected call of BroadcastWorkerUpdate.
|
|
func (mr *MockChangeBroadcasterMockRecorder) BroadcastWorkerUpdate(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastWorkerUpdate", reflect.TypeOf((*MockChangeBroadcaster)(nil).BroadcastWorkerUpdate), arg0)
|
|
}
|
|
|
|
// MockJobCompiler is a mock of JobCompiler interface.
|
|
type MockJobCompiler struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockJobCompilerMockRecorder
|
|
}
|
|
|
|
// MockJobCompilerMockRecorder is the mock recorder for MockJobCompiler.
|
|
type MockJobCompilerMockRecorder struct {
|
|
mock *MockJobCompiler
|
|
}
|
|
|
|
// NewMockJobCompiler creates a new mock instance.
|
|
func NewMockJobCompiler(ctrl *gomock.Controller) *MockJobCompiler {
|
|
mock := &MockJobCompiler{ctrl: ctrl}
|
|
mock.recorder = &MockJobCompilerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockJobCompiler) EXPECT() *MockJobCompilerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Compile mocks base method.
|
|
func (m *MockJobCompiler) Compile(arg0 context.Context, arg1 api.SubmittedJob) (*job_compilers.AuthoredJob, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Compile", arg0, arg1)
|
|
ret0, _ := ret[0].(*job_compilers.AuthoredJob)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Compile indicates an expected call of Compile.
|
|
func (mr *MockJobCompilerMockRecorder) Compile(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compile", reflect.TypeOf((*MockJobCompiler)(nil).Compile), arg0, arg1)
|
|
}
|
|
|
|
// GetJobType mocks base method.
|
|
func (m *MockJobCompiler) GetJobType(arg0 string) (api.AvailableJobType, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "GetJobType", arg0)
|
|
ret0, _ := ret[0].(api.AvailableJobType)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetJobType indicates an expected call of GetJobType.
|
|
func (mr *MockJobCompilerMockRecorder) GetJobType(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobType", reflect.TypeOf((*MockJobCompiler)(nil).GetJobType), arg0)
|
|
}
|
|
|
|
// ListJobTypes mocks base method.
|
|
func (m *MockJobCompiler) ListJobTypes() api.AvailableJobTypes {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ListJobTypes")
|
|
ret0, _ := ret[0].(api.AvailableJobTypes)
|
|
return ret0
|
|
}
|
|
|
|
// ListJobTypes indicates an expected call of ListJobTypes.
|
|
func (mr *MockJobCompilerMockRecorder) ListJobTypes() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListJobTypes", reflect.TypeOf((*MockJobCompiler)(nil).ListJobTypes))
|
|
}
|
|
|
|
// MockLogStorage is a mock of LogStorage interface.
|
|
type MockLogStorage struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockLogStorageMockRecorder
|
|
}
|
|
|
|
// MockLogStorageMockRecorder is the mock recorder for MockLogStorage.
|
|
type MockLogStorageMockRecorder struct {
|
|
mock *MockLogStorage
|
|
}
|
|
|
|
// NewMockLogStorage creates a new mock instance.
|
|
func NewMockLogStorage(ctrl *gomock.Controller) *MockLogStorage {
|
|
mock := &MockLogStorage{ctrl: ctrl}
|
|
mock.recorder = &MockLogStorageMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockLogStorage) EXPECT() *MockLogStorageMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Filepath mocks base method.
|
|
func (m *MockLogStorage) Filepath(arg0, arg1 string) string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Filepath", arg0, arg1)
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// Filepath indicates an expected call of Filepath.
|
|
func (mr *MockLogStorageMockRecorder) Filepath(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Filepath", reflect.TypeOf((*MockLogStorage)(nil).Filepath), arg0, arg1)
|
|
}
|
|
|
|
// RotateFile mocks base method.
|
|
func (m *MockLogStorage) RotateFile(arg0 zerolog.Logger, arg1, arg2 string) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "RotateFile", arg0, arg1, arg2)
|
|
}
|
|
|
|
// RotateFile indicates an expected call of RotateFile.
|
|
func (mr *MockLogStorageMockRecorder) RotateFile(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RotateFile", reflect.TypeOf((*MockLogStorage)(nil).RotateFile), arg0, arg1, arg2)
|
|
}
|
|
|
|
// Tail mocks base method.
|
|
func (m *MockLogStorage) Tail(arg0, arg1 string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Tail", arg0, arg1)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Tail indicates an expected call of Tail.
|
|
func (mr *MockLogStorageMockRecorder) Tail(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tail", reflect.TypeOf((*MockLogStorage)(nil).Tail), arg0, arg1)
|
|
}
|
|
|
|
// TaskLogSize mocks base method.
|
|
func (m *MockLogStorage) TaskLogSize(arg0, arg1 string) (int64, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TaskLogSize", arg0, arg1)
|
|
ret0, _ := ret[0].(int64)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TaskLogSize indicates an expected call of TaskLogSize.
|
|
func (mr *MockLogStorageMockRecorder) TaskLogSize(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskLogSize", reflect.TypeOf((*MockLogStorage)(nil).TaskLogSize), arg0, arg1)
|
|
}
|
|
|
|
// Write mocks base method.
|
|
func (m *MockLogStorage) Write(arg0 zerolog.Logger, arg1, arg2, arg3 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Write", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Write indicates an expected call of Write.
|
|
func (mr *MockLogStorageMockRecorder) Write(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockLogStorage)(nil).Write), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// WriteTimestamped mocks base method.
|
|
func (m *MockLogStorage) WriteTimestamped(arg0 zerolog.Logger, arg1, arg2, arg3 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WriteTimestamped", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// WriteTimestamped indicates an expected call of WriteTimestamped.
|
|
func (mr *MockLogStorageMockRecorder) WriteTimestamped(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTimestamped", reflect.TypeOf((*MockLogStorage)(nil).WriteTimestamped), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// MockConfigService is a mock of ConfigService interface.
|
|
type MockConfigService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockConfigServiceMockRecorder
|
|
}
|
|
|
|
// MockConfigServiceMockRecorder is the mock recorder for MockConfigService.
|
|
type MockConfigServiceMockRecorder struct {
|
|
mock *MockConfigService
|
|
}
|
|
|
|
// NewMockConfigService creates a new mock instance.
|
|
func NewMockConfigService(ctrl *gomock.Controller) *MockConfigService {
|
|
mock := &MockConfigService{ctrl: ctrl}
|
|
mock.recorder = &MockConfigServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockConfigService) EXPECT() *MockConfigServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// ConvertTwoWayVariables mocks base method.
|
|
func (m *MockConfigService) ConvertTwoWayVariables(arg0 <-chan string, arg1 chan<- string, arg2 config.VariableAudience, arg3 config.VariablePlatform) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "ConvertTwoWayVariables", arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// ConvertTwoWayVariables indicates an expected call of ConvertTwoWayVariables.
|
|
func (mr *MockConfigServiceMockRecorder) ConvertTwoWayVariables(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConvertTwoWayVariables", reflect.TypeOf((*MockConfigService)(nil).ConvertTwoWayVariables), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// EffectiveStoragePath mocks base method.
|
|
func (m *MockConfigService) EffectiveStoragePath() string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "EffectiveStoragePath")
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// EffectiveStoragePath indicates an expected call of EffectiveStoragePath.
|
|
func (mr *MockConfigServiceMockRecorder) EffectiveStoragePath() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EffectiveStoragePath", reflect.TypeOf((*MockConfigService)(nil).EffectiveStoragePath))
|
|
}
|
|
|
|
// ExpandVariables mocks base method.
|
|
func (m *MockConfigService) ExpandVariables(arg0 <-chan string, arg1 chan<- string, arg2 config.VariableAudience, arg3 config.VariablePlatform) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "ExpandVariables", arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// ExpandVariables indicates an expected call of ExpandVariables.
|
|
func (mr *MockConfigServiceMockRecorder) ExpandVariables(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpandVariables", reflect.TypeOf((*MockConfigService)(nil).ExpandVariables), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// ForceFirstRun mocks base method.
|
|
func (m *MockConfigService) ForceFirstRun() {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "ForceFirstRun")
|
|
}
|
|
|
|
// ForceFirstRun indicates an expected call of ForceFirstRun.
|
|
func (mr *MockConfigServiceMockRecorder) ForceFirstRun() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceFirstRun", reflect.TypeOf((*MockConfigService)(nil).ForceFirstRun))
|
|
}
|
|
|
|
// Get mocks base method.
|
|
func (m *MockConfigService) Get() *config.Conf {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Get")
|
|
ret0, _ := ret[0].(*config.Conf)
|
|
return ret0
|
|
}
|
|
|
|
// Get indicates an expected call of Get.
|
|
func (mr *MockConfigServiceMockRecorder) Get() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockConfigService)(nil).Get))
|
|
}
|
|
|
|
// IsFirstRun mocks base method.
|
|
func (m *MockConfigService) IsFirstRun() (bool, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsFirstRun")
|
|
ret0, _ := ret[0].(bool)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// IsFirstRun indicates an expected call of IsFirstRun.
|
|
func (mr *MockConfigServiceMockRecorder) IsFirstRun() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsFirstRun", reflect.TypeOf((*MockConfigService)(nil).IsFirstRun))
|
|
}
|
|
|
|
// ResolveVariables mocks base method.
|
|
func (m *MockConfigService) ResolveVariables(arg0 config.VariableAudience, arg1 config.VariablePlatform) map[string]config.ResolvedVariable {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ResolveVariables", arg0, arg1)
|
|
ret0, _ := ret[0].(map[string]config.ResolvedVariable)
|
|
return ret0
|
|
}
|
|
|
|
// ResolveVariables indicates an expected call of ResolveVariables.
|
|
func (mr *MockConfigServiceMockRecorder) ResolveVariables(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveVariables", reflect.TypeOf((*MockConfigService)(nil).ResolveVariables), arg0, arg1)
|
|
}
|
|
|
|
// Save mocks base method.
|
|
func (m *MockConfigService) Save() error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Save")
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// Save indicates an expected call of Save.
|
|
func (mr *MockConfigServiceMockRecorder) Save() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockConfigService)(nil).Save))
|
|
}
|
|
|
|
// MockTaskStateMachine is a mock of TaskStateMachine interface.
|
|
type MockTaskStateMachine struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockTaskStateMachineMockRecorder
|
|
}
|
|
|
|
// MockTaskStateMachineMockRecorder is the mock recorder for MockTaskStateMachine.
|
|
type MockTaskStateMachineMockRecorder struct {
|
|
mock *MockTaskStateMachine
|
|
}
|
|
|
|
// NewMockTaskStateMachine creates a new mock instance.
|
|
func NewMockTaskStateMachine(ctrl *gomock.Controller) *MockTaskStateMachine {
|
|
mock := &MockTaskStateMachine{ctrl: ctrl}
|
|
mock.recorder = &MockTaskStateMachineMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockTaskStateMachine) EXPECT() *MockTaskStateMachineMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// JobStatusChange mocks base method.
|
|
func (m *MockTaskStateMachine) JobStatusChange(arg0 context.Context, arg1 *persistence.Job, arg2 api.JobStatus, arg3 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "JobStatusChange", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// JobStatusChange indicates an expected call of JobStatusChange.
|
|
func (mr *MockTaskStateMachineMockRecorder) JobStatusChange(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JobStatusChange", reflect.TypeOf((*MockTaskStateMachine)(nil).JobStatusChange), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// RequeueActiveTasksOfWorker mocks base method.
|
|
func (m *MockTaskStateMachine) RequeueActiveTasksOfWorker(arg0 context.Context, arg1 *persistence.Worker, arg2 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RequeueActiveTasksOfWorker", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// RequeueActiveTasksOfWorker indicates an expected call of RequeueActiveTasksOfWorker.
|
|
func (mr *MockTaskStateMachineMockRecorder) RequeueActiveTasksOfWorker(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequeueActiveTasksOfWorker", reflect.TypeOf((*MockTaskStateMachine)(nil).RequeueActiveTasksOfWorker), arg0, arg1, arg2)
|
|
}
|
|
|
|
// RequeueFailedTasksOfWorkerOfJob mocks base method.
|
|
func (m *MockTaskStateMachine) RequeueFailedTasksOfWorkerOfJob(arg0 context.Context, arg1 *persistence.Worker, arg2 *persistence.Job, arg3 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RequeueFailedTasksOfWorkerOfJob", arg0, arg1, arg2, arg3)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// RequeueFailedTasksOfWorkerOfJob indicates an expected call of RequeueFailedTasksOfWorkerOfJob.
|
|
func (mr *MockTaskStateMachineMockRecorder) RequeueFailedTasksOfWorkerOfJob(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequeueFailedTasksOfWorkerOfJob", reflect.TypeOf((*MockTaskStateMachine)(nil).RequeueFailedTasksOfWorkerOfJob), arg0, arg1, arg2, arg3)
|
|
}
|
|
|
|
// TaskStatusChange mocks base method.
|
|
func (m *MockTaskStateMachine) TaskStatusChange(arg0 context.Context, arg1 *persistence.Task, arg2 api.TaskStatus) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "TaskStatusChange", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// TaskStatusChange indicates an expected call of TaskStatusChange.
|
|
func (mr *MockTaskStateMachineMockRecorder) TaskStatusChange(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskStatusChange", reflect.TypeOf((*MockTaskStateMachine)(nil).TaskStatusChange), arg0, arg1, arg2)
|
|
}
|
|
|
|
// MockShaman is a mock of Shaman interface.
|
|
type MockShaman struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockShamanMockRecorder
|
|
}
|
|
|
|
// MockShamanMockRecorder is the mock recorder for MockShaman.
|
|
type MockShamanMockRecorder struct {
|
|
mock *MockShaman
|
|
}
|
|
|
|
// NewMockShaman creates a new mock instance.
|
|
func NewMockShaman(ctrl *gomock.Controller) *MockShaman {
|
|
mock := &MockShaman{ctrl: ctrl}
|
|
mock.recorder = &MockShamanMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockShaman) EXPECT() *MockShamanMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Checkout mocks base method.
|
|
func (m *MockShaman) Checkout(arg0 context.Context, arg1 api.ShamanCheckout) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Checkout", arg0, arg1)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Checkout indicates an expected call of Checkout.
|
|
func (mr *MockShamanMockRecorder) Checkout(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Checkout", reflect.TypeOf((*MockShaman)(nil).Checkout), arg0, arg1)
|
|
}
|
|
|
|
// EraseCheckout mocks base method.
|
|
func (m *MockShaman) EraseCheckout(arg0 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "EraseCheckout", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// EraseCheckout indicates an expected call of EraseCheckout.
|
|
func (mr *MockShamanMockRecorder) EraseCheckout(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EraseCheckout", reflect.TypeOf((*MockShaman)(nil).EraseCheckout), arg0)
|
|
}
|
|
|
|
// FileStore mocks base method.
|
|
func (m *MockShaman) FileStore(arg0 context.Context, arg1 io.ReadCloser, arg2 string, arg3 int64, arg4 bool, arg5 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FileStore", arg0, arg1, arg2, arg3, arg4, arg5)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// FileStore indicates an expected call of FileStore.
|
|
func (mr *MockShamanMockRecorder) FileStore(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FileStore", reflect.TypeOf((*MockShaman)(nil).FileStore), arg0, arg1, arg2, arg3, arg4, arg5)
|
|
}
|
|
|
|
// FileStoreCheck mocks base method.
|
|
func (m *MockShaman) FileStoreCheck(arg0 context.Context, arg1 string, arg2 int64) api.ShamanFileStatus {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FileStoreCheck", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(api.ShamanFileStatus)
|
|
return ret0
|
|
}
|
|
|
|
// FileStoreCheck indicates an expected call of FileStoreCheck.
|
|
func (mr *MockShamanMockRecorder) FileStoreCheck(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FileStoreCheck", reflect.TypeOf((*MockShaman)(nil).FileStoreCheck), arg0, arg1, arg2)
|
|
}
|
|
|
|
// IsEnabled mocks base method.
|
|
func (m *MockShaman) IsEnabled() bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "IsEnabled")
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// IsEnabled indicates an expected call of IsEnabled.
|
|
func (mr *MockShamanMockRecorder) IsEnabled() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsEnabled", reflect.TypeOf((*MockShaman)(nil).IsEnabled))
|
|
}
|
|
|
|
// Requirements mocks base method.
|
|
func (m *MockShaman) Requirements(arg0 context.Context, arg1 api.ShamanRequirementsRequest) (api.ShamanRequirementsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Requirements", arg0, arg1)
|
|
ret0, _ := ret[0].(api.ShamanRequirementsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// Requirements indicates an expected call of Requirements.
|
|
func (mr *MockShamanMockRecorder) Requirements(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Requirements", reflect.TypeOf((*MockShaman)(nil).Requirements), arg0, arg1)
|
|
}
|
|
|
|
// MockLastRendered is a mock of LastRendered interface.
|
|
type MockLastRendered struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockLastRenderedMockRecorder
|
|
}
|
|
|
|
// MockLastRenderedMockRecorder is the mock recorder for MockLastRendered.
|
|
type MockLastRenderedMockRecorder struct {
|
|
mock *MockLastRendered
|
|
}
|
|
|
|
// NewMockLastRendered creates a new mock instance.
|
|
func NewMockLastRendered(ctrl *gomock.Controller) *MockLastRendered {
|
|
mock := &MockLastRendered{ctrl: ctrl}
|
|
mock.recorder = &MockLastRenderedMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockLastRendered) EXPECT() *MockLastRenderedMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// JobHasImage mocks base method.
|
|
func (m *MockLastRendered) JobHasImage(arg0 string) bool {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "JobHasImage", arg0)
|
|
ret0, _ := ret[0].(bool)
|
|
return ret0
|
|
}
|
|
|
|
// JobHasImage indicates an expected call of JobHasImage.
|
|
func (mr *MockLastRenderedMockRecorder) JobHasImage(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JobHasImage", reflect.TypeOf((*MockLastRendered)(nil).JobHasImage), arg0)
|
|
}
|
|
|
|
// PathForJob mocks base method.
|
|
func (m *MockLastRendered) PathForJob(arg0 string) string {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "PathForJob", arg0)
|
|
ret0, _ := ret[0].(string)
|
|
return ret0
|
|
}
|
|
|
|
// PathForJob indicates an expected call of PathForJob.
|
|
func (mr *MockLastRenderedMockRecorder) PathForJob(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PathForJob", reflect.TypeOf((*MockLastRendered)(nil).PathForJob), arg0)
|
|
}
|
|
|
|
// QueueImage mocks base method.
|
|
func (m *MockLastRendered) QueueImage(arg0 last_rendered.Payload) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "QueueImage", arg0)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// QueueImage indicates an expected call of QueueImage.
|
|
func (mr *MockLastRenderedMockRecorder) QueueImage(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueImage", reflect.TypeOf((*MockLastRendered)(nil).QueueImage), arg0)
|
|
}
|
|
|
|
// ThumbSpecs mocks base method.
|
|
func (m *MockLastRendered) ThumbSpecs() []last_rendered.Thumbspec {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "ThumbSpecs")
|
|
ret0, _ := ret[0].([]last_rendered.Thumbspec)
|
|
return ret0
|
|
}
|
|
|
|
// ThumbSpecs indicates an expected call of ThumbSpecs.
|
|
func (mr *MockLastRenderedMockRecorder) ThumbSpecs() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ThumbSpecs", reflect.TypeOf((*MockLastRendered)(nil).ThumbSpecs))
|
|
}
|
|
|
|
// MockLocalStorage is a mock of LocalStorage interface.
|
|
type MockLocalStorage struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockLocalStorageMockRecorder
|
|
}
|
|
|
|
// MockLocalStorageMockRecorder is the mock recorder for MockLocalStorage.
|
|
type MockLocalStorageMockRecorder struct {
|
|
mock *MockLocalStorage
|
|
}
|
|
|
|
// NewMockLocalStorage creates a new mock instance.
|
|
func NewMockLocalStorage(ctrl *gomock.Controller) *MockLocalStorage {
|
|
mock := &MockLocalStorage{ctrl: ctrl}
|
|
mock.recorder = &MockLocalStorageMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockLocalStorage) EXPECT() *MockLocalStorageMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// RelPath mocks base method.
|
|
func (m *MockLocalStorage) RelPath(arg0 string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "RelPath", arg0)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RelPath indicates an expected call of RelPath.
|
|
func (mr *MockLocalStorageMockRecorder) RelPath(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RelPath", reflect.TypeOf((*MockLocalStorage)(nil).RelPath), arg0)
|
|
}
|
|
|
|
// MockWorkerSleepScheduler is a mock of WorkerSleepScheduler interface.
|
|
type MockWorkerSleepScheduler struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockWorkerSleepSchedulerMockRecorder
|
|
}
|
|
|
|
// MockWorkerSleepSchedulerMockRecorder is the mock recorder for MockWorkerSleepScheduler.
|
|
type MockWorkerSleepSchedulerMockRecorder struct {
|
|
mock *MockWorkerSleepScheduler
|
|
}
|
|
|
|
// NewMockWorkerSleepScheduler creates a new mock instance.
|
|
func NewMockWorkerSleepScheduler(ctrl *gomock.Controller) *MockWorkerSleepScheduler {
|
|
mock := &MockWorkerSleepScheduler{ctrl: ctrl}
|
|
mock.recorder = &MockWorkerSleepSchedulerMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockWorkerSleepScheduler) EXPECT() *MockWorkerSleepSchedulerMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// FetchSchedule mocks base method.
|
|
func (m *MockWorkerSleepScheduler) FetchSchedule(arg0 context.Context, arg1 string) (*persistence.SleepSchedule, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchSchedule", arg0, arg1)
|
|
ret0, _ := ret[0].(*persistence.SleepSchedule)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchSchedule indicates an expected call of FetchSchedule.
|
|
func (mr *MockWorkerSleepSchedulerMockRecorder) FetchSchedule(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchSchedule", reflect.TypeOf((*MockWorkerSleepScheduler)(nil).FetchSchedule), arg0, arg1)
|
|
}
|
|
|
|
// SetSchedule mocks base method.
|
|
func (m *MockWorkerSleepScheduler) SetSchedule(arg0 context.Context, arg1 string, arg2 *persistence.SleepSchedule) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SetSchedule", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SetSchedule indicates an expected call of SetSchedule.
|
|
func (mr *MockWorkerSleepSchedulerMockRecorder) SetSchedule(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSchedule", reflect.TypeOf((*MockWorkerSleepScheduler)(nil).SetSchedule), arg0, arg1, arg2)
|
|
}
|
|
|
|
// WorkerStatus mocks base method.
|
|
func (m *MockWorkerSleepScheduler) WorkerStatus(arg0 context.Context, arg1 string) (api.WorkerStatus, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WorkerStatus", arg0, arg1)
|
|
ret0, _ := ret[0].(api.WorkerStatus)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WorkerStatus indicates an expected call of WorkerStatus.
|
|
func (mr *MockWorkerSleepSchedulerMockRecorder) WorkerStatus(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStatus", reflect.TypeOf((*MockWorkerSleepScheduler)(nil).WorkerStatus), arg0, arg1)
|
|
}
|
|
|
|
// MockJobDeleter is a mock of JobDeleter interface.
|
|
type MockJobDeleter struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockJobDeleterMockRecorder
|
|
}
|
|
|
|
// MockJobDeleterMockRecorder is the mock recorder for MockJobDeleter.
|
|
type MockJobDeleterMockRecorder struct {
|
|
mock *MockJobDeleter
|
|
}
|
|
|
|
// NewMockJobDeleter creates a new mock instance.
|
|
func NewMockJobDeleter(ctrl *gomock.Controller) *MockJobDeleter {
|
|
mock := &MockJobDeleter{ctrl: ctrl}
|
|
mock.recorder = &MockJobDeleterMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockJobDeleter) EXPECT() *MockJobDeleterMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// QueueJobDeletion mocks base method.
|
|
func (m *MockJobDeleter) QueueJobDeletion(arg0 context.Context, arg1 *persistence.Job) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "QueueJobDeletion", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// QueueJobDeletion indicates an expected call of QueueJobDeletion.
|
|
func (mr *MockJobDeleterMockRecorder) QueueJobDeletion(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueJobDeletion", reflect.TypeOf((*MockJobDeleter)(nil).QueueJobDeletion), arg0, arg1)
|
|
}
|