range_manager.go

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

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	graveler "github.com/treeverse/lakefs/pkg/graveler"
	committed "github.com/treeverse/lakefs/pkg/graveler/committed"
)

// MockValueIterator is a mock of ValueIterator interface.
type MockValueIterator struct {
	ctrl     *gomock.Controller
	recorder *MockValueIteratorMockRecorder
}

// MockValueIteratorMockRecorder is the mock recorder for MockValueIterator.
type MockValueIteratorMockRecorder struct {
	mock *MockValueIterator
}

// NewMockValueIterator creates a new mock instance.
func NewMockValueIterator(ctrl *gomock.Controller) *MockValueIterator {
	mock := &MockValueIterator{ctrl: ctrl}
	mock.recorder = &MockValueIteratorMockRecorder{mock}
	return mock
}

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

// Close mocks base method.
func (m *MockValueIterator) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

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

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

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

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

// SeekGE mocks base method.
func (m *MockValueIterator) SeekGE(id committed.Key) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SeekGE", id)
}

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

// Value mocks base method.
func (m *MockValueIterator) Value() *committed.Record {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].(*committed.Record)
	return ret0
}

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

// MockRangeManager is a mock of RangeManager interface.
type MockRangeManager struct {
	ctrl     *gomock.Controller
	recorder *MockRangeManagerMockRecorder
}

// MockRangeManagerMockRecorder is the mock recorder for MockRangeManager.
type MockRangeManagerMockRecorder struct {
	mock *MockRangeManager
}

// NewMockRangeManager creates a new mock instance.
func NewMockRangeManager(ctrl *gomock.Controller) *MockRangeManager {
	mock := &MockRangeManager{ctrl: ctrl}
	mock.recorder = &MockRangeManagerMockRecorder{mock}
	return mock
}

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

// Exists mocks base method.
func (m *MockRangeManager) Exists(ctx context.Context, ns committed.Namespace, id committed.ID) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Exists", ctx, ns, id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Exists indicates an expected call of Exists.
func (mr *MockRangeManagerMockRecorder) Exists(ctx, ns, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockRangeManager)(nil).Exists), ctx, ns, id)
}

// GetURI mocks base method.
func (m *MockRangeManager) GetURI(ctx context.Context, ns committed.Namespace, id committed.ID) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetURI", ctx, ns, id)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetURI indicates an expected call of GetURI.
func (mr *MockRangeManagerMockRecorder) GetURI(ctx, ns, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetURI", reflect.TypeOf((*MockRangeManager)(nil).GetURI), ctx, ns, id)
}

// GetValue mocks base method.
func (m *MockRangeManager) GetValue(ctx context.Context, ns committed.Namespace, id committed.ID, key committed.Key) (*committed.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetValue", ctx, ns, id, key)
	ret0, _ := ret[0].(*committed.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetValue indicates an expected call of GetValue.
func (mr *MockRangeManagerMockRecorder) GetValue(ctx, ns, id, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValue", reflect.TypeOf((*MockRangeManager)(nil).GetValue), ctx, ns, id, key)
}

// GetValueGE mocks base method.
func (m *MockRangeManager) GetValueGE(ctx context.Context, ns committed.Namespace, id committed.ID, key committed.Key) (*committed.Record, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetValueGE", ctx, ns, id, key)
	ret0, _ := ret[0].(*committed.Record)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetValueGE indicates an expected call of GetValueGE.
func (mr *MockRangeManagerMockRecorder) GetValueGE(ctx, ns, id, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValueGE", reflect.TypeOf((*MockRangeManager)(nil).GetValueGE), ctx, ns, id, key)
}

// GetWriter mocks base method.
func (m *MockRangeManager) GetWriter(ctx context.Context, ns committed.Namespace, metadata graveler.Metadata) (committed.RangeWriter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWriter", ctx, ns, metadata)
	ret0, _ := ret[0].(committed.RangeWriter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWriter indicates an expected call of GetWriter.
func (mr *MockRangeManagerMockRecorder) GetWriter(ctx, ns, metadata interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWriter", reflect.TypeOf((*MockRangeManager)(nil).GetWriter), ctx, ns, metadata)
}

// NewRangeIterator mocks base method.
func (m *MockRangeManager) NewRangeIterator(ctx context.Context, ns committed.Namespace, pid committed.ID) (committed.ValueIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewRangeIterator", ctx, ns, pid)
	ret0, _ := ret[0].(committed.ValueIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewRangeIterator indicates an expected call of NewRangeIterator.
func (mr *MockRangeManagerMockRecorder) NewRangeIterator(ctx, ns, pid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewRangeIterator", reflect.TypeOf((*MockRangeManager)(nil).NewRangeIterator), ctx, ns, pid)
}

// MockRangeWriter is a mock of RangeWriter interface.
type MockRangeWriter struct {
	ctrl     *gomock.Controller
	recorder *MockRangeWriterMockRecorder
}

// MockRangeWriterMockRecorder is the mock recorder for MockRangeWriter.
type MockRangeWriterMockRecorder struct {
	mock *MockRangeWriter
}

// NewMockRangeWriter creates a new mock instance.
func NewMockRangeWriter(ctrl *gomock.Controller) *MockRangeWriter {
	mock := &MockRangeWriter{ctrl: ctrl}
	mock.recorder = &MockRangeWriterMockRecorder{mock}
	return mock
}

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

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

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

// Close mocks base method.
func (m *MockRangeWriter) Close() (*committed.WriteResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(*committed.WriteResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// SetMetadata mocks base method.
func (m *MockRangeWriter) SetMetadata(key, value string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMetadata", key, value)
}

// SetMetadata indicates an expected call of SetMetadata.
func (mr *MockRangeWriterMockRecorder) SetMetadata(key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockRangeWriter)(nil).SetMetadata), key, value)
}

// ShouldBreakAtKey mocks base method.
func (m *MockRangeWriter) ShouldBreakAtKey(key graveler.Key, params *committed.Params) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShouldBreakAtKey", key, params)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ShouldBreakAtKey indicates an expected call of ShouldBreakAtKey.
func (mr *MockRangeWriterMockRecorder) ShouldBreakAtKey(key, params interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldBreakAtKey", reflect.TypeOf((*MockRangeWriter)(nil).ShouldBreakAtKey), key, params)
}

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

// WriteRecord indicates an expected call of WriteRecord.
func (mr *MockRangeWriterMockRecorder) WriteRecord(record interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteRecord", reflect.TypeOf((*MockRangeWriter)(nil).WriteRecord), record)
}