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

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

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

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

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

// MockSysProductModel is a mock of SysProductModel interface.
type MockSysProductModel struct {
	ctrl     *gomock.Controller
	recorder *MockSysProductModelMockRecorder
	isgomock struct{}
}

// MockSysProductModelMockRecorder is the mock recorder for MockSysProductModel.
type MockSysProductModelMockRecorder struct {
	mock *MockSysProductModel
}

// NewMockSysProductModel creates a new mock instance.
func NewMockSysProductModel(ctrl *gomock.Controller) *MockSysProductModel {
	mock := &MockSysProductModel{ctrl: ctrl}
	mock.recorder = &MockSysProductModelMockRecorder{mock}
	return mock
}

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

// BatchDelete mocks base method.
func (m *MockSysProductModel) 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 *MockSysProductModelMockRecorder) BatchDelete(ctx, ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDelete", reflect.TypeOf((*MockSysProductModel)(nil).BatchDelete), ctx, ids)
}

// BatchDeleteWithTx mocks base method.
func (m *MockSysProductModel) 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 *MockSysProductModelMockRecorder) BatchDeleteWithTx(ctx, session, ids any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteWithTx", reflect.TypeOf((*MockSysProductModel)(nil).BatchDeleteWithTx), ctx, session, ids)
}

// BatchInsert mocks base method.
func (m *MockSysProductModel) BatchInsert(ctx context.Context, dataList []*product.SysProduct) 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 *MockSysProductModelMockRecorder) BatchInsert(ctx, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchInsert", reflect.TypeOf((*MockSysProductModel)(nil).BatchInsert), ctx, dataList)
}

// BatchInsertWithTx mocks base method.
func (m *MockSysProductModel) BatchInsertWithTx(ctx context.Context, session sqlx.Session, dataList []*product.SysProduct) 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 *MockSysProductModelMockRecorder) BatchInsertWithTx(ctx, session, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchInsertWithTx", reflect.TypeOf((*MockSysProductModel)(nil).BatchInsertWithTx), ctx, session, dataList)
}

// BatchUpdate mocks base method.
func (m *MockSysProductModel) BatchUpdate(ctx context.Context, dataList []*product.SysProduct) 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 *MockSysProductModelMockRecorder) BatchUpdate(ctx, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdate", reflect.TypeOf((*MockSysProductModel)(nil).BatchUpdate), ctx, dataList)
}

// BatchUpdateWithTx mocks base method.
func (m *MockSysProductModel) BatchUpdateWithTx(ctx context.Context, session sqlx.Session, dataList []*product.SysProduct) 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 *MockSysProductModelMockRecorder) BatchUpdateWithTx(ctx, session, dataList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchUpdateWithTx", reflect.TypeOf((*MockSysProductModel)(nil).BatchUpdateWithTx), ctx, session, dataList)
}

// Delete mocks base method.
func (m *MockSysProductModel) 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 *MockSysProductModelMockRecorder) Delete(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSysProductModel)(nil).Delete), ctx, id)
}

// DeleteWithTx mocks base method.
func (m *MockSysProductModel) 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 *MockSysProductModelMockRecorder) DeleteWithTx(ctx, session, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWithTx", reflect.TypeOf((*MockSysProductModel)(nil).DeleteWithTx), ctx, session, id)
}

