1518 lines
74 KiB
Go
Generated
1518 lines
74 KiB
Go
Generated
// Code generated by MockGen. DO NOT EDIT.
|
|
// Source: git.blender.org/flamenco/internal/worker (interfaces: FlamencoClient)
|
|
|
|
// Package mocks is a generated GoMock package.
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
io "io"
|
|
reflect "reflect"
|
|
|
|
api "git.blender.org/flamenco/pkg/api"
|
|
gomock "github.com/golang/mock/gomock"
|
|
)
|
|
|
|
// MockFlamencoClient is a mock of FlamencoClient interface.
|
|
type MockFlamencoClient struct {
|
|
ctrl *gomock.Controller
|
|
recorder *MockFlamencoClientMockRecorder
|
|
}
|
|
|
|
// MockFlamencoClientMockRecorder is the mock recorder for MockFlamencoClient.
|
|
type MockFlamencoClientMockRecorder struct {
|
|
mock *MockFlamencoClient
|
|
}
|
|
|
|
// NewMockFlamencoClient creates a new mock instance.
|
|
func NewMockFlamencoClient(ctrl *gomock.Controller) *MockFlamencoClient {
|
|
mock := &MockFlamencoClient{ctrl: ctrl}
|
|
mock.recorder = &MockFlamencoClientMockRecorder{mock}
|
|
return mock
|
|
}
|
|
|
|
// EXPECT returns an object that allows the caller to indicate expected use.
|
|
func (m *MockFlamencoClient) EXPECT() *MockFlamencoClientMockRecorder {
|
|
return m.recorder
|
|
}
|
|
|
|
// CheckBlenderExePathWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) CheckBlenderExePathWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.CheckBlenderExePathResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "CheckBlenderExePathWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.CheckBlenderExePathResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CheckBlenderExePathWithBodyWithResponse indicates an expected call of CheckBlenderExePathWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) CheckBlenderExePathWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckBlenderExePathWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).CheckBlenderExePathWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// CheckBlenderExePathWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) CheckBlenderExePathWithResponse(arg0 context.Context, arg1 api.CheckBlenderExePathJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.CheckBlenderExePathResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "CheckBlenderExePathWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.CheckBlenderExePathResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CheckBlenderExePathWithResponse indicates an expected call of CheckBlenderExePathWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) CheckBlenderExePathWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckBlenderExePathWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).CheckBlenderExePathWithResponse), varargs...)
|
|
}
|
|
|
|
// CheckSharedStoragePathWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) CheckSharedStoragePathWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.CheckSharedStoragePathResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "CheckSharedStoragePathWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.CheckSharedStoragePathResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CheckSharedStoragePathWithBodyWithResponse indicates an expected call of CheckSharedStoragePathWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) CheckSharedStoragePathWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckSharedStoragePathWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).CheckSharedStoragePathWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// CheckSharedStoragePathWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) CheckSharedStoragePathWithResponse(arg0 context.Context, arg1 api.CheckSharedStoragePathJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.CheckSharedStoragePathResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "CheckSharedStoragePathWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.CheckSharedStoragePathResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CheckSharedStoragePathWithResponse indicates an expected call of CheckSharedStoragePathWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) CheckSharedStoragePathWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckSharedStoragePathWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).CheckSharedStoragePathWithResponse), varargs...)
|
|
}
|
|
|
|
// CreateWorkerTagWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) CreateWorkerTagWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.CreateWorkerTagResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "CreateWorkerTagWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.CreateWorkerTagResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateWorkerTagWithBodyWithResponse indicates an expected call of CreateWorkerTagWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) CreateWorkerTagWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkerTagWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).CreateWorkerTagWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// CreateWorkerTagWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) CreateWorkerTagWithResponse(arg0 context.Context, arg1 api.CreateWorkerTagJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.CreateWorkerTagResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "CreateWorkerTagWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.CreateWorkerTagResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// CreateWorkerTagWithResponse indicates an expected call of CreateWorkerTagWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) CreateWorkerTagWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateWorkerTagWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).CreateWorkerTagWithResponse), varargs...)
|
|
}
|
|
|
|
// DeleteJobWhatWouldItDoWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) DeleteJobWhatWouldItDoWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.DeleteJobWhatWouldItDoResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "DeleteJobWhatWouldItDoWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.DeleteJobWhatWouldItDoResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteJobWhatWouldItDoWithResponse indicates an expected call of DeleteJobWhatWouldItDoWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) DeleteJobWhatWouldItDoWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteJobWhatWouldItDoWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).DeleteJobWhatWouldItDoWithResponse), varargs...)
|
|
}
|
|
|
|
// DeleteJobWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) DeleteJobWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.DeleteJobResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "DeleteJobWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.DeleteJobResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteJobWithResponse indicates an expected call of DeleteJobWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) DeleteJobWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteJobWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).DeleteJobWithResponse), varargs...)
|
|
}
|
|
|
|
// DeleteWorkerTagWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) DeleteWorkerTagWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.DeleteWorkerTagResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "DeleteWorkerTagWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.DeleteWorkerTagResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteWorkerTagWithResponse indicates an expected call of DeleteWorkerTagWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) DeleteWorkerTagWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkerTagWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).DeleteWorkerTagWithResponse), varargs...)
|
|
}
|
|
|
|
// DeleteWorkerWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) DeleteWorkerWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.DeleteWorkerResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "DeleteWorkerWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.DeleteWorkerResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// DeleteWorkerWithResponse indicates an expected call of DeleteWorkerWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) DeleteWorkerWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkerWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).DeleteWorkerWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchGlobalLastRenderedInfoWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchGlobalLastRenderedInfoWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.FetchGlobalLastRenderedInfoResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchGlobalLastRenderedInfoWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchGlobalLastRenderedInfoResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchGlobalLastRenderedInfoWithResponse indicates an expected call of FetchGlobalLastRenderedInfoWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchGlobalLastRenderedInfoWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchGlobalLastRenderedInfoWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchGlobalLastRenderedInfoWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchJobBlocklistWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchJobBlocklistWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchJobBlocklistResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchJobBlocklistWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchJobBlocklistResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchJobBlocklistWithResponse indicates an expected call of FetchJobBlocklistWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchJobBlocklistWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJobBlocklistWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchJobBlocklistWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchJobLastRenderedInfoWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchJobLastRenderedInfoWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchJobLastRenderedInfoResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchJobLastRenderedInfoWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchJobLastRenderedInfoResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchJobLastRenderedInfoWithResponse indicates an expected call of FetchJobLastRenderedInfoWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchJobLastRenderedInfoWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJobLastRenderedInfoWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchJobLastRenderedInfoWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchJobTasksWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchJobTasksWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchJobTasksResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchJobTasksWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchJobTasksResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchJobTasksWithResponse indicates an expected call of FetchJobTasksWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchJobTasksWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJobTasksWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchJobTasksWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchJobWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchJobWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchJobResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchJobWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchJobResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchJobWithResponse indicates an expected call of FetchJobWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchJobWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchJobWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchJobWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchTaskLogInfoWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchTaskLogInfoWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchTaskLogInfoResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchTaskLogInfoWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchTaskLogInfoResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchTaskLogInfoWithResponse indicates an expected call of FetchTaskLogInfoWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchTaskLogInfoWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTaskLogInfoWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchTaskLogInfoWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchTaskLogTailWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchTaskLogTailWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchTaskLogTailResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchTaskLogTailWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchTaskLogTailResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchTaskLogTailWithResponse indicates an expected call of FetchTaskLogTailWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchTaskLogTailWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTaskLogTailWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchTaskLogTailWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchTaskWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchTaskWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchTaskResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchTaskWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchTaskResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchTaskWithResponse indicates an expected call of FetchTaskWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchTaskWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTaskWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchTaskWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchWorkerSleepScheduleWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchWorkerSleepScheduleWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchWorkerSleepScheduleResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchWorkerSleepScheduleWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchWorkerSleepScheduleResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorkerSleepScheduleWithResponse indicates an expected call of FetchWorkerSleepScheduleWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchWorkerSleepScheduleWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkerSleepScheduleWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchWorkerSleepScheduleWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchWorkerTagWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchWorkerTagWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchWorkerTagResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchWorkerTagWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchWorkerTagResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorkerTagWithResponse indicates an expected call of FetchWorkerTagWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchWorkerTagWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkerTagWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchWorkerTagWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchWorkerTagsWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchWorkerTagsWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.FetchWorkerTagsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchWorkerTagsWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchWorkerTagsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorkerTagsWithResponse indicates an expected call of FetchWorkerTagsWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchWorkerTagsWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkerTagsWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchWorkerTagsWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchWorkerWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchWorkerWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.FetchWorkerResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchWorkerWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchWorkerResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorkerWithResponse indicates an expected call of FetchWorkerWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchWorkerWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkerWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchWorkerWithResponse), varargs...)
|
|
}
|
|
|
|
// FetchWorkersWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FetchWorkersWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.FetchWorkersResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FetchWorkersWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FetchWorkersResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FetchWorkersWithResponse indicates an expected call of FetchWorkersWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FetchWorkersWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkersWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FetchWorkersWithResponse), varargs...)
|
|
}
|
|
|
|
// FindBlenderExePathWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) FindBlenderExePathWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.FindBlenderExePathResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "FindBlenderExePathWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.FindBlenderExePathResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// FindBlenderExePathWithResponse indicates an expected call of FindBlenderExePathWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) FindBlenderExePathWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindBlenderExePathWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).FindBlenderExePathWithResponse), varargs...)
|
|
}
|
|
|
|
// GetConfigurationFileWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) GetConfigurationFileWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.GetConfigurationFileResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetConfigurationFileWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.GetConfigurationFileResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetConfigurationFileWithResponse indicates an expected call of GetConfigurationFileWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) GetConfigurationFileWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationFileWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetConfigurationFileWithResponse), varargs...)
|
|
}
|
|
|
|
// GetConfigurationWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) GetConfigurationWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.GetConfigurationResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetConfigurationWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.GetConfigurationResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetConfigurationWithResponse indicates an expected call of GetConfigurationWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) GetConfigurationWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfigurationWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetConfigurationWithResponse), varargs...)
|
|
}
|
|
|
|
// GetJobTypeWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) GetJobTypeWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.GetJobTypeResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetJobTypeWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.GetJobTypeResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetJobTypeWithResponse indicates an expected call of GetJobTypeWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) GetJobTypeWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobTypeWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetJobTypeWithResponse), varargs...)
|
|
}
|
|
|
|
// GetJobTypesWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) GetJobTypesWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.GetJobTypesResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetJobTypesWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.GetJobTypesResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetJobTypesWithResponse indicates an expected call of GetJobTypesWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) GetJobTypesWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJobTypesWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetJobTypesWithResponse), varargs...)
|
|
}
|
|
|
|
// GetSharedStorageWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) GetSharedStorageWithResponse(arg0 context.Context, arg1 api.ManagerVariableAudience, arg2 string, arg3 ...api.RequestEditorFn) (*api.GetSharedStorageResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetSharedStorageWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.GetSharedStorageResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetSharedStorageWithResponse indicates an expected call of GetSharedStorageWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) GetSharedStorageWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSharedStorageWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetSharedStorageWithResponse), varargs...)
|
|
}
|
|
|
|
// GetVariablesWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) GetVariablesWithResponse(arg0 context.Context, arg1 api.ManagerVariableAudience, arg2 string, arg3 ...api.RequestEditorFn) (*api.GetVariablesResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetVariablesWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.GetVariablesResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetVariablesWithResponse indicates an expected call of GetVariablesWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) GetVariablesWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVariablesWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetVariablesWithResponse), varargs...)
|
|
}
|
|
|
|
// GetVersionWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) GetVersionWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.GetVersionResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "GetVersionWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.GetVersionResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// GetVersionWithResponse indicates an expected call of GetVersionWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) GetVersionWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersionWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).GetVersionWithResponse), varargs...)
|
|
}
|
|
|
|
// MayWorkerRunWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) MayWorkerRunWithResponse(arg0 context.Context, arg1 string, arg2 ...api.RequestEditorFn) (*api.MayWorkerRunResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "MayWorkerRunWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.MayWorkerRunResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// MayWorkerRunWithResponse indicates an expected call of MayWorkerRunWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) MayWorkerRunWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MayWorkerRunWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).MayWorkerRunWithResponse), varargs...)
|
|
}
|
|
|
|
// QueryJobsWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) QueryJobsWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.QueryJobsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "QueryJobsWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.QueryJobsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// QueryJobsWithBodyWithResponse indicates an expected call of QueryJobsWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) QueryJobsWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryJobsWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).QueryJobsWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// QueryJobsWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) QueryJobsWithResponse(arg0 context.Context, arg1 api.QueryJobsJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.QueryJobsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "QueryJobsWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.QueryJobsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// QueryJobsWithResponse indicates an expected call of QueryJobsWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) QueryJobsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryJobsWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).QueryJobsWithResponse), varargs...)
|
|
}
|
|
|
|
// RegisterWorkerWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) RegisterWorkerWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.RegisterWorkerResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RegisterWorkerWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.RegisterWorkerResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RegisterWorkerWithBodyWithResponse indicates an expected call of RegisterWorkerWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) RegisterWorkerWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkerWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RegisterWorkerWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// RegisterWorkerWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) RegisterWorkerWithResponse(arg0 context.Context, arg1 api.RegisterWorkerJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.RegisterWorkerResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RegisterWorkerWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.RegisterWorkerResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RegisterWorkerWithResponse indicates an expected call of RegisterWorkerWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) RegisterWorkerWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkerWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RegisterWorkerWithResponse), varargs...)
|
|
}
|
|
|
|
// RemoveJobBlocklistWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) RemoveJobBlocklistWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.RemoveJobBlocklistResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RemoveJobBlocklistWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.RemoveJobBlocklistResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RemoveJobBlocklistWithBodyWithResponse indicates an expected call of RemoveJobBlocklistWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) RemoveJobBlocklistWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveJobBlocklistWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RemoveJobBlocklistWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// RemoveJobBlocklistWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) RemoveJobBlocklistWithResponse(arg0 context.Context, arg1 string, arg2 api.RemoveJobBlocklistJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.RemoveJobBlocklistResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RemoveJobBlocklistWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.RemoveJobBlocklistResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RemoveJobBlocklistWithResponse indicates an expected call of RemoveJobBlocklistWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) RemoveJobBlocklistWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveJobBlocklistWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RemoveJobBlocklistWithResponse), varargs...)
|
|
}
|
|
|
|
// RequestWorkerStatusChangeWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) RequestWorkerStatusChangeWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.RequestWorkerStatusChangeResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RequestWorkerStatusChangeWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.RequestWorkerStatusChangeResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RequestWorkerStatusChangeWithBodyWithResponse indicates an expected call of RequestWorkerStatusChangeWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) RequestWorkerStatusChangeWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestWorkerStatusChangeWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RequestWorkerStatusChangeWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// RequestWorkerStatusChangeWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) RequestWorkerStatusChangeWithResponse(arg0 context.Context, arg1 string, arg2 api.RequestWorkerStatusChangeJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.RequestWorkerStatusChangeResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "RequestWorkerStatusChangeWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.RequestWorkerStatusChangeResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// RequestWorkerStatusChangeWithResponse indicates an expected call of RequestWorkerStatusChangeWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) RequestWorkerStatusChangeWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestWorkerStatusChangeWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).RequestWorkerStatusChangeWithResponse), varargs...)
|
|
}
|
|
|
|
// SaveSetupAssistantConfigWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SaveSetupAssistantConfigWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.SaveSetupAssistantConfigResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SaveSetupAssistantConfigWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SaveSetupAssistantConfigResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SaveSetupAssistantConfigWithBodyWithResponse indicates an expected call of SaveSetupAssistantConfigWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SaveSetupAssistantConfigWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSetupAssistantConfigWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SaveSetupAssistantConfigWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SaveSetupAssistantConfigWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SaveSetupAssistantConfigWithResponse(arg0 context.Context, arg1 api.SaveSetupAssistantConfigJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.SaveSetupAssistantConfigResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SaveSetupAssistantConfigWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SaveSetupAssistantConfigResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SaveSetupAssistantConfigWithResponse indicates an expected call of SaveSetupAssistantConfigWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SaveSetupAssistantConfigWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSetupAssistantConfigWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SaveSetupAssistantConfigWithResponse), varargs...)
|
|
}
|
|
|
|
// ScheduleTaskWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) ScheduleTaskWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.ScheduleTaskResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ScheduleTaskWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.ScheduleTaskResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ScheduleTaskWithResponse indicates an expected call of ScheduleTaskWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) ScheduleTaskWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScheduleTaskWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ScheduleTaskWithResponse), varargs...)
|
|
}
|
|
|
|
// SetJobPriorityWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetJobPriorityWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.SetJobPriorityResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetJobPriorityWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetJobPriorityResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetJobPriorityWithBodyWithResponse indicates an expected call of SetJobPriorityWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetJobPriorityWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetJobPriorityWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetJobPriorityWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SetJobPriorityWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetJobPriorityWithResponse(arg0 context.Context, arg1 string, arg2 api.SetJobPriorityJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.SetJobPriorityResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetJobPriorityWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetJobPriorityResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetJobPriorityWithResponse indicates an expected call of SetJobPriorityWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetJobPriorityWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetJobPriorityWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetJobPriorityWithResponse), varargs...)
|
|
}
|
|
|
|
// SetJobStatusWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetJobStatusWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.SetJobStatusResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetJobStatusWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetJobStatusResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetJobStatusWithBodyWithResponse indicates an expected call of SetJobStatusWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetJobStatusWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetJobStatusWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetJobStatusWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SetJobStatusWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetJobStatusWithResponse(arg0 context.Context, arg1 string, arg2 api.SetJobStatusJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.SetJobStatusResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetJobStatusWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetJobStatusResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetJobStatusWithResponse indicates an expected call of SetJobStatusWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetJobStatusWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetJobStatusWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetJobStatusWithResponse), varargs...)
|
|
}
|
|
|
|
// SetTaskStatusWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetTaskStatusWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.SetTaskStatusResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetTaskStatusWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetTaskStatusResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetTaskStatusWithBodyWithResponse indicates an expected call of SetTaskStatusWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetTaskStatusWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTaskStatusWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetTaskStatusWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SetTaskStatusWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetTaskStatusWithResponse(arg0 context.Context, arg1 string, arg2 api.SetTaskStatusJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.SetTaskStatusResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetTaskStatusWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetTaskStatusResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetTaskStatusWithResponse indicates an expected call of SetTaskStatusWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetTaskStatusWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTaskStatusWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetTaskStatusWithResponse), varargs...)
|
|
}
|
|
|
|
// SetWorkerSleepScheduleWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetWorkerSleepScheduleWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.SetWorkerSleepScheduleResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetWorkerSleepScheduleWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetWorkerSleepScheduleResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetWorkerSleepScheduleWithBodyWithResponse indicates an expected call of SetWorkerSleepScheduleWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetWorkerSleepScheduleWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkerSleepScheduleWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetWorkerSleepScheduleWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SetWorkerSleepScheduleWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetWorkerSleepScheduleWithResponse(arg0 context.Context, arg1 string, arg2 api.SetWorkerSleepScheduleJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.SetWorkerSleepScheduleResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetWorkerSleepScheduleWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetWorkerSleepScheduleResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetWorkerSleepScheduleWithResponse indicates an expected call of SetWorkerSleepScheduleWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetWorkerSleepScheduleWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkerSleepScheduleWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetWorkerSleepScheduleWithResponse), varargs...)
|
|
}
|
|
|
|
// SetWorkerTagsWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetWorkerTagsWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.SetWorkerTagsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetWorkerTagsWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetWorkerTagsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetWorkerTagsWithBodyWithResponse indicates an expected call of SetWorkerTagsWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetWorkerTagsWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkerTagsWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetWorkerTagsWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SetWorkerTagsWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SetWorkerTagsWithResponse(arg0 context.Context, arg1 string, arg2 api.SetWorkerTagsJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.SetWorkerTagsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SetWorkerTagsWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SetWorkerTagsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SetWorkerTagsWithResponse indicates an expected call of SetWorkerTagsWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SetWorkerTagsWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWorkerTagsWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SetWorkerTagsWithResponse), varargs...)
|
|
}
|
|
|
|
// ShamanCheckoutRequirementsWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) ShamanCheckoutRequirementsWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.ShamanCheckoutRequirementsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ShamanCheckoutRequirementsWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.ShamanCheckoutRequirementsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ShamanCheckoutRequirementsWithBodyWithResponse indicates an expected call of ShamanCheckoutRequirementsWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) ShamanCheckoutRequirementsWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanCheckoutRequirementsWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanCheckoutRequirementsWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// ShamanCheckoutRequirementsWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) ShamanCheckoutRequirementsWithResponse(arg0 context.Context, arg1 api.ShamanCheckoutRequirementsJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.ShamanCheckoutRequirementsResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ShamanCheckoutRequirementsWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.ShamanCheckoutRequirementsResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ShamanCheckoutRequirementsWithResponse indicates an expected call of ShamanCheckoutRequirementsWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) ShamanCheckoutRequirementsWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanCheckoutRequirementsWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanCheckoutRequirementsWithResponse), varargs...)
|
|
}
|
|
|
|
// ShamanCheckoutWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) ShamanCheckoutWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.ShamanCheckoutResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ShamanCheckoutWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.ShamanCheckoutResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ShamanCheckoutWithBodyWithResponse indicates an expected call of ShamanCheckoutWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) ShamanCheckoutWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanCheckoutWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanCheckoutWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// ShamanCheckoutWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) ShamanCheckoutWithResponse(arg0 context.Context, arg1 api.ShamanCheckoutJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.ShamanCheckoutResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ShamanCheckoutWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.ShamanCheckoutResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ShamanCheckoutWithResponse indicates an expected call of ShamanCheckoutWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) ShamanCheckoutWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanCheckoutWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanCheckoutWithResponse), varargs...)
|
|
}
|
|
|
|
// ShamanFileStoreCheckWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) ShamanFileStoreCheckWithResponse(arg0 context.Context, arg1 string, arg2 int, arg3 ...api.RequestEditorFn) (*api.ShamanFileStoreCheckResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ShamanFileStoreCheckWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.ShamanFileStoreCheckResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ShamanFileStoreCheckWithResponse indicates an expected call of ShamanFileStoreCheckWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) ShamanFileStoreCheckWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanFileStoreCheckWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanFileStoreCheckWithResponse), varargs...)
|
|
}
|
|
|
|
// ShamanFileStoreWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) ShamanFileStoreWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 int, arg3 *api.ShamanFileStoreParams, arg4 string, arg5 io.Reader, arg6 ...api.RequestEditorFn) (*api.ShamanFileStoreResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3, arg4, arg5}
|
|
for _, a := range arg6 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "ShamanFileStoreWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.ShamanFileStoreResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// ShamanFileStoreWithBodyWithResponse indicates an expected call of ShamanFileStoreWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) ShamanFileStoreWithBodyWithResponse(arg0, arg1, arg2, arg3, arg4, arg5 interface{}, arg6 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5}, arg6...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShamanFileStoreWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).ShamanFileStoreWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SignOffWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SignOffWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.SignOffResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SignOffWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SignOffResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SignOffWithResponse indicates an expected call of SignOffWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SignOffWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOffWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SignOffWithResponse), varargs...)
|
|
}
|
|
|
|
// SignOnWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SignOnWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.SignOnResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SignOnWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SignOnResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SignOnWithBodyWithResponse indicates an expected call of SignOnWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SignOnWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOnWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SignOnWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SignOnWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SignOnWithResponse(arg0 context.Context, arg1 api.SignOnJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.SignOnResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SignOnWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SignOnResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SignOnWithResponse indicates an expected call of SignOnWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SignOnWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignOnWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SignOnWithResponse), varargs...)
|
|
}
|
|
|
|
// SubmitJobCheckWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SubmitJobCheckWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.SubmitJobCheckResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SubmitJobCheckWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SubmitJobCheckResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SubmitJobCheckWithBodyWithResponse indicates an expected call of SubmitJobCheckWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SubmitJobCheckWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitJobCheckWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SubmitJobCheckWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SubmitJobCheckWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SubmitJobCheckWithResponse(arg0 context.Context, arg1 api.SubmitJobCheckJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.SubmitJobCheckResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SubmitJobCheckWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SubmitJobCheckResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SubmitJobCheckWithResponse indicates an expected call of SubmitJobCheckWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SubmitJobCheckWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitJobCheckWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SubmitJobCheckWithResponse), varargs...)
|
|
}
|
|
|
|
// SubmitJobWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SubmitJobWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.SubmitJobResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SubmitJobWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SubmitJobResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SubmitJobWithBodyWithResponse indicates an expected call of SubmitJobWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SubmitJobWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitJobWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SubmitJobWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// SubmitJobWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) SubmitJobWithResponse(arg0 context.Context, arg1 api.SubmitJobJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.SubmitJobResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "SubmitJobWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.SubmitJobResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// SubmitJobWithResponse indicates an expected call of SubmitJobWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) SubmitJobWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitJobWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).SubmitJobWithResponse), varargs...)
|
|
}
|
|
|
|
// TaskOutputProducedWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) TaskOutputProducedWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.TaskOutputProducedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "TaskOutputProducedWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.TaskOutputProducedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TaskOutputProducedWithBodyWithResponse indicates an expected call of TaskOutputProducedWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) TaskOutputProducedWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskOutputProducedWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).TaskOutputProducedWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// TaskUpdateWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) TaskUpdateWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.TaskUpdateResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "TaskUpdateWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.TaskUpdateResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TaskUpdateWithBodyWithResponse indicates an expected call of TaskUpdateWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) TaskUpdateWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskUpdateWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).TaskUpdateWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// TaskUpdateWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) TaskUpdateWithResponse(arg0 context.Context, arg1 string, arg2 api.TaskUpdateJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.TaskUpdateResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "TaskUpdateWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.TaskUpdateResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// TaskUpdateWithResponse indicates an expected call of TaskUpdateWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) TaskUpdateWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TaskUpdateWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).TaskUpdateWithResponse), varargs...)
|
|
}
|
|
|
|
// UpdateWorkerTagWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) UpdateWorkerTagWithBodyWithResponse(arg0 context.Context, arg1, arg2 string, arg3 io.Reader, arg4 ...api.RequestEditorFn) (*api.UpdateWorkerTagResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2, arg3}
|
|
for _, a := range arg4 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "UpdateWorkerTagWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.UpdateWorkerTagResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateWorkerTagWithBodyWithResponse indicates an expected call of UpdateWorkerTagWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) UpdateWorkerTagWithBodyWithResponse(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkerTagWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).UpdateWorkerTagWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// UpdateWorkerTagWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) UpdateWorkerTagWithResponse(arg0 context.Context, arg1 string, arg2 api.UpdateWorkerTagJSONRequestBody, arg3 ...api.RequestEditorFn) (*api.UpdateWorkerTagResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "UpdateWorkerTagWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.UpdateWorkerTagResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// UpdateWorkerTagWithResponse indicates an expected call of UpdateWorkerTagWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) UpdateWorkerTagWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWorkerTagWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).UpdateWorkerTagWithResponse), varargs...)
|
|
}
|
|
|
|
// WorkerStateChangedWithBodyWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) WorkerStateChangedWithBodyWithResponse(arg0 context.Context, arg1 string, arg2 io.Reader, arg3 ...api.RequestEditorFn) (*api.WorkerStateChangedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1, arg2}
|
|
for _, a := range arg3 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "WorkerStateChangedWithBodyWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.WorkerStateChangedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WorkerStateChangedWithBodyWithResponse indicates an expected call of WorkerStateChangedWithBodyWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) WorkerStateChangedWithBodyWithResponse(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStateChangedWithBodyWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).WorkerStateChangedWithBodyWithResponse), varargs...)
|
|
}
|
|
|
|
// WorkerStateChangedWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) WorkerStateChangedWithResponse(arg0 context.Context, arg1 api.WorkerStateChangedJSONRequestBody, arg2 ...api.RequestEditorFn) (*api.WorkerStateChangedResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0, arg1}
|
|
for _, a := range arg2 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "WorkerStateChangedWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.WorkerStateChangedResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WorkerStateChangedWithResponse indicates an expected call of WorkerStateChangedWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) WorkerStateChangedWithResponse(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0, arg1}, arg2...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStateChangedWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).WorkerStateChangedWithResponse), varargs...)
|
|
}
|
|
|
|
// WorkerStateWithResponse mocks base method.
|
|
func (m *MockFlamencoClient) WorkerStateWithResponse(arg0 context.Context, arg1 ...api.RequestEditorFn) (*api.WorkerStateResponse, error) {
|
|
m.ctrl.T.Helper()
|
|
varargs := []interface{}{arg0}
|
|
for _, a := range arg1 {
|
|
varargs = append(varargs, a)
|
|
}
|
|
ret := m.ctrl.Call(m, "WorkerStateWithResponse", varargs...)
|
|
ret0, _ := ret[0].(*api.WorkerStateResponse)
|
|
ret1, _ := ret[1].(error)
|
|
return ret0, ret1
|
|
}
|
|
|
|
// WorkerStateWithResponse indicates an expected call of WorkerStateWithResponse.
|
|
func (mr *MockFlamencoClientMockRecorder) WorkerStateWithResponse(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
|
|
mr.mock.ctrl.T.Helper()
|
|
varargs := append([]interface{}{arg0}, arg1...)
|
|
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkerStateWithResponse", reflect.TypeOf((*MockFlamencoClient)(nil).WorkerStateWithResponse), varargs...)
|
|
}
|