21227c8046
- Addon switches between filesystem-packing and Shaman-packing automatically, depending on whether the Manager has Shaman enabled. - Actually using BAT for Shaman packing. It doesn't work though, some error occurs when receiving Shaman response from the Manager in the Addon.
498 lines
23 KiB
Go
498 lines
23 KiB
Go
// 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
|
|
}
|
|
|
|
// 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...)
|
|
}
|
|
|
|
// 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...)
|
|
}
|
|
|
|
// 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...)
|
|
}
|
|
|
|
// 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...)
|
|
}
|
|
|
|
// 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...)
|
|
}
|
|
|
|
// 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...)
|
|
}
|
|
|
|
// 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...)
|
|
}
|
|
|
|
// 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...)
|
|
}
|
|
|
|
// 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...)
|
|
}
|
|
|
|
// 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...)
|
|
}
|