// FindList mocks base method.
func (m *MockSysProductModel) FindList(ctx context.Context, page, pageSize int64) ([]*product.SysProduct, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindList", ctx, page, pageSize)
	ret0, _ := ret[0].([]*product.SysProduct)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FindList indicates an expected call of FindList.
func (mr *MockSysProductModelMockRecorder) FindList(ctx, page, pageSize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindList", reflect.TypeOf((*MockSysProductModel)(nil).FindList), ctx, page, pageSize)
}

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

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

// FindOneByAppKey mocks base method.
func (m *MockSysProductModel) FindOneByAppKey(ctx context.Context, appKey string) (*product.SysProduct, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOneByAppKey", ctx, appKey)
	ret0, _ := ret[0].(*product.SysProduct)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FindOneByAppKeyWithTx mocks base method.
func (m *MockSysProductModel) FindOneByAppKeyWithTx(ctx context.Context, session sqlx.Session, appKey string) (*product.SysProduct, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOneByAppKeyWithTx", ctx, session, appKey)
	ret0, _ := ret[0].(*product.SysProduct)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOneByAppKeyWithTx indicates an expected call of FindOneByAppKeyWithTx.
func (mr *MockSysProductModelMockRecorder) FindOneByAppKeyWithTx(ctx, session, appKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneByAppKeyWithTx", reflect.TypeOf((*MockSysProductModel)(nil).FindOneByAppKeyWithTx), ctx, session, appKey)
}

// FindOneByCode mocks base method.
func (m *MockSysProductModel) FindOneByCode(ctx context.Context, code string) (*product.SysProduct, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOneByCode", ctx, code)
	ret0, _ := ret[0].(*product.SysProduct)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// FindOneByCodeWithTx mocks base method.
func (m *MockSysProductModel) FindOneByCodeWithTx(ctx context.Context, session sqlx.Session, code string) (*product.SysProduct, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FindOneByCodeWithTx", ctx, session, code)
	ret0, _ := ret[0].(*product.SysProduct)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FindOneByCodeWithTx indicates an expected call of FindOneByCodeWithTx.
func (mr *MockSysProductModelMockRecorder) FindOneByCodeWithTx(ctx, session, code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneByCodeWithTx", reflect.TypeOf((*MockSysProductModel)(nil).FindOneByCodeWithTx), ctx, session, code)
}

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

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

// Insert mocks base method.
func (m *MockSysProductModel) Insert(ctx context.Context, data *product.SysProduct) (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 *MockSysProductModelMockRecorder) Insert(ctx, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockSysProductModel)(nil).Insert), ctx, data)
}

// InsertWithTx mocks base method.
func (m *MockSysProductModel) InsertWithTx(ctx context.Context, session sqlx.Session, data *product.SysProduct) (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 *MockSysProductModelMockRecorder) InsertWithTx(ctx, session, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWithTx", reflect.TypeOf((*MockSysProductModel)(nil).InsertWithTx), ctx, session, data)
}

// InvalidateProductCache mocks base method.
func (m *MockSysProductModel) InvalidateProductCache(ctx context.Context, id int64, appKey, code string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InvalidateProductCache", ctx, id, appKey, code)
}

// InvalidateProductCache indicates an expected call of InvalidateProductCache.
func (mr *MockSysProductModelMockRecorder) InvalidateProductCache(ctx, id, appKey, code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvalidateProductCache", reflect.TypeOf((*MockSysProductModel)(nil).InvalidateProductCache), ctx, id, appKey, code)
}

// LockByCodeTx mocks base method.
func (m *MockSysProductModel) LockByCodeTx(ctx context.Context, session sqlx.Session, code string) (*product.SysProduct, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LockByCodeTx", ctx, session, code)
	ret0, _ := ret[0].(*product.SysProduct)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// LockByCodeTx indicates an expected call of LockByCodeTx.
func (mr *MockSysProductModelMockRecorder) LockByCodeTx(ctx, session, code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockByCodeTx", reflect.TypeOf((*MockSysProductModel)(nil).LockByCodeTx), ctx, session, code)
}

// TableName mocks base method.
func (m *MockSysProductModel) 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 *MockSysProductModelMockRecorder) TableName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TableName", reflect.TypeOf((*MockSysProductModel)(nil).TableName))
}

// TransactCtx mocks base method.
func (m *MockSysProductModel) 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 *MockSysProductModelMockRecorder) TransactCtx(ctx, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactCtx", reflect.TypeOf((*MockSysProductModel)(nil).TransactCtx), ctx, fn)
}

// Update mocks base method.
func (m *MockSysProductModel) Update(ctx context.Context, data *product.SysProduct) 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 *MockSysProductModelMockRecorder) Update(ctx, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockSysProductModel)(nil).Update), ctx, data)
}

// UpdateWithOptLock mocks base method.
func (m *MockSysProductModel) UpdateWithOptLock(ctx context.Context, data *product.SysProduct, expectedUpdateTime int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWithOptLock", ctx, data, expectedUpdateTime)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateWithOptLockTx mocks base method.
func (m *MockSysProductModel) UpdateWithOptLockTx(ctx context.Context, session sqlx.Session, data *product.SysProduct, expectedUpdateTime int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWithOptLockTx", ctx, session, data, expectedUpdateTime)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateWithTx mocks base method.
func (m *MockSysProductModel) UpdateWithTx(ctx context.Context, session sqlx.Session, data *product.SysProduct) 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 *MockSysProductModelMockRecorder) UpdateWithTx(ctx, session, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWithTx", reflect.TypeOf((*MockSysProductModel)(nil).UpdateWithTx), ctx, session, data)
}