github.com/matrixorigin/matrixone@v0.7.0/pkg/frontend/test/txn_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ../../../pkg/txn/client/types.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	txn "github.com/matrixorigin/matrixone/pkg/pb/txn"
	client "github.com/matrixorigin/matrixone/pkg/txn/client"
	rpc "github.com/matrixorigin/matrixone/pkg/txn/rpc"
)

// MockTxnClient is a mock of TxnClient interface.
type MockTxnClient struct {
	ctrl     *gomock.Controller
	recorder *MockTxnClientMockRecorder
}

// MockTxnClientMockRecorder is the mock recorder for MockTxnClient.
type MockTxnClientMockRecorder struct {
	mock *MockTxnClient
}

// NewMockTxnClient creates a new mock instance.
func NewMockTxnClient(ctrl *gomock.Controller) *MockTxnClient {
	mock := &MockTxnClient{ctrl: ctrl}
	mock.recorder = &MockTxnClientMockRecorder{mock}
	return mock
}

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

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

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

// New mocks base method.
func (m *MockTxnClient) New(options ...client.TxnOption) (client.TxnOperator, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "New", varargs...)
	ret0, _ := ret[0].(client.TxnOperator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// New indicates an expected call of New.
func (mr *MockTxnClientMockRecorder) New(options ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockTxnClient)(nil).New), options...)
}

// NewWithSnapshot mocks base method.
func (m *MockTxnClient) NewWithSnapshot(snapshot []byte) (client.TxnOperator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewWithSnapshot", snapshot)
	ret0, _ := ret[0].(client.TxnOperator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewWithSnapshot indicates an expected call of NewWithSnapshot.
func (mr *MockTxnClientMockRecorder) NewWithSnapshot(snapshot interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewWithSnapshot", reflect.TypeOf((*MockTxnClient)(nil).NewWithSnapshot), snapshot)
}

// MockTxnOperator is a mock of TxnOperator interface.
type MockTxnOperator struct {
	ctrl     *gomock.Controller
	recorder *MockTxnOperatorMockRecorder
}

// MockTxnOperatorMockRecorder is the mock recorder for MockTxnOperator.
type MockTxnOperatorMockRecorder struct {
	mock *MockTxnOperator
}

// NewMockTxnOperator creates a new mock instance.
func NewMockTxnOperator(ctrl *gomock.Controller) *MockTxnOperator {
	mock := &MockTxnOperator{ctrl: ctrl}
	mock.recorder = &MockTxnOperatorMockRecorder{mock}
	return mock
}

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

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

// ApplySnapshot indicates an expected call of ApplySnapshot.
func (mr *MockTxnOperatorMockRecorder) ApplySnapshot(data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySnapshot", reflect.TypeOf((*MockTxnOperator)(nil).ApplySnapshot), data)
}

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

// Commit indicates an expected call of Commit.
func (mr *MockTxnOperatorMockRecorder) Commit(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockTxnOperator)(nil).Commit), ctx)
}

// Read mocks base method.
func (m *MockTxnOperator) Read(ctx context.Context, ops []txn.TxnRequest) (*rpc.SendResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, ops)
	ret0, _ := ret[0].(*rpc.SendResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockTxnOperatorMockRecorder) Read(ctx, ops interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockTxnOperator)(nil).Read), ctx, ops)
}

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

// Rollback indicates an expected call of Rollback.
func (mr *MockTxnOperatorMockRecorder) Rollback(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockTxnOperator)(nil).Rollback), ctx)
}

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

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

// Txn mocks base method.
func (m *MockTxnOperator) Txn() txn.TxnMeta {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Txn")
	ret0, _ := ret[0].(txn.TxnMeta)
	return ret0
}

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

// Write mocks base method.
func (m *MockTxnOperator) Write(ctx context.Context, ops []txn.TxnRequest) (*rpc.SendResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", ctx, ops)
	ret0, _ := ret[0].(*rpc.SendResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockTxnOperatorMockRecorder) Write(ctx, ops interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockTxnOperator)(nil).Write), ctx, ops)
}

