mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: store.go
//
// Generated by this command:
//
//	mockgen -destination=mock.go -package stoabs -source=store.go
//

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

import (
	context "context"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockKVStore is a mock of KVStore interface.
type MockKVStore struct {
	ctrl     *gomock.Controller
	recorder *MockKVStoreMockRecorder
	isgomock struct{}
}

// MockKVStoreMockRecorder is the mock recorder for MockKVStore.
type MockKVStoreMockRecorder struct {
	mock *MockKVStore
}

// NewMockKVStore creates a new mock instance.
func NewMockKVStore(ctrl *gomock.Controller) *MockKVStore {
	mock := &MockKVStore{ctrl: ctrl}
	mock.recorder = &MockKVStoreMockRecorder{mock}
	return mock
}

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

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

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

// Read mocks base method.
func (m *MockKVStore) Read(ctx context.Context, fn func(ReadTx) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// Read indicates an expected call of Read.
func (mr *MockKVStoreMockRecorder) Read(ctx, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockKVStore)(nil).Read), ctx, fn)
}

// ReadShelf mocks base method.
func (m *MockKVStore) ReadShelf(ctx context.Context, shelfName string, fn func(Reader) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadShelf", ctx, shelfName, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReadShelf indicates an expected call of ReadShelf.
func (mr *MockKVStoreMockRecorder) ReadShelf(ctx, shelfName, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadShelf", reflect.TypeOf((*MockKVStore)(nil).ReadShelf), ctx, shelfName, fn)
}

// Write mocks base method.
func (m *MockKVStore) Write(ctx context.Context, fn func(WriteTx) error, opts ...TxOption) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, fn}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Write", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockKVStoreMockRecorder) Write(ctx, fn any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, fn}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockKVStore)(nil).Write), varargs...)
}

// WriteShelf mocks base method.
func (m *MockKVStore) WriteShelf(ctx context.Context, shelfName string, fn func(Writer) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteShelf", ctx, shelfName, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteShelf indicates an expected call of WriteShelf.
func (mr *MockKVStoreMockRecorder) WriteShelf(ctx, shelfName, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteShelf", reflect.TypeOf((*MockKVStore)(nil).WriteShelf), ctx, shelfName, fn)
}

// MockReader is a mock of Reader interface.
type MockReader struct {
	ctrl     *gomock.Controller
	recorder *MockReaderMockRecorder
	isgomock struct{}
}

// MockReaderMockRecorder is the mock recorder for MockReader.
type MockReaderMockRecorder struct {
	mock *MockReader
}

// NewMockReader creates a new mock instance.
func NewMockReader(ctrl *gomock.Controller) *MockReader {
	mock := &MockReader{ctrl: ctrl}
	mock.recorder = &MockReaderMockRecorder{mock}
	return mock
}

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

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

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

// Get mocks base method.
func (m *MockReader) Get(key Key) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockReaderMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockReader)(nil).Get), key)
}

// Iterate mocks base method.
func (m *MockReader) Iterate(callback CallerFn, keyType Key) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Iterate", callback, keyType)
	ret0, _ := ret[0].(error)
	return ret0
}

// Iterate indicates an expected call of Iterate.
func (mr *MockReaderMockRecorder) Iterate(callback, keyType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockReader)(nil).Iterate), callback, keyType)
}

// Range mocks base method.
func (m *MockReader) Range(from, to Key, callback CallerFn, stopAtNil bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Range", from, to, callback, stopAtNil)
	ret0, _ := ret[0].(error)
	return ret0
}

// Range indicates an expected call of Range.
func (mr *MockReaderMockRecorder) Range(from, to, callback, stopAtNil any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Range", reflect.TypeOf((*MockReader)(nil).Range), from, to, callback, stopAtNil)
}

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

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

// MockWriter is a mock of Writer interface.
type MockWriter struct {
	ctrl     *gomock.Controller
	recorder *MockWriterMockRecorder
	isgomock struct{}
}

// MockWriterMockRecorder is the mock recorder for MockWriter.
type MockWriterMockRecorder struct {
	mock *MockWriter
}

// NewMockWriter creates a new mock instance.
func NewMockWriter(ctrl *gomock.Controller) *MockWriter {
	mock := &MockWriter{ctrl: ctrl}
	mock.recorder = &MockWriterMockRecorder{mock}
	return mock
}

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

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

// Delete indicates an expected call of Delete.
func (mr *MockWriterMockRecorder) Delete(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockWriter)(nil).Delete), key)
}

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

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

