github.com/angryronald/go-kit@v0.0.0-20240505173814-ff2bd9c79dbf/generic/repository/generic.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: generic/repository/generic.interface.go

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

import (
	context "context"
	reflect "reflect"

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

// MockGenericRepositoryInterface is a mock of GenericRepositoryInterface interface.
type MockGenericRepositoryInterface struct {
	ctrl     *gomock.Controller
	recorder *MockGenericRepositoryInterfaceMockRecorder
}

// MockGenericRepositoryInterfaceMockRecorder is the mock recorder for MockGenericRepositoryInterface.
type MockGenericRepositoryInterfaceMockRecorder struct {
	mock *MockGenericRepositoryInterface
}

// NewMockGenericRepositoryInterface creates a new mock instance.
func NewMockGenericRepositoryInterface(ctrl *gomock.Controller) *MockGenericRepositoryInterface {
	mock := &MockGenericRepositoryInterface{ctrl: ctrl}
	mock.recorder = &MockGenericRepositoryInterfaceMockRecorder{mock}
	return mock
}

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

// BulkInsert mocks base method.
func (m *MockGenericRepositoryInterface) BulkInsert(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BulkInsert", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BulkUpsert mocks base method.
func (m *MockGenericRepositoryInterface) BulkUpsert(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BulkUpsert", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Delete mocks base method.
func (m *MockGenericRepositoryInterface) Delete(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FindAll mocks base method.
func (m *MockGenericRepositoryInterface) FindAll(ctx context.Context, params map[string]interface{}, conditionalOperations []ConditionalOperation, relationalOperations []RelationalOperation, page, limit int, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindAll", ctx, params, conditionalOperations, relationalOperations, page, limit, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindAll indicates an expected call of FindAll.
func (mr *MockGenericRepositoryInterfaceMockRecorder) FindAll(ctx, params, conditionalOperations, relationalOperations, page, limit, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAll", reflect.TypeOf((*MockGenericRepositoryInterface)(nil).FindAll), ctx, params, conditionalOperations, relationalOperations, page, limit, result)
}

// FindByID mocks base method.
func (m *MockGenericRepositoryInterface) FindByID(ctx context.Context, id uuid.UUID, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByID", ctx, id, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindByID indicates an expected call of FindByID.
func (mr *MockGenericRepositoryInterfaceMockRecorder) FindByID(ctx, id, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockGenericRepositoryInterface)(nil).FindByID), ctx, id, result)
}

// FindOne mocks base method.
func (m *MockGenericRepositoryInterface) FindOne(ctx context.Context, key string, value, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOne", ctx, key, value, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOne indicates an expected call of FindOne.
func (mr *MockGenericRepositoryInterfaceMockRecorder) FindOne(ctx, key, value, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOne", reflect.TypeOf((*MockGenericRepositoryInterface)(nil).FindOne), ctx, key, value, result)
}

// Insert mocks base method.
func (m *MockGenericRepositoryInterface) Insert(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Query mocks base method.
func (m *MockGenericRepositoryInterface) Query(ctx context.Context, query string, params []interface{}, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", ctx, query, params, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Query indicates an expected call of Query.
func (mr *MockGenericRepositoryInterfaceMockRecorder) Query(ctx, query, params, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockGenericRepositoryInterface)(nil).Query), ctx, query, params, result)
}

// Update mocks base method.
func (m *MockGenericRepositoryInterface) Update(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Upsert mocks base method.
func (m *MockGenericRepositoryInterface) Upsert(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upsert", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockImmutableGenericRepositoryInterface is a mock of ImmutableGenericRepositoryInterface interface.
type MockImmutableGenericRepositoryInterface struct {
	ctrl     *gomock.Controller
	recorder *MockImmutableGenericRepositoryInterfaceMockRecorder
}

// MockImmutableGenericRepositoryInterfaceMockRecorder is the mock recorder for MockImmutableGenericRepositoryInterface.
type MockImmutableGenericRepositoryInterfaceMockRecorder struct {
	mock *MockImmutableGenericRepositoryInterface
}

// NewMockImmutableGenericRepositoryInterface creates a new mock instance.
func NewMockImmutableGenericRepositoryInterface(ctrl *gomock.Controller) *MockImmutableGenericRepositoryInterface {
	mock := &MockImmutableGenericRepositoryInterface{ctrl: ctrl}
	mock.recorder = &MockImmutableGenericRepositoryInterfaceMockRecorder{mock}
	return mock
}

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

// BulkInsert mocks base method.
func (m *MockImmutableGenericRepositoryInterface) BulkInsert(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BulkInsert", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FindAll mocks base method.
func (m *MockImmutableGenericRepositoryInterface) FindAll(ctx context.Context, params map[string]interface{}, conditionalOperations []ConditionalOperation, relationalOperations []RelationalOperation, page, limit int, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindAll", ctx, params, conditionalOperations, relationalOperations, page, limit, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindAll indicates an expected call of FindAll.
func (mr *MockImmutableGenericRepositoryInterfaceMockRecorder) FindAll(ctx, params, conditionalOperations, relationalOperations, page, limit, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAll", reflect.TypeOf((*MockImmutableGenericRepositoryInterface)(nil).FindAll), ctx, params, conditionalOperations, relationalOperations, page, limit, result)
}

// FindByID mocks base method.
func (m *MockImmutableGenericRepositoryInterface) FindByID(ctx context.Context, id uuid.UUID, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByID", ctx, id, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindByID indicates an expected call of FindByID.
func (mr *MockImmutableGenericRepositoryInterfaceMockRecorder) FindByID(ctx, id, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockImmutableGenericRepositoryInterface)(nil).FindByID), ctx, id, result)
}

// FindOne mocks base method.
func (m *MockImmutableGenericRepositoryInterface) FindOne(ctx context.Context, key string, value, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOne", ctx, key, value, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOne indicates an expected call of FindOne.
func (mr *MockImmutableGenericRepositoryInterfaceMockRecorder) FindOne(ctx, key, value, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOne", reflect.TypeOf((*MockImmutableGenericRepositoryInterface)(nil).FindOne), ctx, key, value, result)
}

// Insert mocks base method.
func (m *MockImmutableGenericRepositoryInterface) Insert(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Query mocks base method.
func (m *MockImmutableGenericRepositoryInterface) Query(ctx context.Context, query string, params []interface{}, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", ctx, query, params, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Query indicates an expected call of Query.
func (mr *MockImmutableGenericRepositoryInterfaceMockRecorder) Query(ctx, query, params, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockImmutableGenericRepositoryInterface)(nil).Query), ctx, query, params, result)
}

// MockMutableGenericRepositoryInterface is a mock of MutableGenericRepositoryInterface interface.
type MockMutableGenericRepositoryInterface struct {
	ctrl     *gomock.Controller
	recorder *MockMutableGenericRepositoryInterfaceMockRecorder
}

// MockMutableGenericRepositoryInterfaceMockRecorder is the mock recorder for MockMutableGenericRepositoryInterface.
type MockMutableGenericRepositoryInterfaceMockRecorder struct {
	mock *MockMutableGenericRepositoryInterface
}

// NewMockMutableGenericRepositoryInterface creates a new mock instance.
func NewMockMutableGenericRepositoryInterface(ctrl *gomock.Controller) *MockMutableGenericRepositoryInterface {
	mock := &MockMutableGenericRepositoryInterface{ctrl: ctrl}
	mock.recorder = &MockMutableGenericRepositoryInterfaceMockRecorder{mock}
	return mock
}

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

// BulkUpsert mocks base method.
func (m *MockMutableGenericRepositoryInterface) BulkUpsert(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BulkUpsert", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Delete mocks base method.
func (m *MockMutableGenericRepositoryInterface) Delete(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FindAll mocks base method.
func (m *MockMutableGenericRepositoryInterface) FindAll(ctx context.Context, params map[string]interface{}, conditionalOperations []ConditionalOperation, relationalOperations []RelationalOperation, page, limit int, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindAll", ctx, params, conditionalOperations, relationalOperations, page, limit, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindAll indicates an expected call of FindAll.
func (mr *MockMutableGenericRepositoryInterfaceMockRecorder) FindAll(ctx, params, conditionalOperations, relationalOperations, page, limit, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindAll", reflect.TypeOf((*MockMutableGenericRepositoryInterface)(nil).FindAll), ctx, params, conditionalOperations, relationalOperations, page, limit, result)
}

// FindByID mocks base method.
func (m *MockMutableGenericRepositoryInterface) FindByID(ctx context.Context, id uuid.UUID, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByID", ctx, id, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindByID indicates an expected call of FindByID.
func (mr *MockMutableGenericRepositoryInterfaceMockRecorder) FindByID(ctx, id, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindByID", reflect.TypeOf((*MockMutableGenericRepositoryInterface)(nil).FindByID), ctx, id, result)
}

// FindOne mocks base method.
func (m *MockMutableGenericRepositoryInterface) FindOne(ctx context.Context, key string, value, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOne", ctx, key, value, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOne indicates an expected call of FindOne.
func (mr *MockMutableGenericRepositoryInterfaceMockRecorder) FindOne(ctx, key, value, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOne", reflect.TypeOf((*MockMutableGenericRepositoryInterface)(nil).FindOne), ctx, key, value, result)
}

// Insert mocks base method.
func (m *MockMutableGenericRepositoryInterface) Insert(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Query mocks base method.
func (m *MockMutableGenericRepositoryInterface) Query(ctx context.Context, query string, params []interface{}, result interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", ctx, query, params, result)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Query indicates an expected call of Query.
func (mr *MockMutableGenericRepositoryInterfaceMockRecorder) Query(ctx, query, params, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockMutableGenericRepositoryInterface)(nil).Query), ctx, query, params, result)
}

// Update mocks base method.
func (m *MockMutableGenericRepositoryInterface) Update(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Upsert mocks base method.
func (m *MockMutableGenericRepositoryInterface) Upsert(ctx context.Context, data interface{}) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upsert", ctx, data)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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