perms-system-server/internal/testutil/mocks/mock_userrole_model.go

// Code generated by MockGen. DO NOT EDIT.
// Source: internal/model/userrole/sysUserRoleModel.go
//
// Generated by this command:
//
//	mockgen -source=internal/model/userrole/sysUserRoleModel.go -destination=internal/testutil/mocks/mock_userrole_model.go -package=mocks
//

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

import (
	context "context"
	sql "database/sql"
	userrole "perms-system-server/internal/model/userrole"
	reflect "reflect"

	sqlx "github.com/zeromicro/go-zero/core/stores/sqlx"
	gomock "go.uber.org/mock/gomock"
)

// MockSysUserRoleModel is a mock of SysUserRoleModel interface.
type MockSysUserRoleModel struct {
	ctrl     *gomock.Controller
	recorder *MockSysUserRoleModelMockRecorder
	isgomock struct{}
}

// MockSysUserRoleModelMockRecorder is the mock recorder for MockSysUserRoleModel.
type MockSysUserRoleModelMockRecorder struct {
	mock *MockSysUserRoleModel
}

// NewMockSysUserRoleModel creates a new mock instance.
func NewMockSysUserRoleModel(ctrl *gomock.Controller) *MockSysUserRoleModel {
	mock := &MockSysUserRoleModel{ctrl: ctrl}
	mock.recorder = &MockSysUserRoleModelMockRecorder{mock}
	return mock
}

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

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

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

// BatchDeleteWithTx mocks base method.
func (m *MockSysUserRoleModel) BatchDeleteWithTx(ctx context.Context, session sqlx.Session, ids []int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchDeleteWithTx", ctx, session, ids)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchDeleteWithTx indicates an expected call of BatchDeleteWithTx.
func (mr *MockSysUserRoleModelMockRecorder) BatchDeleteWithTx(ctx, session, ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteWithTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).BatchDeleteWithTx), ctx, session, ids)
}

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

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

// BatchInsertWithTx mocks base method.
func (m *MockSysUserRoleModel) BatchInsertWithTx(ctx context.Context, session sqlx.Session, dataList []*userrole.SysUserRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchInsertWithTx", ctx, session, dataList)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchInsertWithTx indicates an expected call of BatchInsertWithTx.
func (mr *MockSysUserRoleModelMockRecorder) BatchInsertWithTx(ctx, session, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchInsertWithTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).BatchInsertWithTx), ctx, session, dataList)
}

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

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

// BatchUpdateWithTx mocks base method.
func (m *MockSysUserRoleModel) BatchUpdateWithTx(ctx context.Context, session sqlx.Session, dataList []*userrole.SysUserRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BatchUpdateWithTx", ctx, session, dataList)
	ret0, _ := ret[0].(error)
	return ret0
}

// BatchUpdateWithTx indicates an expected call of BatchUpdateWithTx.
func (mr *MockSysUserRoleModelMockRecorder) BatchUpdateWithTx(ctx, session, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdateWithTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).BatchUpdateWithTx), ctx, session, dataList)
}

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

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

// DeleteByRoleIdTx mocks base method.
func (m *MockSysUserRoleModel) DeleteByRoleIdTx(ctx context.Context, session sqlx.Session, roleId int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteByRoleIdTx", ctx, session, roleId)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteByRoleIdTx indicates an expected call of DeleteByRoleIdTx.
func (mr *MockSysUserRoleModelMockRecorder) DeleteByRoleIdTx(ctx, session, roleId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByRoleIdTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).DeleteByRoleIdTx), ctx, session, roleId)
}

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

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

// DeleteByUserIdForProduct mocks base method.
func (m *MockSysUserRoleModel) DeleteByUserIdForProduct(ctx context.Context, userId int64, productCode string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteByUserIdForProduct", ctx, userId, productCode)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteByUserIdForProduct indicates an expected call of DeleteByUserIdForProduct.
func (mr *MockSysUserRoleModelMockRecorder) DeleteByUserIdForProduct(ctx, userId, productCode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByUserIdForProduct", reflect.TypeOf((*MockSysUserRoleModel)(nil).DeleteByUserIdForProduct), ctx, userId, productCode)
}

// DeleteByUserIdForProductTx mocks base method.
func (m *MockSysUserRoleModel) DeleteByUserIdForProductTx(ctx context.Context, session sqlx.Session, userId int64, productCode string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteByUserIdForProductTx", ctx, session, userId, productCode)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteByUserIdForProductTx indicates an expected call of DeleteByUserIdForProductTx.
func (mr *MockSysUserRoleModelMockRecorder) DeleteByUserIdForProductTx(ctx, session, userId, productCode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByUserIdForProductTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).DeleteByUserIdForProductTx), ctx, session, userId, productCode)
}

