tusd/pkg/handler/handler_mock_test.go

// Code generated by MockGen. DO NOT EDIT.
// Source: utils_test.go

// Package handler_test is a generated GoMock package.
package handler_test

import (
	gomock "github.com/golang/mock/gomock"
	handler "github.com/tus/tusd/pkg/handler"
	io "io"
	reflect "reflect"
)

// MockFullDataStore is a mock of FullDataStore interface
type MockFullDataStore struct {
	ctrl     *gomock.Controller
	recorder *MockFullDataStoreMockRecorder
}

// MockFullDataStoreMockRecorder is the mock recorder for MockFullDataStore
type MockFullDataStoreMockRecorder struct {
	mock *MockFullDataStore
}

// NewMockFullDataStore creates a new mock instance
func NewMockFullDataStore(ctrl *gomock.Controller) *MockFullDataStore {
	mock := &MockFullDataStore{ctrl: ctrl}
	mock.recorder = &MockFullDataStoreMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockFullDataStore) EXPECT() *MockFullDataStoreMockRecorder {
	return m.recorder
}

// NewUpload mocks base method
func (m *MockFullDataStore) NewUpload(info handler.FileInfo) (handler.Upload, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpload", info)
	ret0, _ := ret[0].(handler.Upload)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewUpload indicates an expected call of NewUpload
func (mr *MockFullDataStoreMockRecorder) NewUpload(info interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpload", reflect.TypeOf((*MockFullDataStore)(nil).NewUpload), info)
}

// GetUpload mocks base method
func (m *MockFullDataStore) GetUpload(id string) (handler.Upload, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpload", id)
	ret0, _ := ret[0].(handler.Upload)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUpload indicates an expected call of GetUpload
func (mr *MockFullDataStoreMockRecorder) GetUpload(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpload", reflect.TypeOf((*MockFullDataStore)(nil).GetUpload), id)
}

// AsTerminatableUpload mocks base method
func (m *MockFullDataStore) AsTerminatableUpload(upload handler.Upload) handler.TerminatableUpload {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AsTerminatableUpload", upload)
	ret0, _ := ret[0].(handler.TerminatableUpload)
	return ret0
}

// AsTerminatableUpload indicates an expected call of AsTerminatableUpload
func (mr *MockFullDataStoreMockRecorder) AsTerminatableUpload(upload interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsTerminatableUpload", reflect.TypeOf((*MockFullDataStore)(nil).AsTerminatableUpload), upload)
}

// ConcatUploads mocks base method
func (m *MockFullDataStore) ConcatUploads(destination string, partialUploads []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConcatUploads", destination, partialUploads)
	ret0, _ := ret[0].(error)
	return ret0
}

// ConcatUploads indicates an expected call of ConcatUploads
func (mr *MockFullDataStoreMockRecorder) ConcatUploads(destination, partialUploads interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConcatUploads", reflect.TypeOf((*MockFullDataStore)(nil).ConcatUploads), destination, partialUploads)
}

// AsLengthDeclarableUpload mocks base method
func (m *MockFullDataStore) AsLengthDeclarableUpload(upload handler.Upload) handler.LengthDeclarableUpload {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AsLengthDeclarableUpload", upload)
	ret0, _ := ret[0].(handler.LengthDeclarableUpload)
	return ret0
}

// AsLengthDeclarableUpload indicates an expected call of AsLengthDeclarableUpload
func (mr *MockFullDataStoreMockRecorder) AsLengthDeclarableUpload(upload interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AsLengthDeclarableUpload", reflect.TypeOf((*MockFullDataStore)(nil).AsLengthDeclarableUpload), upload)
}

// MockFullUpload is a mock of FullUpload interface
type MockFullUpload struct {
	ctrl     *gomock.Controller
	recorder *MockFullUploadMockRecorder
}

// MockFullUploadMockRecorder is the mock recorder for MockFullUpload
type MockFullUploadMockRecorder struct {
	mock *MockFullUpload
}

// NewMockFullUpload creates a new mock instance
func NewMockFullUpload(ctrl *gomock.Controller) *MockFullUpload {
	mock := &MockFullUpload{ctrl: ctrl}
	mock.recorder = &MockFullUploadMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockFullUpload) EXPECT() *MockFullUploadMockRecorder {
	return m.recorder
}

// WriteChunk mocks base method
func (m *MockFullUpload) WriteChunk(offset int64, src io.Reader) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteChunk", offset, src)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteChunk indicates an expected call of WriteChunk
func (mr *MockFullUploadMockRecorder) WriteChunk(offset, src interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteChunk", reflect.TypeOf((*MockFullUpload)(nil).WriteChunk), offset, src)
}

// GetInfo mocks base method
func (m *MockFullUpload) GetInfo() (handler.FileInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInfo")
	ret0, _ := ret[0].(handler.FileInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetInfo indicates an expected call of GetInfo
func (mr *MockFullUploadMockRecorder) GetInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInfo", reflect.TypeOf((*MockFullUpload)(nil).GetInfo))
}

// GetReader mocks base method
func (m *MockFullUpload) GetReader() (io.Reader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReader")
	ret0, _ := ret[0].(io.Reader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReader indicates an expected call of GetReader
func (mr *MockFullUploadMockRecorder) GetReader() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReader", reflect.TypeOf((*MockFullUpload)(nil).GetReader))
}

// FinishUpload mocks base method
func (m *MockFullUpload) FinishUpload() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinishUpload")
	ret0, _ := ret[0].(error)
	return ret0
}

// FinishUpload indicates an expected call of FinishUpload
func (mr *MockFullUploadMockRecorder) FinishUpload() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishUpload", reflect.TypeOf((*MockFullUpload)(nil).FinishUpload))
}

// Terminate mocks base method
func (m *MockFullUpload) Terminate() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Terminate")
	ret0, _ := ret[0].(error)
	return ret0
}

// Terminate indicates an expected call of Terminate
func (mr *MockFullUploadMockRecorder) Terminate() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terminate", reflect.TypeOf((*MockFullUpload)(nil).Terminate))
}

