94d71bc3c9
Replace old used-to-be-GORM datastructures (#104305) with sqlc-generated structs. This also makes it possible to use more specific structs that are more taylored to the specific queries, increasing efficiency. This commit covers job blocklists and last-rendered images. Functional changes are kept to a minimum, as the API still serves the same data. Because this work covers so much of Flamenco's code, it's been split up into different commits. Each commit brings Flamenco to a state where it compiles and unit tests pass. Only the result of the final commit has actually been tested properly. Ref: #104343
1455 lines
57 KiB
Go
Generated
1455 lines
57 KiB
Go
Generated
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: projects.blender.org/studio/flamenco/internal/manager/api_impl (interfaces: PersistenceService,ChangeBroadcaster,JobCompiler,LogStorage,ConfigService,TaskStateMachine,Shaman,LastRendered,LocalStorage,WorkerSleepScheduler,JobDeleter,FarmStatusService)
|
|
|
|
// Package mocks is a generated GoMock package.
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
io "io"
|
|
reflect "reflect"
|
|
time "time"
|
|
|
|
gomock "github.com/golang/mock/gomock"
|
|
zerolog "github.com/rs/zerolog"
|
|
config "projects.blender.org/studio/flamenco/internal/manager/config"
|
|
job_compilers "projects.blender.org/studio/flamenco/internal/manager/job_compilers"
|
|
last_rendered "projects.blender.org/studio/flamenco/internal/manager/last_rendered"
|
|
persistence "projects.blender.org/studio/flamenco/internal/manager/persistence"
|
|
sqlc "projects.blender.org/studio/flamenco/internal/manager/persistence/sqlc"
|
|
api "projects.blender.org/studio/flamenco/pkg/api"
|
|
)
|
|
|
|
// 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)
|
|
}
|
|
|
|
// CreateWorkerTag mocks base method.
|
|
func (m *MockPersistenceService) CreateWorkerTag(arg0 context.Context, arg1 *persistence.WorkerTag) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "CreateWorkerTag", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// CreateWorkerTag indicates an expected call of CreateWorkerTag.
|
|
func (mr *MockPersistenceServiceMockRecorder) CreateWorkerTag(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkerTag", reflect.TypeOf((*MockPersistenceService)(nil).CreateWorkerTag), 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)
|
|
}
|
|
|
|
// DeleteWorkerTag mocks base method.
|
|
func (m *MockPersistenceService) DeleteWorkerTag(arg0 context.Context, arg1 string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "DeleteWorkerTag", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// DeleteWorkerTag indicates an expected call of DeleteWorkerTag.
|
|
func (mr *MockPersistenceServiceMockRecorder) DeleteWorkerTag(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkerTag", reflect.TypeOf((*MockPersistenceService)(nil).DeleteWorkerTag), 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) ([]sqlc.FetchJobBlocklistRow, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchJobBlocklist", arg0, arg1)
|
|
ret0, _ := ret[0].([]sqlc.FetchJobBlocklistRow)
|
|
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)
|
|
}
|
|
|
|
// FetchJobs mocks base method.
|
|
func (m *MockPersistenceService) FetchJobs(arg0 context.Context) ([]*persistence.Job, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchJobs", arg0)
|
|
ret0, _ := ret[0].([]*persistence.Job)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchJobs indicates an expected call of FetchJobs.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchJobs(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJobs", reflect.TypeOf((*MockPersistenceService)(nil).FetchJobs), arg0)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// FetchTaskJobUUID mocks base method.
|
|
func (m *MockPersistenceService) FetchTaskJobUUID(arg0 context.Context, arg1 string) (string, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchTaskJobUUID", arg0, arg1)
|
|
ret0, _ := ret[0].(string)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchTaskJobUUID indicates an expected call of FetchTaskJobUUID.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchTaskJobUUID(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTaskJobUUID", reflect.TypeOf((*MockPersistenceService)(nil).FetchTaskJobUUID), 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)
|
|
}
|
|
|
|
// FetchWorkerTag mocks base method.
|
|
func (m *MockPersistenceService) FetchWorkerTag(arg0 context.Context, arg1 string) (*persistence.WorkerTag, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchWorkerTag", arg0, arg1)
|
|
ret0, _ := ret[0].(*persistence.WorkerTag)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorkerTag indicates an expected call of FetchWorkerTag.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchWorkerTag(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkerTag", reflect.TypeOf((*MockPersistenceService)(nil).FetchWorkerTag), arg0, arg1)
|
|
}
|
|
|
|
// FetchWorkerTags mocks base method.
|
|
func (m *MockPersistenceService) FetchWorkerTags(arg0 context.Context) ([]*persistence.WorkerTag, error) {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "FetchWorkerTags", arg0)
|
|
ret0, _ := ret[0].([]*persistence.WorkerTag)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorkerTags indicates an expected call of FetchWorkerTags.
|
|
func (mr *MockPersistenceServiceMockRecorder) FetchWorkerTags(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkerTags", reflect.TypeOf((*MockPersistenceService)(nil).FetchWorkerTags), arg0)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// SaveWorkerTag mocks base method.
|
|
func (m *MockPersistenceService) SaveWorkerTag(arg0 context.Context, arg1 *persistence.WorkerTag) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "SaveWorkerTag", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// SaveWorkerTag indicates an expected call of SaveWorkerTag.
|
|
func (mr *MockPersistenceServiceMockRecorder) SaveWorkerTag(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveWorkerTag", reflect.TypeOf((*MockPersistenceService)(nil).SaveWorkerTag), 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)
|
|
}
|
|
|
|
// WorkerSetTags mocks base method.
|
|
func (m *MockPersistenceService) WorkerSetTags(arg0 context.Context, arg1 *persistence.Worker, arg2 []string) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WorkerSetTags", arg0, arg1, arg2)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// WorkerSetTags indicates an expected call of WorkerSetTags.
|
|
func (mr *MockPersistenceServiceMockRecorder) WorkerSetTags(arg0, arg1, arg2 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerSetTags", reflect.TypeOf((*MockPersistenceService)(nil).WorkerSetTags), arg0, arg1, arg2)
|
|
}
|
|
|
|
// 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.EventJobUpdate) {
|
|
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.EventLastRenderedUpdate) {
|
|
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.EventJobUpdate) {
|
|
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.EventWorkerUpdate) {
|
|
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)
|
|
}
|
|
|
|
// BroadcastNewWorkerTag mocks base method.
|
|
func (m *MockChangeBroadcaster) BroadcastNewWorkerTag(arg0 api.EventWorkerTagUpdate) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "BroadcastNewWorkerTag", arg0)
|
|
}
|
|
|
|
// BroadcastNewWorkerTag indicates an expected call of BroadcastNewWorkerTag.
|
|
func (mr *MockChangeBroadcasterMockRecorder) BroadcastNewWorkerTag(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastNewWorkerTag", reflect.TypeOf((*MockChangeBroadcaster)(nil).BroadcastNewWorkerTag), arg0)
|
|
}
|
|
|
|
// BroadcastWorkerTagUpdate mocks base method.
|
|
func (m *MockChangeBroadcaster) BroadcastWorkerTagUpdate(arg0 api.EventWorkerTagUpdate) {
|
|
m.ctrl.T.Helper()
|
|
m.ctrl.Call(m, "BroadcastWorkerTagUpdate", arg0)
|
|
}
|
|
|
|
// BroadcastWorkerTagUpdate indicates an expected call of BroadcastWorkerTagUpdate.
|
|
func (mr *MockChangeBroadcasterMockRecorder) BroadcastWorkerTagUpdate(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BroadcastWorkerTagUpdate", reflect.TypeOf((*MockChangeBroadcaster)(nil).BroadcastWorkerTagUpdate), arg0)
|
|
}
|
|
|
|
// BroadcastWorkerUpdate mocks base method.
|
|
func (m *MockChangeBroadcaster) BroadcastWorkerUpdate(arg0 api.EventWorkerUpdate) {
|
|
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
|
|
}
|
|
|
|
// 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))
|
|
}
|
|
|
|
// 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))
|
|
}
|
|
|
|
// NewVariableExpander mocks base method.
|
|
func (m *MockConfigService) NewVariableExpander(arg0 config.VariableAudience, arg1 config.VariablePlatform) *config.VariableExpander {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "NewVariableExpander", arg0, arg1)
|
|
ret0, _ := ret[0].(*config.VariableExpander)
|
|
return ret0
|
|
}
|
|
|
|
// NewVariableExpander indicates an expected call of NewVariableExpander.
|
|
func (mr *MockConfigServiceMockRecorder) NewVariableExpander(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewVariableExpander", reflect.TypeOf((*MockConfigService)(nil).NewVariableExpander), arg0, arg1)
|
|
}
|
|
|
|
// NewVariableToValueConverter mocks base method.
|
|
func (m *MockConfigService) NewVariableToValueConverter(arg0 config.VariableAudience, arg1 config.VariablePlatform) *config.ValueToVariableReplacer {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "NewVariableToValueConverter", arg0, arg1)
|
|
ret0, _ := ret[0].(*config.ValueToVariableReplacer)
|
|
return ret0
|
|
}
|
|
|
|
// NewVariableToValueConverter indicates an expected call of NewVariableToValueConverter.
|
|
func (mr *MockConfigServiceMockRecorder) NewVariableToValueConverter(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewVariableToValueConverter", reflect.TypeOf((*MockConfigService)(nil).NewVariableToValueConverter), arg0, arg1)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// QueueMassJobDeletion mocks base method.
|
|
func (m *MockJobDeleter) QueueMassJobDeletion(arg0 context.Context, arg1 time.Time) error {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "QueueMassJobDeletion", arg0, arg1)
|
|
ret0, _ := ret[0].(error)
|
|
return ret0
|
|
}
|
|
|
|
// QueueMassJobDeletion indicates an expected call of QueueMassJobDeletion.
|
|
func (mr *MockJobDeleterMockRecorder) QueueMassJobDeletion(arg0, arg1 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueMassJobDeletion", reflect.TypeOf((*MockJobDeleter)(nil).QueueMassJobDeletion), arg0, arg1)
|
|
}
|
|
|
|
// WhatWouldBeDeleted mocks base method.
|
|
func (m *MockJobDeleter) WhatWouldBeDeleted(arg0 *persistence.Job) api.JobDeletionInfo {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "WhatWouldBeDeleted", arg0)
|
|
ret0, _ := ret[0].(api.JobDeletionInfo)
|
|
return ret0
|
|
}
|
|
|
|
// WhatWouldBeDeleted indicates an expected call of WhatWouldBeDeleted.
|
|
func (mr *MockJobDeleterMockRecorder) WhatWouldBeDeleted(arg0 interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhatWouldBeDeleted", reflect.TypeOf((*MockJobDeleter)(nil).WhatWouldBeDeleted), arg0)
|
|
}
|
|
|
|
// MockFarmStatusService is a mock of FarmStatusService interface.
|
|
type MockFarmStatusService struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockFarmStatusServiceMockRecorder
|
|
}
|
|
|
|
// MockFarmStatusServiceMockRecorder is the mock recorder for MockFarmStatusService.
|
|
type MockFarmStatusServiceMockRecorder struct {
|
|
mock *MockFarmStatusService
|
|
}
|
|
|
|
// NewMockFarmStatusService creates a new mock instance.
|
|
func NewMockFarmStatusService(ctrl *gomock.Controller) *MockFarmStatusService {
|
|
mock := &MockFarmStatusService{ctrl: ctrl}
|
|
mock.recorder = &MockFarmStatusServiceMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockFarmStatusService) EXPECT() *MockFarmStatusServiceMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// Report mocks base method.
|
|
func (m *MockFarmStatusService) Report() api.FarmStatusReport {
|
|
m.ctrl.T.Helper()
|
|
ret := m.ctrl.Call(m, "Report")
|
|
ret0, _ := ret[0].(api.FarmStatusReport)
|
|
return ret0
|
|
}
|
|
|
|
// Report indicates an expected call of Report.
|
|
func (mr *MockFarmStatusServiceMockRecorder) Report() *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Report", reflect.TypeOf((*MockFarmStatusService)(nil).Report))
|
|
}
|