// DeleteByUserIdTx mocks base method.
func (m *MockSysUserRoleModel) DeleteByUserIdTx(ctx context.Context, session sqlx.Session, userId int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteByUserIdTx", ctx, session, userId)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteByUserIdTx indicates an expected call of DeleteByUserIdTx.
func (mr *MockSysUserRoleModelMockRecorder) DeleteByUserIdTx(ctx, session, userId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByUserIdTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).DeleteByUserIdTx), ctx, session, userId)
}

// DeleteWithTx mocks base method.
func (m *MockSysUserRoleModel) DeleteWithTx(ctx context.Context, session sqlx.Session, id int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWithTx", ctx, session, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWithTx indicates an expected call of DeleteWithTx.
func (mr *MockSysUserRoleModelMockRecorder) DeleteWithTx(ctx, session, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWithTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).DeleteWithTx), ctx, session, id)
}

// FindByUserId mocks base method.
func (m *MockSysUserRoleModel) FindByUserId(ctx context.Context, userId int64) ([]*userrole.SysUserRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindByUserId", ctx, userId)
	ret0, _ := ret[0].([]*userrole.SysUserRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FindOne mocks base method.
func (m *MockSysUserRoleModel) FindOne(ctx context.Context, id int64) (*userrole.SysUserRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOne", ctx, id)
	ret0, _ := ret[0].(*userrole.SysUserRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FindOneByUserIdRoleId mocks base method.
func (m *MockSysUserRoleModel) FindOneByUserIdRoleId(ctx context.Context, userId, roleId int64) (*userrole.SysUserRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOneByUserIdRoleId", ctx, userId, roleId)
	ret0, _ := ret[0].(*userrole.SysUserRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOneByUserIdRoleId indicates an expected call of FindOneByUserIdRoleId.
func (mr *MockSysUserRoleModelMockRecorder) FindOneByUserIdRoleId(ctx, userId, roleId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneByUserIdRoleId", reflect.TypeOf((*MockSysUserRoleModel)(nil).FindOneByUserIdRoleId), ctx, userId, roleId)
}

// FindOneByUserIdRoleIdWithTx mocks base method.
func (m *MockSysUserRoleModel) FindOneByUserIdRoleIdWithTx(ctx context.Context, session sqlx.Session, userId, roleId int64) (*userrole.SysUserRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOneByUserIdRoleIdWithTx", ctx, session, userId, roleId)
	ret0, _ := ret[0].(*userrole.SysUserRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOneByUserIdRoleIdWithTx indicates an expected call of FindOneByUserIdRoleIdWithTx.
func (mr *MockSysUserRoleModelMockRecorder) FindOneByUserIdRoleIdWithTx(ctx, session, userId, roleId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneByUserIdRoleIdWithTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).FindOneByUserIdRoleIdWithTx), ctx, session, userId, roleId)
}

// FindOneWithTx mocks base method.
func (m *MockSysUserRoleModel) FindOneWithTx(ctx context.Context, session sqlx.Session, id int64) (*userrole.SysUserRole, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOneWithTx", ctx, session, id)
	ret0, _ := ret[0].(*userrole.SysUserRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOneWithTx indicates an expected call of FindOneWithTx.
func (mr *MockSysUserRoleModelMockRecorder) FindOneWithTx(ctx, session, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneWithTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).FindOneWithTx), ctx, session, id)
}

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

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

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

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

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

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

// InsertWithTx mocks base method.
func (m *MockSysUserRoleModel) InsertWithTx(ctx context.Context, session sqlx.Session, data *userrole.SysUserRole) (sql.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWithTx", ctx, session, data)
	ret0, _ := ret[0].(sql.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWithTx indicates an expected call of InsertWithTx.
func (mr *MockSysUserRoleModelMockRecorder) InsertWithTx(ctx, session, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWithTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).InsertWithTx), ctx, session, data)
}

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

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

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

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

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

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

// UpdateWithTx mocks base method.
func (m *MockSysUserRoleModel) UpdateWithTx(ctx context.Context, session sqlx.Session, data *userrole.SysUserRole) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWithTx", ctx, session, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWithTx indicates an expected call of UpdateWithTx.
func (mr *MockSysUserRoleModelMockRecorder) UpdateWithTx(ctx, session, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWithTx", reflect.TypeOf((*MockSysUserRoleModel)(nil).UpdateWithTx), ctx, session, data)
}