// DeclareLength mocks base method
func (m *MockFullUpload) DeclareLength(length int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeclareLength", length)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeclareLength indicates an expected call of DeclareLength
func (mr *MockFullUploadMockRecorder) DeclareLength(length interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeclareLength", reflect.TypeOf((*MockFullUpload)(nil).DeclareLength), length)
}

// MockLocker is a mock of Locker interface
type MockLocker struct {
	ctrl     *gomock.Controller
	recorder *MockLockerMockRecorder
}

// MockLockerMockRecorder is the mock recorder for MockLocker
type MockLockerMockRecorder struct {
	mock *MockLocker
}

// NewMockLocker creates a new mock instance
func NewMockLocker(ctrl *gomock.Controller) *MockLocker {
	mock := &MockLocker{ctrl: ctrl}
	mock.recorder = &MockLockerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockLocker) EXPECT() *MockLockerMockRecorder {
	return m.recorder
}

// LockUpload mocks base method
func (m *MockLocker) LockUpload(id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockUpload", id)
	ret0, _ := ret[0].(error)
	return ret0
}

// LockUpload indicates an expected call of LockUpload
func (mr *MockLockerMockRecorder) LockUpload(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockUpload", reflect.TypeOf((*MockLocker)(nil).LockUpload), id)
}

// UnlockUpload mocks base method
func (m *MockLocker) UnlockUpload(id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnlockUpload", id)
	ret0, _ := ret[0].(error)
	return ret0
}

// UnlockUpload indicates an expected call of UnlockUpload
func (mr *MockLockerMockRecorder) UnlockUpload(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockUpload", reflect.TypeOf((*MockLocker)(nil).UnlockUpload), id)
}