// Code generated by MockGen. DO NOT EDIT.
// Source: git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/engine (interfaces: Engine,Consumer,MessageProcessor,PeriodicalWorker,RPCClient,RPCMessageProcessor)
//
// Generated by this command:
//
//	mockgen -destination=../../../mocks/lib/canopsis/engine/engine.go git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/engine Engine,Consumer,MessageProcessor,PeriodicalWorker,RPCClient,RPCMessageProcessor
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	engine "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/engine"
	amqp091 "github.com/rabbitmq/amqp091-go"
	gomock "go.uber.org/mock/gomock"
)

// MockEngine is a mock of Engine interface.
type MockEngine struct {
	ctrl     *gomock.Controller
	recorder *MockEngineMockRecorder
	isgomock struct{}
}

// MockEngineMockRecorder is the mock recorder for MockEngine.
type MockEngineMockRecorder struct {
	mock *MockEngine
}

// NewMockEngine creates a new mock instance.
func NewMockEngine(ctrl *gomock.Controller) *MockEngine {
	mock := &MockEngine{ctrl: ctrl}
	mock.recorder = &MockEngineMockRecorder{mock}
	return mock
}

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

// AddConsumer mocks base method.
func (m *MockEngine) AddConsumer(arg0 engine.Consumer) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddConsumer", arg0)
}

// AddConsumer indicates an expected call of AddConsumer.
func (mr *MockEngineMockRecorder) AddConsumer(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConsumer", reflect.TypeOf((*MockEngine)(nil).AddConsumer), arg0)
}

// AddDeferFunc mocks base method.
func (m *MockEngine) AddDeferFunc(deferFunc func(context.Context)) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddDeferFunc", deferFunc)
}

// AddDeferFunc indicates an expected call of AddDeferFunc.
func (mr *MockEngineMockRecorder) AddDeferFunc(deferFunc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDeferFunc", reflect.TypeOf((*MockEngine)(nil).AddDeferFunc), deferFunc)
}

// AddPeriodicalWorker mocks base method.
func (m *MockEngine) AddPeriodicalWorker(name string, worker engine.PeriodicalWorker) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddPeriodicalWorker", name, worker)
}

// AddPeriodicalWorker indicates an expected call of AddPeriodicalWorker.
func (mr *MockEngineMockRecorder) AddPeriodicalWorker(name, worker any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPeriodicalWorker", reflect.TypeOf((*MockEngine)(nil).AddPeriodicalWorker), name, worker)
}

// AddRoutine mocks base method.
func (m *MockEngine) AddRoutine(arg0 engine.Routine) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddRoutine", arg0)
}

// AddRoutine indicates an expected call of AddRoutine.
func (mr *MockEngineMockRecorder) AddRoutine(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRoutine", reflect.TypeOf((*MockEngine)(nil).AddRoutine), arg0)
}

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

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

// MockConsumer is a mock of Consumer interface.
type MockConsumer struct {
	ctrl     *gomock.Controller
	recorder *MockConsumerMockRecorder
	isgomock struct{}
}

// MockConsumerMockRecorder is the mock recorder for MockConsumer.
type MockConsumerMockRecorder struct {
	mock *MockConsumer
}

// NewMockConsumer creates a new mock instance.
func NewMockConsumer(ctrl *gomock.Controller) *MockConsumer {
	mock := &MockConsumer{ctrl: ctrl}
	mock.recorder = &MockConsumerMockRecorder{mock}
	return mock
}

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

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

// Consume indicates an expected call of Consume.
func (mr *MockConsumerMockRecorder) Consume(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Consume", reflect.TypeOf((*MockConsumer)(nil).Consume), arg0)
}

// MockMessageProcessor is a mock of MessageProcessor interface.
type MockMessageProcessor struct {
	ctrl     *gomock.Controller
	recorder *MockMessageProcessorMockRecorder
	isgomock struct{}
}

// MockMessageProcessorMockRecorder is the mock recorder for MockMessageProcessor.
type MockMessageProcessorMockRecorder struct {
	mock *MockMessageProcessor
}

// NewMockMessageProcessor creates a new mock instance.
func NewMockMessageProcessor(ctrl *gomock.Controller) *MockMessageProcessor {
	mock := &MockMessageProcessor{ctrl: ctrl}
	mock.recorder = &MockMessageProcessorMockRecorder{mock}
	return mock
}

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

// Process mocks base method.
func (m *MockMessageProcessor) Process(ctx context.Context, d amqp091.Delivery) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Process", ctx, d)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockPeriodicalWorker is a mock of PeriodicalWorker interface.
type MockPeriodicalWorker struct {
	ctrl     *gomock.Controller
	recorder *MockPeriodicalWorkerMockRecorder
	isgomock struct{}
}

// MockPeriodicalWorkerMockRecorder is the mock recorder for MockPeriodicalWorker.
type MockPeriodicalWorkerMockRecorder struct {
	mock *MockPeriodicalWorker
}

// NewMockPeriodicalWorker creates a new mock instance.
func NewMockPeriodicalWorker(ctrl *gomock.Controller) *MockPeriodicalWorker {
	mock := &MockPeriodicalWorker{ctrl: ctrl}
	mock.recorder = &MockPeriodicalWorkerMockRecorder{mock}
	return mock
}

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

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

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

// Work mocks base method.
func (m *MockPeriodicalWorker) Work(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Work", arg0)
}

// Work indicates an expected call of Work.
func (mr *MockPeriodicalWorkerMockRecorder) Work(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Work", reflect.TypeOf((*MockPeriodicalWorker)(nil).Work), arg0)
}

// MockRPCClient is a mock of RPCClient interface.
type MockRPCClient struct {
	ctrl     *gomock.Controller
	recorder *MockRPCClientMockRecorder
	isgomock struct{}
}

// MockRPCClientMockRecorder is the mock recorder for MockRPCClient.
type MockRPCClientMockRecorder struct {
	mock *MockRPCClient
}

// NewMockRPCClient creates a new mock instance.
func NewMockRPCClient(ctrl *gomock.Controller) *MockRPCClient {
	mock := &MockRPCClient{ctrl: ctrl}
	mock.recorder = &MockRPCClientMockRecorder{mock}
	return mock
}

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

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

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

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

// Consume indicates an expected call of Consume.
func (mr *MockRPCClientMockRecorder) Consume(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Consume", reflect.TypeOf((*MockRPCClient)(nil).Consume), arg0)
}

// MockRPCMessageProcessor is a mock of RPCMessageProcessor interface.
type MockRPCMessageProcessor struct {
	ctrl     *gomock.Controller
	recorder *MockRPCMessageProcessorMockRecorder
	isgomock struct{}
}

// MockRPCMessageProcessorMockRecorder is the mock recorder for MockRPCMessageProcessor.
type MockRPCMessageProcessorMockRecorder struct {
	mock *MockRPCMessageProcessor
}

// NewMockRPCMessageProcessor creates a new mock instance.
func NewMockRPCMessageProcessor(ctrl *gomock.Controller) *MockRPCMessageProcessor {
	mock := &MockRPCMessageProcessor{ctrl: ctrl}
	mock.recorder = &MockRPCMessageProcessorMockRecorder{mock}
	return mock
}

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

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

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