// Code generated by MockGen. DO NOT EDIT.
package eventbus

import (
	sql "database/sql"
	reflect "reflect"
	time "time"

	prometheus "github.com/prometheus/client_golang/prometheus"
	tieventbus "github.com/tidbcloud/tiinf/transport/tieventbus"
	"go.uber.org/mock/gomock"
)

func NewMockEventBusService(ctrl *gomock.Controller) *EventbusService {
	mock := &MockEventbus{ctrl: ctrl}
	mock.recorder = &MockEventbusMockRecorder{mock}
	return &EventbusService{mock}
}

func (m *EventbusService) EXPECT() *MockEventbusMockRecorder {
	return m.Eventbus.(*MockEventbus).recorder
}

// MockEventbus is a mock of Eventbus interface.
type MockEventbus struct {
	ctrl     *gomock.Controller
	recorder *MockEventbusMockRecorder
}

// MockEventbusMockRecorder is the mock recorder for MockEventbus.
type MockEventbusMockRecorder struct {
	mock *MockEventbus
}

// NewMockEventbus creates a new mock instance.
func NewMockEventbus(ctrl *gomock.Controller) *MockEventbus {
	mock := &MockEventbus{ctrl: ctrl}
	mock.recorder = &MockEventbusMockRecorder{mock}
	return mock
}

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

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

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

// EnableMetrics mocks base method.
func (m *MockEventbus) EnableMetrics(prometheusRegistry prometheus.Registerer, namespace, subsystem string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EnableMetrics", prometheusRegistry, namespace, subsystem)
}

// EnableMetrics indicates an expected call of EnableMetrics.
func (mr *MockEventbusMockRecorder) EnableMetrics(prometheusRegistry, namespace, subsystem any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(
		mr.mock,
		"EnableMetrics",
		reflect.TypeOf((*MockEventbus)(nil).EnableMetrics),
		prometheusRegistry,
		namespace,
		subsystem,
	)
}

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

// FixDLQ indicates an expected call of FixDLQ.
func (mr *MockEventbusMockRecorder) FixDLQ(timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(
		mr.mock,
		"FixDLQ",
		reflect.TypeOf((*MockEventbus)(nil).FixDLQ),
		timeout,
	)
}

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

// Publish indicates an expected call of Publish.
func (mr *MockEventbusMockRecorder) Publish(event any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(
		mr.mock,
		"Publish",
		reflect.TypeOf((*MockEventbus)(nil).Publish),
		event,
	)
}

// PublishAsync mocks base method.
func (m *MockEventbus) PublishAsync(event *tieventbus.Event) *tieventbus.AsyncResult {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishAsync", event)
	ret0, _ := ret[0].(*tieventbus.AsyncResult)
	return ret0
}

// PublishAsync indicates an expected call of PublishAsync.
func (mr *MockEventbusMockRecorder) PublishAsync(event any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(
		mr.mock,
		"PublishAsync",
		reflect.TypeOf((*MockEventbus)(nil).PublishAsync),
		event,
	)
}

// PublishWithDBTx mocks base method.
func (m *MockEventbus) PublishWithDBTx(tx *sql.Tx, event *tieventbus.Event) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishWithDBTx", tx, event)
	ret0, _ := ret[0].(error)
	return ret0
}

// PublishWithDBTx indicates an expected call of PublishWithDBTx.
func (mr *MockEventbusMockRecorder) PublishWithDBTx(tx, event any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(
		mr.mock,
		"PublishWithDBTx",
		reflect.TypeOf((*MockEventbus)(nil).PublishWithDBTx),
		tx,
		event,
	)
}

// RegisterHandler mocks base method.
func (m *MockEventbus) RegisterHandler(config tieventbus.HandlerConfig) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterHandler", config)
}

// RegisterHandler indicates an expected call of RegisterHandler.
func (mr *MockEventbusMockRecorder) RegisterHandler(config any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(
		mr.mock,
		"RegisterHandler",
		reflect.TypeOf((*MockEventbus)(nil).RegisterHandler),
		config,
	)
}

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

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

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

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

// Running mocks base method.
func (m *MockEventbus) Running() chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Running")
	ret0, _ := ret[0].(chan struct{})
	return ret0
}

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