// Get mocks base method.
func (m *MockWriter) Get(key Key) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockWriterMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockWriter)(nil).Get), key)
}

// Iterate mocks base method.
func (m *MockWriter) Iterate(callback CallerFn, keyType Key) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Iterate", callback, keyType)
	ret0, _ := ret[0].(error)
	return ret0
}

// Iterate indicates an expected call of Iterate.
func (mr *MockWriterMockRecorder) Iterate(callback, keyType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockWriter)(nil).Iterate), callback, keyType)
}

// Put mocks base method.
func (m *MockWriter) Put(key Key, value []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", key, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// Put indicates an expected call of Put.
func (mr *MockWriterMockRecorder) Put(key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockWriter)(nil).Put), key, value)
}

// Range mocks base method.
func (m *MockWriter) Range(from, to Key, callback CallerFn, stopAtNil bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Range", from, to, callback, stopAtNil)
	ret0, _ := ret[0].(error)
	return ret0
}

// Range indicates an expected call of Range.
func (mr *MockWriterMockRecorder) Range(from, to, callback, stopAtNil any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Range", reflect.TypeOf((*MockWriter)(nil).Range), from, to, callback, stopAtNil)
}

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

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

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
	isgomock struct{}
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

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

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

// MockTxOption is a mock of TxOption interface.
type MockTxOption struct {
	ctrl     *gomock.Controller
	recorder *MockTxOptionMockRecorder
	isgomock struct{}
}

// MockTxOptionMockRecorder is the mock recorder for MockTxOption.
type MockTxOptionMockRecorder struct {
	mock *MockTxOption
}

// NewMockTxOption creates a new mock instance.
func NewMockTxOption(ctrl *gomock.Controller) *MockTxOption {
	mock := &MockTxOption{ctrl: ctrl}
	mock.recorder = &MockTxOptionMockRecorder{mock}
	return mock
}

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

// MockWriteTx is a mock of WriteTx interface.
type MockWriteTx struct {
	ctrl     *gomock.Controller
	recorder *MockWriteTxMockRecorder
	isgomock struct{}
}

// MockWriteTxMockRecorder is the mock recorder for MockWriteTx.
type MockWriteTxMockRecorder struct {
	mock *MockWriteTx
}

// NewMockWriteTx creates a new mock instance.
func NewMockWriteTx(ctrl *gomock.Controller) *MockWriteTx {
	mock := &MockWriteTx{ctrl: ctrl}
	mock.recorder = &MockWriteTxMockRecorder{mock}
	return mock
}

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

// GetShelfReader mocks base method.
func (m *MockWriteTx) GetShelfReader(shelfName string) Reader {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShelfReader", shelfName)
	ret0, _ := ret[0].(Reader)
	return ret0
}

// GetShelfReader indicates an expected call of GetShelfReader.
func (mr *MockWriteTxMockRecorder) GetShelfReader(shelfName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShelfReader", reflect.TypeOf((*MockWriteTx)(nil).GetShelfReader), shelfName)
}

// GetShelfWriter mocks base method.
func (m *MockWriteTx) GetShelfWriter(shelfName string) Writer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShelfWriter", shelfName)
	ret0, _ := ret[0].(Writer)
	return ret0
}

// GetShelfWriter indicates an expected call of GetShelfWriter.
func (mr *MockWriteTxMockRecorder) GetShelfWriter(shelfName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShelfWriter", reflect.TypeOf((*MockWriteTx)(nil).GetShelfWriter), shelfName)
}

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

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

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

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

// MockReadTx is a mock of ReadTx interface.
type MockReadTx struct {
	ctrl     *gomock.Controller
	recorder *MockReadTxMockRecorder
	isgomock struct{}
}

// MockReadTxMockRecorder is the mock recorder for MockReadTx.
type MockReadTxMockRecorder struct {
	mock *MockReadTx
}

// NewMockReadTx creates a new mock instance.
func NewMockReadTx(ctrl *gomock.Controller) *MockReadTx {
	mock := &MockReadTx{ctrl: ctrl}
	mock.recorder = &MockReadTxMockRecorder{mock}
	return mock
}

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

// GetShelfReader mocks base method.
func (m *MockReadTx) GetShelfReader(shelfName string) Reader {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShelfReader", shelfName)
	ret0, _ := ret[0].(Reader)
	return ret0
}

// GetShelfReader indicates an expected call of GetShelfReader.
func (mr *MockReadTxMockRecorder) GetShelfReader(shelfName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShelfReader", reflect.TypeOf((*MockReadTx)(nil).GetShelfReader), shelfName)
}

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

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

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

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