mock_rsources.go

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

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

import (
	context "context"
	sql "database/sql"
	json "encoding/json"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockStatsIncrementer is a mock of StatsIncrementer interface.
type MockStatsIncrementer struct {
	ctrl     *gomock.Controller
	recorder *MockStatsIncrementerMockRecorder
}

// MockStatsIncrementerMockRecorder is the mock recorder for MockStatsIncrementer.
type MockStatsIncrementerMockRecorder struct {
	mock *MockStatsIncrementer
}

// NewMockStatsIncrementer creates a new mock instance.
func NewMockStatsIncrementer(ctrl *gomock.Controller) *MockStatsIncrementer {
	mock := &MockStatsIncrementer{ctrl: ctrl}
	mock.recorder = &MockStatsIncrementerMockRecorder{mock}
	return mock
}

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

// IncrementStats mocks base method.
func (m *MockStatsIncrementer) IncrementStats(ctx context.Context, tx *sql.Tx, jobRunId string, key JobTargetKey, stats Stats) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementStats", ctx, tx, jobRunId, key, stats)
	ret0, _ := ret[0].(error)
	return ret0
}

// IncrementStats indicates an expected call of IncrementStats.
func (mr *MockStatsIncrementerMockRecorder) IncrementStats(ctx, tx, jobRunId, key, stats interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementStats", reflect.TypeOf((*MockStatsIncrementer)(nil).IncrementStats), ctx, tx, jobRunId, key, stats)
}

// MockJobService is a mock of JobService interface.
type MockJobService struct {
	ctrl     *gomock.Controller
	recorder *MockJobServiceMockRecorder
}

// MockJobServiceMockRecorder is the mock recorder for MockJobService.
type MockJobServiceMockRecorder struct {
	mock *MockJobService
}

// NewMockJobService creates a new mock instance.
func NewMockJobService(ctrl *gomock.Controller) *MockJobService {
	mock := &MockJobService{ctrl: ctrl}
	mock.recorder = &MockJobServiceMockRecorder{mock}
	return mock
}

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

// AddFailedRecords mocks base method.
func (m *MockJobService) AddFailedRecords(ctx context.Context, tx *sql.Tx, jobRunId string, key JobTargetKey, records []json.RawMessage) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddFailedRecords", ctx, tx, jobRunId, key, records)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddFailedRecords indicates an expected call of AddFailedRecords.
func (mr *MockJobServiceMockRecorder) AddFailedRecords(ctx, tx, jobRunId, key, records interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFailedRecords", reflect.TypeOf((*MockJobService)(nil).AddFailedRecords), ctx, tx, jobRunId, key, records)
}

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

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

// Delete mocks base method.
func (m *MockJobService) Delete(ctx context.Context, jobRunId string, filter JobFilter) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, jobRunId, filter)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockJobServiceMockRecorder) Delete(ctx, jobRunId, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockJobService)(nil).Delete), ctx, jobRunId, filter)
}

// GetFailedRecords mocks base method.
func (m *MockJobService) GetFailedRecords(ctx context.Context, jobRunId string, filter JobFilter) (JobFailedRecords, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFailedRecords", ctx, jobRunId, filter)
	ret0, _ := ret[0].(JobFailedRecords)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFailedRecords indicates an expected call of GetFailedRecords.
func (mr *MockJobServiceMockRecorder) GetFailedRecords(ctx, jobRunId, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFailedRecords", reflect.TypeOf((*MockJobService)(nil).GetFailedRecords), ctx, jobRunId, filter)
}

// GetStatus mocks base method.
func (m *MockJobService) GetStatus(ctx context.Context, jobRunId string, filter JobFilter) (JobStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatus", ctx, jobRunId, filter)
	ret0, _ := ret[0].(JobStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetStatus indicates an expected call of GetStatus.
func (mr *MockJobServiceMockRecorder) GetStatus(ctx, jobRunId, filter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatus", reflect.TypeOf((*MockJobService)(nil).GetStatus), ctx, jobRunId, filter)
}

// IncrementStats mocks base method.
func (m *MockJobService) IncrementStats(ctx context.Context, tx *sql.Tx, jobRunId string, key JobTargetKey, stats Stats) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementStats", ctx, tx, jobRunId, key, stats)
	ret0, _ := ret[0].(error)
	return ret0
}

// IncrementStats indicates an expected call of IncrementStats.
func (mr *MockJobServiceMockRecorder) IncrementStats(ctx, tx, jobRunId, key, stats interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementStats", reflect.TypeOf((*MockJobService)(nil).IncrementStats), ctx, tx, jobRunId, key, stats)
}

// Monitor mocks base method.
func (m *MockJobService) Monitor(ctx context.Context, lagGauge, replicationSlotGauge Gauger) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Monitor", ctx, lagGauge, replicationSlotGauge)
}

// Monitor indicates an expected call of Monitor.
func (mr *MockJobServiceMockRecorder) Monitor(ctx, lagGauge, replicationSlotGauge interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Monitor", reflect.TypeOf((*MockJobService)(nil).Monitor), ctx, lagGauge, replicationSlotGauge)
}

// MockGauger is a mock of Gauger interface.
type MockGauger struct {
	ctrl     *gomock.Controller
	recorder *MockGaugerMockRecorder
}

// MockGaugerMockRecorder is the mock recorder for MockGauger.
type MockGaugerMockRecorder struct {
	mock *MockGauger
}

// NewMockGauger creates a new mock instance.
func NewMockGauger(ctrl *gomock.Controller) *MockGauger {
	mock := &MockGauger{ctrl: ctrl}
	mock.recorder = &MockGaugerMockRecorder{mock}
	return mock
}

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

// Gauge mocks base method.
func (m *MockGauger) Gauge(arg0 interface{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Gauge", arg0)
}

// Gauge indicates an expected call of Gauge.
func (mr *MockGaugerMockRecorder) Gauge(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Gauge", reflect.TypeOf((*MockGauger)(nil).Gauge), arg0)
}