// WriteAndCommit mocks base method.
func (m *MockTxnOperator) WriteAndCommit(ctx context.Context, ops []txn.TxnRequest) (*rpc.SendResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteAndCommit", ctx, ops)
	ret0, _ := ret[0].(*rpc.SendResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteAndCommit indicates an expected call of WriteAndCommit.
func (mr *MockTxnOperatorMockRecorder) WriteAndCommit(ctx, ops interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAndCommit", reflect.TypeOf((*MockTxnOperator)(nil).WriteAndCommit), ctx, ops)
}

// MockDebugableTxnOperator is a mock of DebugableTxnOperator interface.
type MockDebugableTxnOperator struct {
	ctrl     *gomock.Controller
	recorder *MockDebugableTxnOperatorMockRecorder
}

// MockDebugableTxnOperatorMockRecorder is the mock recorder for MockDebugableTxnOperator.
type MockDebugableTxnOperatorMockRecorder struct {
	mock *MockDebugableTxnOperator
}

// NewMockDebugableTxnOperator creates a new mock instance.
func NewMockDebugableTxnOperator(ctrl *gomock.Controller) *MockDebugableTxnOperator {
	mock := &MockDebugableTxnOperator{ctrl: ctrl}
	mock.recorder = &MockDebugableTxnOperatorMockRecorder{mock}
	return mock
}

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

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

// ApplySnapshot indicates an expected call of ApplySnapshot.
func (mr *MockDebugableTxnOperatorMockRecorder) ApplySnapshot(data interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySnapshot", reflect.TypeOf((*MockDebugableTxnOperator)(nil).ApplySnapshot), data)
}

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

// Commit indicates an expected call of Commit.
func (mr *MockDebugableTxnOperatorMockRecorder) Commit(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockDebugableTxnOperator)(nil).Commit), ctx)
}

// Debug mocks base method.
func (m *MockDebugableTxnOperator) Debug(ctx context.Context, ops []txn.TxnRequest) (*rpc.SendResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Debug", ctx, ops)
	ret0, _ := ret[0].(*rpc.SendResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Debug indicates an expected call of Debug.
func (mr *MockDebugableTxnOperatorMockRecorder) Debug(ctx, ops interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockDebugableTxnOperator)(nil).Debug), ctx, ops)
}

// Read mocks base method.
func (m *MockDebugableTxnOperator) Read(ctx context.Context, ops []txn.TxnRequest) (*rpc.SendResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", ctx, ops)
	ret0, _ := ret[0].(*rpc.SendResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockDebugableTxnOperatorMockRecorder) Read(ctx, ops interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockDebugableTxnOperator)(nil).Read), ctx, ops)
}

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

// Rollback indicates an expected call of Rollback.
func (mr *MockDebugableTxnOperatorMockRecorder) Rollback(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rollback", reflect.TypeOf((*MockDebugableTxnOperator)(nil).Rollback), ctx)
}

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

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

// Txn mocks base method.
func (m *MockDebugableTxnOperator) Txn() txn.TxnMeta {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Txn")
	ret0, _ := ret[0].(txn.TxnMeta)
	return ret0
}

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

// Write mocks base method.
func (m *MockDebugableTxnOperator) Write(ctx context.Context, ops []txn.TxnRequest) (*rpc.SendResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", ctx, ops)
	ret0, _ := ret[0].(*rpc.SendResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockDebugableTxnOperatorMockRecorder) Write(ctx, ops interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockDebugableTxnOperator)(nil).Write), ctx, ops)
}

// WriteAndCommit mocks base method.
func (m *MockDebugableTxnOperator) WriteAndCommit(ctx context.Context, ops []txn.TxnRequest) (*rpc.SendResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteAndCommit", ctx, ops)
	ret0, _ := ret[0].(*rpc.SendResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WriteAndCommit indicates an expected call of WriteAndCommit.
func (mr *MockDebugableTxnOperatorMockRecorder) WriteAndCommit(ctx, ops interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAndCommit", reflect.TypeOf((*MockDebugableTxnOperator)(nil).WriteAndCommit), ctx, ops)
}

// MockTxnIDGenerator is a mock of TxnIDGenerator interface.
type MockTxnIDGenerator struct {
	ctrl     *gomock.Controller
	recorder *MockTxnIDGeneratorMockRecorder
}

// MockTxnIDGeneratorMockRecorder is the mock recorder for MockTxnIDGenerator.
type MockTxnIDGeneratorMockRecorder struct {
	mock *MockTxnIDGenerator
}

// NewMockTxnIDGenerator creates a new mock instance.
func NewMockTxnIDGenerator(ctrl *gomock.Controller) *MockTxnIDGenerator {
	mock := &MockTxnIDGenerator{ctrl: ctrl}
	mock.recorder = &MockTxnIDGeneratorMockRecorder{mock}
	return mock
}

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

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

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