Rainbond/db/dao/dao_mock.go

// Automatically generated by MockGen. DO NOT EDIT!
// Source: dao.go

package dao

import (
	gomock "github.com/rafrombrc/gomock/gomock"
	model "github.com/goodrain/rainbond/db/model"
	time "time"
)

// Mock of Dao interface
type MockDao struct {
	ctrl     *gomock.Controller
	recorder *_MockDaoRecorder
}

// Recorder for MockDao (not exported)
type _MockDaoRecorder struct {
	mock *MockDao
}

func NewMockDao(ctrl *gomock.Controller) *MockDao {
	mock := &MockDao{ctrl: ctrl}
	mock.recorder = &_MockDaoRecorder{mock}
	return mock
}

func (_m *MockDao) EXPECT() *_MockDaoRecorder {
	return _m.recorder
}

func (_m *MockDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

// Mock of DelDao interface
type MockDelDao struct {
	ctrl     *gomock.Controller
	recorder *_MockDelDaoRecorder
}

// Recorder for MockDelDao (not exported)
type _MockDelDaoRecorder struct {
	mock *MockDelDao
}

func NewMockDelDao(ctrl *gomock.Controller) *MockDelDao {
	mock := &MockDelDao{ctrl: ctrl}
	mock.recorder = &_MockDelDaoRecorder{mock}
	return mock
}

func (_m *MockDelDao) EXPECT() *_MockDelDaoRecorder {
	return _m.recorder
}

func (_m *MockDelDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockDelDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

// Mock of TenantDao interface
type MockTenantDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantDaoRecorder
}

// Recorder for MockTenantDao (not exported)
type _MockTenantDaoRecorder struct {
	mock *MockTenantDao
}

func NewMockTenantDao(ctrl *gomock.Controller) *MockTenantDao {
	mock := &MockTenantDao{ctrl: ctrl}
	mock.recorder = &_MockTenantDaoRecorder{mock}
	return mock
}

func (_m *MockTenantDao) EXPECT() *_MockTenantDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantDao) GetTenantByUUID(uuid string) (*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetTenantByUUID", uuid)
	ret0, _ := ret[0].(*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantByUUID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantByUUID", arg0)
}

func (_m *MockTenantDao) GetTenantIDByName(tenantName string) (*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetTenantIDByName", tenantName)
	ret0, _ := ret[0].(*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantIDByName(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantIDByName", arg0)
}

func (_m *MockTenantDao) GetALLTenants() ([]*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetALLTenants")
	ret0, _ := ret[0].([]*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetALLTenants() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetALLTenants")
}

func (_m *MockTenantDao) GetTenantByEid(eid string) ([]*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetTenantByEid", eid)
	ret0, _ := ret[0].([]*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantByEid(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantByEid", arg0)
}

func (_m *MockTenantDao) GetPagedTenants(offset int, len int) ([]*model.Tenants, error) {
	ret := _m.ctrl.Call(_m, "GetPagedTenants", offset, len)
	ret0, _ := ret[0].([]*model.Tenants)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetPagedTenants(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPagedTenants", arg0, arg1)
}

func (_m *MockTenantDao) GetTenantIDsByNames(names []string) ([]string, error) {
	ret := _m.ctrl.Call(_m, "GetTenantIDsByNames", names)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantIDsByNames(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantIDsByNames", arg0)
}

func (_m *MockTenantDao) GetTenantLimitsByNames(names []string) (map[string]int, error) {
	ret := _m.ctrl.Call(_m, "GetTenantLimitsByNames", names)
	ret0, _ := ret[0].(map[string]int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantDaoRecorder) GetTenantLimitsByNames(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantLimitsByNames", arg0)
}

func (_m *MockTenantDao) GetTenantByUUIDIsExist(uuid string) bool {
	ret := _m.ctrl.Call(_m, "GetTenantByUUIDIsExist", uuid)
	ret0, _ := ret[0].(bool)
	return ret0
}

func (_mr *_MockTenantDaoRecorder) GetTenantByUUIDIsExist(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantByUUIDIsExist", arg0)
}

// Mock of AppDao interface
type MockAppDao struct {
	ctrl     *gomock.Controller
	recorder *_MockAppDaoRecorder
}

// Recorder for MockAppDao (not exported)
type _MockAppDaoRecorder struct {
	mock *MockAppDao
}

func NewMockAppDao(ctrl *gomock.Controller) *MockAppDao {
	mock := &MockAppDao{ctrl: ctrl}
	mock.recorder = &_MockAppDaoRecorder{mock}
	return mock
}

func (_m *MockAppDao) EXPECT() *_MockAppDaoRecorder {
	return _m.recorder
}

func (_m *MockAppDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockAppDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockAppDao) GetByEventId(eventID string) (*model.AppStatus, error) {
	ret := _m.ctrl.Call(_m, "GetByEventId", eventID)
	ret0, _ := ret[0].(*model.AppStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppDaoRecorder) GetByEventId(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetByEventId", arg0)
}

func (_m *MockAppDao) DeleteModelByEventId(eventID string) error {
	ret := _m.ctrl.Call(_m, "DeleteModelByEventId", eventID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppDaoRecorder) DeleteModelByEventId(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModelByEventId", arg0)
}

// Mock of LicenseDao interface
type MockLicenseDao struct {
	ctrl     *gomock.Controller
	recorder *_MockLicenseDaoRecorder
}

// Recorder for MockLicenseDao (not exported)
type _MockLicenseDaoRecorder struct {
	mock *MockLicenseDao
}

func NewMockLicenseDao(ctrl *gomock.Controller) *MockLicenseDao {
	mock := &MockLicenseDao{ctrl: ctrl}
	mock.recorder = &_MockLicenseDaoRecorder{mock}
	return mock
}

func (_m *MockLicenseDao) EXPECT() *_MockLicenseDaoRecorder {
	return _m.recorder
}

func (_m *MockLicenseDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockLicenseDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockLicenseDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockLicenseDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockLicenseDao) ListLicenses() ([]*model.LicenseInfo, error) {
	ret := _m.ctrl.Call(_m, "ListLicenses")
	ret0, _ := ret[0].([]*model.LicenseInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockLicenseDaoRecorder) ListLicenses() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListLicenses")
}

// Mock of TenantServiceDao interface
type MockTenantServiceDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceDaoRecorder
}

// Recorder for MockTenantServiceDao (not exported)
type _MockTenantServiceDaoRecorder struct {
	mock *MockTenantServiceDao
}

func NewMockTenantServiceDao(ctrl *gomock.Controller) *MockTenantServiceDao {
	mock := &MockTenantServiceDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceDao) EXPECT() *_MockTenantServiceDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceDao) GetServiceByID(serviceID string) (*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceByID", serviceID)
	ret0, _ := ret[0].(*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceByID", arg0)
}

func (_m *MockTenantServiceDao) GetServiceByServiceAlias(serviceAlias string) (*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceByServiceAlias", serviceAlias)
	ret0, _ := ret[0].(*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceByServiceAlias(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceByServiceAlias", arg0)
}

func (_m *MockTenantServiceDao) GetServiceByIDs(serviceIDs []string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceByIDs", serviceIDs)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceByIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceByIDs", arg0)
}

func (_m *MockTenantServiceDao) GetServiceAliasByIDs(uids []string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceAliasByIDs", uids)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceAliasByIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceAliasByIDs", arg0)
}

func (_m *MockTenantServiceDao) GetServiceByTenantIDAndServiceAlias(tenantID string, serviceName string) (*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServiceByTenantIDAndServiceAlias", tenantID, serviceName)
	ret0, _ := ret[0].(*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceByTenantIDAndServiceAlias(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceByTenantIDAndServiceAlias", arg0, arg1)
}

func (_m *MockTenantServiceDao) SetTenantServiceStatus(serviceID string, status string) error {
	ret := _m.ctrl.Call(_m, "SetTenantServiceStatus", serviceID, status)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDaoRecorder) SetTenantServiceStatus(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetTenantServiceStatus", arg0, arg1)
}

func (_m *MockTenantServiceDao) GetServicesByTenantID(tenantID string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServicesByTenantID", tenantID)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServicesByTenantID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServicesByTenantID", arg0)
}

func (_m *MockTenantServiceDao) GetServicesByTenantIDs(tenantIDs []string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServicesByTenantIDs", tenantIDs)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServicesByTenantIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServicesByTenantIDs", arg0)
}

func (_m *MockTenantServiceDao) GetServicesAllInfoByTenantID(tenantID string) ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetServicesAllInfoByTenantID", tenantID)
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServicesAllInfoByTenantID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServicesAllInfoByTenantID", arg0)
}

func (_m *MockTenantServiceDao) DeleteServiceByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteServiceByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDaoRecorder) DeleteServiceByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteServiceByServiceID", arg0)
}

func (_m *MockTenantServiceDao) GetServiceMemoryByTenantIDs(tenantIDs []string, serviceIDs []string) (map[string]map[string]interface{}, error) {
	ret := _m.ctrl.Call(_m, "GetServiceMemoryByTenantIDs", tenantIDs, serviceIDs)
	ret0, _ := ret[0].(map[string]map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceMemoryByTenantIDs(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceMemoryByTenantIDs", arg0, arg1)
}

func (_m *MockTenantServiceDao) GetServiceMemoryByServiceIDs(serviceIDs []string) (map[string]map[string]interface{}, error) {
	ret := _m.ctrl.Call(_m, "GetServiceMemoryByServiceIDs", serviceIDs)
	ret0, _ := ret[0].(map[string]map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetServiceMemoryByServiceIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceMemoryByServiceIDs", arg0)
}

func (_m *MockTenantServiceDao) GetPagedTenantService(offset int, len int, serviceIDs []string) ([]map[string]interface{}, int, error) {
	ret := _m.ctrl.Call(_m, "GetPagedTenantService", offset, len, serviceIDs)
	ret0, _ := ret[0].([]map[string]interface{})
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

func (_mr *_MockTenantServiceDaoRecorder) GetPagedTenantService(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPagedTenantService", arg0, arg1, arg2)
}

func (_m *MockTenantServiceDao) GetAllServicesID() ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "GetAllServicesID")
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) GetAllServicesID() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllServicesID")
}

func (_m *MockTenantServiceDao) UpdateDeployVersion(serviceID string, deployversion string) error {
	ret := _m.ctrl.Call(_m, "UpdateDeployVersion", serviceID, deployversion)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDaoRecorder) UpdateDeployVersion(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateDeployVersion", arg0, arg1)
}

func (_m *MockTenantServiceDao) ListThirdPartyServices() ([]*model.TenantServices, error) {
	ret := _m.ctrl.Call(_m, "ListThirdPartyServices")
	ret0, _ := ret[0].([]*model.TenantServices)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDaoRecorder) ListThirdPartyServices() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListThirdPartyServices")
}

// Mock of TenantServiceDeleteDao interface
type MockTenantServiceDeleteDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceDeleteDaoRecorder
}

// Recorder for MockTenantServiceDeleteDao (not exported)
type _MockTenantServiceDeleteDaoRecorder struct {
	mock *MockTenantServiceDeleteDao
}

func NewMockTenantServiceDeleteDao(ctrl *gomock.Controller) *MockTenantServiceDeleteDao {
	mock := &MockTenantServiceDeleteDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceDeleteDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceDeleteDao) EXPECT() *_MockTenantServiceDeleteDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceDeleteDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDeleteDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceDeleteDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDeleteDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceDeleteDao) GetTenantServicesDeleteByCreateTime(createTime time.Time) ([]*model.TenantServicesDelete, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServicesDeleteByCreateTime", createTime)
	ret0, _ := ret[0].([]*model.TenantServicesDelete)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceDeleteDaoRecorder) GetTenantServicesDeleteByCreateTime(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServicesDeleteByCreateTime", arg0)
}

func (_m *MockTenantServiceDeleteDao) DeleteTenantServicesDelete(record *model.TenantServicesDelete) error {
	ret := _m.ctrl.Call(_m, "DeleteTenantServicesDelete", record)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceDeleteDaoRecorder) DeleteTenantServicesDelete(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTenantServicesDelete", arg0)
}

// Mock of TenantServicesPortDao interface
type MockTenantServicesPortDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServicesPortDaoRecorder
}

// Recorder for MockTenantServicesPortDao (not exported)
type _MockTenantServicesPortDaoRecorder struct {
	mock *MockTenantServicesPortDao
}

func NewMockTenantServicesPortDao(ctrl *gomock.Controller) *MockTenantServicesPortDao {
	mock := &MockTenantServicesPortDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServicesPortDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServicesPortDao) EXPECT() *_MockTenantServicesPortDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServicesPortDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesPortDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServicesPortDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesPortDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServicesPortDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesPortDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServicesPortDao) GetPortsByServiceID(serviceID string) ([]*model.TenantServicesPort, error) {
	ret := _m.ctrl.Call(_m, "GetPortsByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.TenantServicesPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesPortDaoRecorder) GetPortsByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPortsByServiceID", arg0)
}

func (_m *MockTenantServicesPortDao) GetOuterPorts(serviceID string) ([]*model.TenantServicesPort, error) {
	ret := _m.ctrl.Call(_m, "GetOuterPorts", serviceID)
	ret0, _ := ret[0].([]*model.TenantServicesPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesPortDaoRecorder) GetOuterPorts(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetOuterPorts", arg0)
}

func (_m *MockTenantServicesPortDao) GetInnerPorts(serviceID string) ([]*model.TenantServicesPort, error) {
	ret := _m.ctrl.Call(_m, "GetInnerPorts", serviceID)
	ret0, _ := ret[0].([]*model.TenantServicesPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesPortDaoRecorder) GetInnerPorts(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetInnerPorts", arg0)
}

func (_m *MockTenantServicesPortDao) GetPort(serviceID string, port int) (*model.TenantServicesPort, error) {
	ret := _m.ctrl.Call(_m, "GetPort", serviceID, port)
	ret0, _ := ret[0].(*model.TenantServicesPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesPortDaoRecorder) GetPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPort", arg0, arg1)
}

func (_m *MockTenantServicesPortDao) DELPortsByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELPortsByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesPortDaoRecorder) DELPortsByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELPortsByServiceID", arg0)
}

func (_m *MockTenantServicesPortDao) HasOpenPort(sid string) bool {
	ret := _m.ctrl.Call(_m, "HasOpenPort", sid)
	ret0, _ := ret[0].(bool)
	return ret0
}

func (_mr *_MockTenantServicesPortDaoRecorder) HasOpenPort(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "HasOpenPort", arg0)
}

// Mock of TenantPluginDao interface
type MockTenantPluginDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantPluginDaoRecorder
}

// Recorder for MockTenantPluginDao (not exported)
type _MockTenantPluginDaoRecorder struct {
	mock *MockTenantPluginDao
}

func NewMockTenantPluginDao(ctrl *gomock.Controller) *MockTenantPluginDao {
	mock := &MockTenantPluginDao{ctrl: ctrl}
	mock.recorder = &_MockTenantPluginDaoRecorder{mock}
	return mock
}

func (_m *MockTenantPluginDao) EXPECT() *_MockTenantPluginDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantPluginDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantPluginDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantPluginDao) GetPluginByID(pluginID string, tenantID string) (*model.TenantPlugin, error) {
	ret := _m.ctrl.Call(_m, "GetPluginByID", pluginID, tenantID)
	ret0, _ := ret[0].(*model.TenantPlugin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDaoRecorder) GetPluginByID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginByID", arg0, arg1)
}

func (_m *MockTenantPluginDao) DeletePluginByID(pluginID string, tenantID string) error {
	ret := _m.ctrl.Call(_m, "DeletePluginByID", pluginID, tenantID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDaoRecorder) DeletePluginByID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeletePluginByID", arg0, arg1)
}

func (_m *MockTenantPluginDao) GetPluginsByTenantID(tenantID string) ([]*model.TenantPlugin, error) {
	ret := _m.ctrl.Call(_m, "GetPluginsByTenantID", tenantID)
	ret0, _ := ret[0].([]*model.TenantPlugin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDaoRecorder) GetPluginsByTenantID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginsByTenantID", arg0)
}

// Mock of TenantPluginDefaultENVDao interface
type MockTenantPluginDefaultENVDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantPluginDefaultENVDaoRecorder
}

// Recorder for MockTenantPluginDefaultENVDao (not exported)
type _MockTenantPluginDefaultENVDaoRecorder struct {
	mock *MockTenantPluginDefaultENVDao
}

func NewMockTenantPluginDefaultENVDao(ctrl *gomock.Controller) *MockTenantPluginDefaultENVDao {
	mock := &MockTenantPluginDefaultENVDao{ctrl: ctrl}
	mock.recorder = &_MockTenantPluginDefaultENVDaoRecorder{mock}
	return mock
}

func (_m *MockTenantPluginDefaultENVDao) EXPECT() *_MockTenantPluginDefaultENVDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantPluginDefaultENVDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantPluginDefaultENVDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantPluginDefaultENVDao) GetDefaultENVByName(pluginID string, name string, versionID string) (*model.TenantPluginDefaultENV, error) {
	ret := _m.ctrl.Call(_m, "GetDefaultENVByName", pluginID, name, versionID)
	ret0, _ := ret[0].(*model.TenantPluginDefaultENV)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) GetDefaultENVByName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDefaultENVByName", arg0, arg1, arg2)
}

func (_m *MockTenantPluginDefaultENVDao) GetDefaultENVSByPluginID(pluginID string, versionID string) ([]*model.TenantPluginDefaultENV, error) {
	ret := _m.ctrl.Call(_m, "GetDefaultENVSByPluginID", pluginID, versionID)
	ret0, _ := ret[0].([]*model.TenantPluginDefaultENV)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) GetDefaultENVSByPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDefaultENVSByPluginID", arg0, arg1)
}

func (_m *MockTenantPluginDefaultENVDao) DeleteDefaultENVByName(pluginID string, name string, versionID string) error {
	ret := _m.ctrl.Call(_m, "DeleteDefaultENVByName", pluginID, name, versionID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) DeleteDefaultENVByName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteDefaultENVByName", arg0, arg1, arg2)
}

func (_m *MockTenantPluginDefaultENVDao) DeleteAllDefaultENVByPluginID(PluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteAllDefaultENVByPluginID", PluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) DeleteAllDefaultENVByPluginID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAllDefaultENVByPluginID", arg0)
}

func (_m *MockTenantPluginDefaultENVDao) DeleteDefaultENVByPluginIDAndVersionID(pluginID string, versionID string) error {
	ret := _m.ctrl.Call(_m, "DeleteDefaultENVByPluginIDAndVersionID", pluginID, versionID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) DeleteDefaultENVByPluginIDAndVersionID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteDefaultENVByPluginIDAndVersionID", arg0, arg1)
}

func (_m *MockTenantPluginDefaultENVDao) GetALLMasterDefultENVs(pluginID string) ([]*model.TenantPluginDefaultENV, error) {
	ret := _m.ctrl.Call(_m, "GetALLMasterDefultENVs", pluginID)
	ret0, _ := ret[0].([]*model.TenantPluginDefaultENV)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) GetALLMasterDefultENVs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetALLMasterDefultENVs", arg0)
}

func (_m *MockTenantPluginDefaultENVDao) GetDefaultEnvWhichCanBeSetByPluginID(pluginID string, versionID string) ([]*model.TenantPluginDefaultENV, error) {
	ret := _m.ctrl.Call(_m, "GetDefaultEnvWhichCanBeSetByPluginID", pluginID, versionID)
	ret0, _ := ret[0].([]*model.TenantPluginDefaultENV)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginDefaultENVDaoRecorder) GetDefaultEnvWhichCanBeSetByPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDefaultEnvWhichCanBeSetByPluginID", arg0, arg1)
}

// Mock of TenantPluginBuildVersionDao interface
type MockTenantPluginBuildVersionDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantPluginBuildVersionDaoRecorder
}

// Recorder for MockTenantPluginBuildVersionDao (not exported)
type _MockTenantPluginBuildVersionDaoRecorder struct {
	mock *MockTenantPluginBuildVersionDao
}

func NewMockTenantPluginBuildVersionDao(ctrl *gomock.Controller) *MockTenantPluginBuildVersionDao {
	mock := &MockTenantPluginBuildVersionDao{ctrl: ctrl}
	mock.recorder = &_MockTenantPluginBuildVersionDaoRecorder{mock}
	return mock
}

func (_m *MockTenantPluginBuildVersionDao) EXPECT() *_MockTenantPluginBuildVersionDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantPluginBuildVersionDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) DeleteBuildVersionByVersionID(versionID string) error {
	ret := _m.ctrl.Call(_m, "DeleteBuildVersionByVersionID", versionID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) DeleteBuildVersionByVersionID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBuildVersionByVersionID", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) DeleteBuildVersionByPluginID(pluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteBuildVersionByPluginID", pluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) DeleteBuildVersionByPluginID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteBuildVersionByPluginID", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) GetBuildVersionByPluginID(pluginID string) ([]*model.TenantPluginBuildVersion, error) {
	ret := _m.ctrl.Call(_m, "GetBuildVersionByPluginID", pluginID)
	ret0, _ := ret[0].([]*model.TenantPluginBuildVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) GetBuildVersionByPluginID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBuildVersionByPluginID", arg0)
}

func (_m *MockTenantPluginBuildVersionDao) GetBuildVersionByVersionID(pluginID string, versionID string) (*model.TenantPluginBuildVersion, error) {
	ret := _m.ctrl.Call(_m, "GetBuildVersionByVersionID", pluginID, versionID)
	ret0, _ := ret[0].(*model.TenantPluginBuildVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) GetBuildVersionByVersionID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBuildVersionByVersionID", arg0, arg1)
}

func (_m *MockTenantPluginBuildVersionDao) GetLastBuildVersionByVersionID(pluginID string, versionID string) (*model.TenantPluginBuildVersion, error) {
	ret := _m.ctrl.Call(_m, "GetLastBuildVersionByVersionID", pluginID, versionID)
	ret0, _ := ret[0].(*model.TenantPluginBuildVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) GetLastBuildVersionByVersionID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLastBuildVersionByVersionID", arg0, arg1)
}

func (_m *MockTenantPluginBuildVersionDao) GetBuildVersionByDeployVersion(pluginID string, versionID string, deployVersion string) (*model.TenantPluginBuildVersion, error) {
	ret := _m.ctrl.Call(_m, "GetBuildVersionByDeployVersion", pluginID, versionID, deployVersion)
	ret0, _ := ret[0].(*model.TenantPluginBuildVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginBuildVersionDaoRecorder) GetBuildVersionByDeployVersion(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetBuildVersionByDeployVersion", arg0, arg1, arg2)
}

// Mock of TenantPluginVersionEnvDao interface
type MockTenantPluginVersionEnvDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantPluginVersionEnvDaoRecorder
}

// Recorder for MockTenantPluginVersionEnvDao (not exported)
type _MockTenantPluginVersionEnvDaoRecorder struct {
	mock *MockTenantPluginVersionEnvDao
}

func NewMockTenantPluginVersionEnvDao(ctrl *gomock.Controller) *MockTenantPluginVersionEnvDao {
	mock := &MockTenantPluginVersionEnvDao{ctrl: ctrl}
	mock.recorder = &_MockTenantPluginVersionEnvDaoRecorder{mock}
	return mock
}

func (_m *MockTenantPluginVersionEnvDao) EXPECT() *_MockTenantPluginVersionEnvDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantPluginVersionEnvDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantPluginVersionEnvDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantPluginVersionEnvDao) DeleteEnvByEnvName(envName string, pluginID string, serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteEnvByEnvName", envName, pluginID, serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) DeleteEnvByEnvName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteEnvByEnvName", arg0, arg1, arg2)
}

func (_m *MockTenantPluginVersionEnvDao) DeleteEnvByPluginID(serviceID string, pluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteEnvByPluginID", serviceID, pluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) DeleteEnvByPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteEnvByPluginID", arg0, arg1)
}

func (_m *MockTenantPluginVersionEnvDao) DeleteEnvByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteEnvByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) DeleteEnvByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteEnvByServiceID", arg0)
}

func (_m *MockTenantPluginVersionEnvDao) GetVersionEnvByServiceID(serviceID string, pluginID string) ([]*model.TenantPluginVersionEnv, error) {
	ret := _m.ctrl.Call(_m, "GetVersionEnvByServiceID", serviceID, pluginID)
	ret0, _ := ret[0].([]*model.TenantPluginVersionEnv)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) GetVersionEnvByServiceID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionEnvByServiceID", arg0, arg1)
}

func (_m *MockTenantPluginVersionEnvDao) GetVersionEnvByEnvName(serviceID string, pluginID string, envName string) (*model.TenantPluginVersionEnv, error) {
	ret := _m.ctrl.Call(_m, "GetVersionEnvByEnvName", serviceID, pluginID, envName)
	ret0, _ := ret[0].(*model.TenantPluginVersionEnv)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginVersionEnvDaoRecorder) GetVersionEnvByEnvName(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionEnvByEnvName", arg0, arg1, arg2)
}

// Mock of TenantPluginVersionConfigDao interface
type MockTenantPluginVersionConfigDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantPluginVersionConfigDaoRecorder
}

// Recorder for MockTenantPluginVersionConfigDao (not exported)
type _MockTenantPluginVersionConfigDaoRecorder struct {
	mock *MockTenantPluginVersionConfigDao
}

func NewMockTenantPluginVersionConfigDao(ctrl *gomock.Controller) *MockTenantPluginVersionConfigDao {
	mock := &MockTenantPluginVersionConfigDao{ctrl: ctrl}
	mock.recorder = &_MockTenantPluginVersionConfigDaoRecorder{mock}
	return mock
}

func (_m *MockTenantPluginVersionConfigDao) EXPECT() *_MockTenantPluginVersionConfigDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantPluginVersionConfigDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionConfigDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantPluginVersionConfigDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionConfigDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantPluginVersionConfigDao) GetPluginConfig(serviceID string, pluginID string) (*model.TenantPluginVersionDiscoverConfig, error) {
	ret := _m.ctrl.Call(_m, "GetPluginConfig", serviceID, pluginID)
	ret0, _ := ret[0].(*model.TenantPluginVersionDiscoverConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantPluginVersionConfigDaoRecorder) GetPluginConfig(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginConfig", arg0, arg1)
}

func (_m *MockTenantPluginVersionConfigDao) DeletePluginConfig(serviceID string, pluginID string) error {
	ret := _m.ctrl.Call(_m, "DeletePluginConfig", serviceID, pluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionConfigDaoRecorder) DeletePluginConfig(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeletePluginConfig", arg0, arg1)
}

func (_m *MockTenantPluginVersionConfigDao) DeletePluginConfigByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeletePluginConfigByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantPluginVersionConfigDaoRecorder) DeletePluginConfigByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeletePluginConfigByServiceID", arg0)
}

// Mock of TenantServicePluginRelationDao interface
type MockTenantServicePluginRelationDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServicePluginRelationDaoRecorder
}

// Recorder for MockTenantServicePluginRelationDao (not exported)
type _MockTenantServicePluginRelationDaoRecorder struct {
	mock *MockTenantServicePluginRelationDao
}

func NewMockTenantServicePluginRelationDao(ctrl *gomock.Controller) *MockTenantServicePluginRelationDao {
	mock := &MockTenantServicePluginRelationDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServicePluginRelationDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServicePluginRelationDao) EXPECT() *_MockTenantServicePluginRelationDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServicePluginRelationDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServicePluginRelationDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServicePluginRelationDao) DeleteRelationByServiceIDAndPluginID(serviceID string, pluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteRelationByServiceIDAndPluginID", serviceID, pluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) DeleteRelationByServiceIDAndPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteRelationByServiceIDAndPluginID", arg0, arg1)
}

func (_m *MockTenantServicePluginRelationDao) DeleteALLRelationByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteALLRelationByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) DeleteALLRelationByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteALLRelationByServiceID", arg0)
}

func (_m *MockTenantServicePluginRelationDao) DeleteALLRelationByPluginID(pluginID string) error {
	ret := _m.ctrl.Call(_m, "DeleteALLRelationByPluginID", pluginID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) DeleteALLRelationByPluginID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteALLRelationByPluginID", arg0)
}

func (_m *MockTenantServicePluginRelationDao) GetALLRelationByServiceID(serviceID string) ([]*model.TenantServicePluginRelation, error) {
	ret := _m.ctrl.Call(_m, "GetALLRelationByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.TenantServicePluginRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) GetALLRelationByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetALLRelationByServiceID", arg0)
}

func (_m *MockTenantServicePluginRelationDao) GetRelateionByServiceIDAndPluginID(serviceID string, pluginID string) (*model.TenantServicePluginRelation, error) {
	ret := _m.ctrl.Call(_m, "GetRelateionByServiceIDAndPluginID", serviceID, pluginID)
	ret0, _ := ret[0].(*model.TenantServicePluginRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) GetRelateionByServiceIDAndPluginID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetRelateionByServiceIDAndPluginID", arg0, arg1)
}

func (_m *MockTenantServicePluginRelationDao) CheckSomeModelPluginByServiceID(serviceID string, pluginModel string) (bool, error) {
	ret := _m.ctrl.Call(_m, "CheckSomeModelPluginByServiceID", serviceID, pluginModel)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) CheckSomeModelPluginByServiceID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CheckSomeModelPluginByServiceID", arg0, arg1)
}

func (_m *MockTenantServicePluginRelationDao) CheckSomeModelLikePluginByServiceID(serviceID string, pluginModel string) (bool, error) {
	ret := _m.ctrl.Call(_m, "CheckSomeModelLikePluginByServiceID", serviceID, pluginModel)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicePluginRelationDaoRecorder) CheckSomeModelLikePluginByServiceID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CheckSomeModelLikePluginByServiceID", arg0, arg1)
}

// Mock of TenantServiceRelationDao interface
type MockTenantServiceRelationDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceRelationDaoRecorder
}

// Recorder for MockTenantServiceRelationDao (not exported)
type _MockTenantServiceRelationDaoRecorder struct {
	mock *MockTenantServiceRelationDao
}

func NewMockTenantServiceRelationDao(ctrl *gomock.Controller) *MockTenantServiceRelationDao {
	mock := &MockTenantServiceRelationDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceRelationDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceRelationDao) EXPECT() *_MockTenantServiceRelationDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceRelationDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceRelationDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceRelationDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServiceRelationDao) GetTenantServiceRelations(serviceID string) ([]*model.TenantServiceRelation, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceRelations", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceRelationDaoRecorder) GetTenantServiceRelations(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceRelations", arg0)
}

func (_m *MockTenantServiceRelationDao) GetTenantServiceRelationsByDependServiceID(dependServiceID string) ([]*model.TenantServiceRelation, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceRelationsByDependServiceID", dependServiceID)
	ret0, _ := ret[0].([]*model.TenantServiceRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceRelationDaoRecorder) GetTenantServiceRelationsByDependServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceRelationsByDependServiceID", arg0)
}

func (_m *MockTenantServiceRelationDao) HaveRelations(serviceID string) bool {
	ret := _m.ctrl.Call(_m, "HaveRelations", serviceID)
	ret0, _ := ret[0].(bool)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) HaveRelations(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "HaveRelations", arg0)
}

func (_m *MockTenantServiceRelationDao) DELRelationsByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELRelationsByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) DELRelationsByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELRelationsByServiceID", arg0)
}

func (_m *MockTenantServiceRelationDao) DeleteRelationByDepID(serviceID string, depID string) error {
	ret := _m.ctrl.Call(_m, "DeleteRelationByDepID", serviceID, depID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceRelationDaoRecorder) DeleteRelationByDepID(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteRelationByDepID", arg0, arg1)
}

// Mock of TenantServicesStreamPluginPortDao interface
type MockTenantServicesStreamPluginPortDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServicesStreamPluginPortDaoRecorder
}

// Recorder for MockTenantServicesStreamPluginPortDao (not exported)
type _MockTenantServicesStreamPluginPortDaoRecorder struct {
	mock *MockTenantServicesStreamPluginPortDao
}

func NewMockTenantServicesStreamPluginPortDao(ctrl *gomock.Controller) *MockTenantServicesStreamPluginPortDao {
	mock := &MockTenantServicesStreamPluginPortDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServicesStreamPluginPortDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServicesStreamPluginPortDao) EXPECT() *_MockTenantServicesStreamPluginPortDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServicesStreamPluginPortDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServicesStreamPluginPortDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServicesStreamPluginPortDao) GetPluginMappingPorts(serviceID string, pluginModel string) ([]*model.TenantServicesStreamPluginPort, error) {
	ret := _m.ctrl.Call(_m, "GetPluginMappingPorts", serviceID, pluginModel)
	ret0, _ := ret[0].([]*model.TenantServicesStreamPluginPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) GetPluginMappingPorts(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginMappingPorts", arg0, arg1)
}

func (_m *MockTenantServicesStreamPluginPortDao) SetPluginMappingPort(tenantID string, serviceID string, pluginModel string, containerPort int) (int, error) {
	ret := _m.ctrl.Call(_m, "SetPluginMappingPort", tenantID, serviceID, pluginModel, containerPort)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) SetPluginMappingPort(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetPluginMappingPort", arg0, arg1, arg2, arg3)
}

func (_m *MockTenantServicesStreamPluginPortDao) DeletePluginMappingPortByContainerPort(serviceID string, pluginModel string, containerPort int) error {
	ret := _m.ctrl.Call(_m, "DeletePluginMappingPortByContainerPort", serviceID, pluginModel, containerPort)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) DeletePluginMappingPortByContainerPort(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeletePluginMappingPortByContainerPort", arg0, arg1, arg2)
}

func (_m *MockTenantServicesStreamPluginPortDao) DeleteAllPluginMappingPortByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteAllPluginMappingPortByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) DeleteAllPluginMappingPortByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAllPluginMappingPortByServiceID", arg0)
}

func (_m *MockTenantServicesStreamPluginPortDao) GetPluginMappingPortByServiceIDAndContainerPort(serviceID string, pluginModel string, containerPort int) (*model.TenantServicesStreamPluginPort, error) {
	ret := _m.ctrl.Call(_m, "GetPluginMappingPortByServiceIDAndContainerPort", serviceID, pluginModel, containerPort)
	ret0, _ := ret[0].(*model.TenantServicesStreamPluginPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServicesStreamPluginPortDaoRecorder) GetPluginMappingPortByServiceIDAndContainerPort(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPluginMappingPortByServiceIDAndContainerPort", arg0, arg1, arg2)
}

// Mock of TenantServiceEnvVarDao interface
type MockTenantServiceEnvVarDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceEnvVarDaoRecorder
}

// Recorder for MockTenantServiceEnvVarDao (not exported)
type _MockTenantServiceEnvVarDaoRecorder struct {
	mock *MockTenantServiceEnvVarDao
}

func NewMockTenantServiceEnvVarDao(ctrl *gomock.Controller) *MockTenantServiceEnvVarDao {
	mock := &MockTenantServiceEnvVarDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceEnvVarDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceEnvVarDao) EXPECT() *_MockTenantServiceEnvVarDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceEnvVarDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceEnvVarDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceEnvVarDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServiceEnvVarDao) GetDependServiceEnvs(serviceIDs []string, scopes []string) ([]*model.TenantServiceEnvVar, error) {
	ret := _m.ctrl.Call(_m, "GetDependServiceEnvs", serviceIDs, scopes)
	ret0, _ := ret[0].([]*model.TenantServiceEnvVar)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) GetDependServiceEnvs(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDependServiceEnvs", arg0, arg1)
}

func (_m *MockTenantServiceEnvVarDao) GetServiceEnvs(serviceID string, scopes []string) ([]*model.TenantServiceEnvVar, error) {
	ret := _m.ctrl.Call(_m, "GetServiceEnvs", serviceID, scopes)
	ret0, _ := ret[0].([]*model.TenantServiceEnvVar)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) GetServiceEnvs(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceEnvs", arg0, arg1)
}

func (_m *MockTenantServiceEnvVarDao) GetEnv(serviceID string, envName string) (*model.TenantServiceEnvVar, error) {
	ret := _m.ctrl.Call(_m, "GetEnv", serviceID, envName)
	ret0, _ := ret[0].(*model.TenantServiceEnvVar)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) GetEnv(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetEnv", arg0, arg1)
}

func (_m *MockTenantServiceEnvVarDao) DELServiceEnvsByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELServiceEnvsByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceEnvVarDaoRecorder) DELServiceEnvsByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELServiceEnvsByServiceID", arg0)
}

// Mock of TenantServiceMountRelationDao interface
type MockTenantServiceMountRelationDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceMountRelationDaoRecorder
}

// Recorder for MockTenantServiceMountRelationDao (not exported)
type _MockTenantServiceMountRelationDaoRecorder struct {
	mock *MockTenantServiceMountRelationDao
}

func NewMockTenantServiceMountRelationDao(ctrl *gomock.Controller) *MockTenantServiceMountRelationDao {
	mock := &MockTenantServiceMountRelationDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceMountRelationDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceMountRelationDao) EXPECT() *_MockTenantServiceMountRelationDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceMountRelationDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceMountRelationDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceMountRelationDao) GetTenantServiceMountRelationsByService(serviceID string) ([]*model.TenantServiceMountRelation, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceMountRelationsByService", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceMountRelation)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) GetTenantServiceMountRelationsByService(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceMountRelationsByService", arg0)
}

func (_m *MockTenantServiceMountRelationDao) DElTenantServiceMountRelationByServiceAndName(serviceID string, mntDir string) error {
	ret := _m.ctrl.Call(_m, "DElTenantServiceMountRelationByServiceAndName", serviceID, mntDir)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) DElTenantServiceMountRelationByServiceAndName(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DElTenantServiceMountRelationByServiceAndName", arg0, arg1)
}

func (_m *MockTenantServiceMountRelationDao) DELTenantServiceMountRelationByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELTenantServiceMountRelationByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) DELTenantServiceMountRelationByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELTenantServiceMountRelationByServiceID", arg0)
}

func (_m *MockTenantServiceMountRelationDao) DElTenantServiceMountRelationByDepService(serviceID string, depServiceID string) error {
	ret := _m.ctrl.Call(_m, "DElTenantServiceMountRelationByDepService", serviceID, depServiceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceMountRelationDaoRecorder) DElTenantServiceMountRelationByDepService(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DElTenantServiceMountRelationByDepService", arg0, arg1)
}

// Mock of TenantServiceVolumeDao interface
type MockTenantServiceVolumeDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceVolumeDaoRecorder
}

// Recorder for MockTenantServiceVolumeDao (not exported)
type _MockTenantServiceVolumeDaoRecorder struct {
	mock *MockTenantServiceVolumeDao
}

func NewMockTenantServiceVolumeDao(ctrl *gomock.Controller) *MockTenantServiceVolumeDao {
	mock := &MockTenantServiceVolumeDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceVolumeDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceVolumeDao) EXPECT() *_MockTenantServiceVolumeDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceVolumeDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceVolumeDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceVolumeDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServiceVolumeDao) GetTenantServiceVolumesByServiceID(serviceID string) ([]*model.TenantServiceVolume, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceVolumesByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceVolume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) GetTenantServiceVolumesByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceVolumesByServiceID", arg0)
}

func (_m *MockTenantServiceVolumeDao) DeleteTenantServiceVolumesByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteTenantServiceVolumesByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) DeleteTenantServiceVolumesByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTenantServiceVolumesByServiceID", arg0)
}

func (_m *MockTenantServiceVolumeDao) DeleteByServiceIDAndVolumePath(serviceID string, volumePath string) error {
	ret := _m.ctrl.Call(_m, "DeleteByServiceIDAndVolumePath", serviceID, volumePath)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) DeleteByServiceIDAndVolumePath(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteByServiceIDAndVolumePath", arg0, arg1)
}

func (_m *MockTenantServiceVolumeDao) GetVolumeByServiceIDAndName(serviceID string, name string) (*model.TenantServiceVolume, error) {
	ret := _m.ctrl.Call(_m, "GetVolumeByServiceIDAndName", serviceID, name)
	ret0, _ := ret[0].(*model.TenantServiceVolume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) GetVolumeByServiceIDAndName(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVolumeByServiceIDAndName", arg0, arg1)
}

func (_m *MockTenantServiceVolumeDao) GetAllVolumes() ([]*model.TenantServiceVolume, error) {
	ret := _m.ctrl.Call(_m, "GetAllVolumes")
	ret0, _ := ret[0].([]*model.TenantServiceVolume)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceVolumeDaoRecorder) GetAllVolumes() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllVolumes")
}

// Mock of TenantServiceConfigFileDao interface
type MockTenantServiceConfigFileDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceConfigFileDaoRecorder
}

// Recorder for MockTenantServiceConfigFileDao (not exported)
type _MockTenantServiceConfigFileDaoRecorder struct {
	mock *MockTenantServiceConfigFileDao
}

func NewMockTenantServiceConfigFileDao(ctrl *gomock.Controller) *MockTenantServiceConfigFileDao {
	mock := &MockTenantServiceConfigFileDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceConfigFileDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceConfigFileDao) EXPECT() *_MockTenantServiceConfigFileDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceConfigFileDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceConfigFileDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceConfigFileDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceConfigFileDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceConfigFileDao) GetByVolumeName(volumeName string) (*model.TenantServiceConfigFile, error) {
	ret := _m.ctrl.Call(_m, "GetByVolumeName", volumeName)
	ret0, _ := ret[0].(*model.TenantServiceConfigFile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceConfigFileDaoRecorder) GetByVolumeName(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetByVolumeName", arg0)
}

func (_m *MockTenantServiceConfigFileDao) DelByVolumeID(volumeName string) error {
	ret := _m.ctrl.Call(_m, "DelByVolumeID", volumeName)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceConfigFileDaoRecorder) DelByVolumeID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DelByVolumeID", arg0)
}

// Mock of TenantServiceLBMappingPortDao interface
type MockTenantServiceLBMappingPortDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceLBMappingPortDaoRecorder
}

// Recorder for MockTenantServiceLBMappingPortDao (not exported)
type _MockTenantServiceLBMappingPortDaoRecorder struct {
	mock *MockTenantServiceLBMappingPortDao
}

func NewMockTenantServiceLBMappingPortDao(ctrl *gomock.Controller) *MockTenantServiceLBMappingPortDao {
	mock := &MockTenantServiceLBMappingPortDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceLBMappingPortDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceLBMappingPortDao) EXPECT() *_MockTenantServiceLBMappingPortDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceLBMappingPortDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceLBMappingPortDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceLBMappingPortDao) GetTenantServiceLBMappingPort(serviceID string, containerPort int) (*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceLBMappingPort", serviceID, containerPort)
	ret0, _ := ret[0].(*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) GetTenantServiceLBMappingPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceLBMappingPort", arg0, arg1)
}

func (_m *MockTenantServiceLBMappingPortDao) GetLBMappingPortByServiceIDAndPort(serviceID string, port int) (*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "GetLBMappingPortByServiceIDAndPort", serviceID, port)
	ret0, _ := ret[0].(*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) GetLBMappingPortByServiceIDAndPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLBMappingPortByServiceIDAndPort", arg0, arg1)
}

func (_m *MockTenantServiceLBMappingPortDao) GetTenantServiceLBMappingPortByService(serviceID string) ([]*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceLBMappingPortByService", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) GetTenantServiceLBMappingPortByService(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceLBMappingPortByService", arg0)
}

func (_m *MockTenantServiceLBMappingPortDao) GetLBPortsASC() ([]*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "GetLBPortsASC")
	ret0, _ := ret[0].([]*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) GetLBPortsASC() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLBPortsASC")
}

func (_m *MockTenantServiceLBMappingPortDao) CreateTenantServiceLBMappingPort(serviceID string, containerPort int) (*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "CreateTenantServiceLBMappingPort", serviceID, containerPort)
	ret0, _ := ret[0].(*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) CreateTenantServiceLBMappingPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CreateTenantServiceLBMappingPort", arg0, arg1)
}

func (_m *MockTenantServiceLBMappingPortDao) DELServiceLBMappingPortByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELServiceLBMappingPortByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) DELServiceLBMappingPortByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELServiceLBMappingPortByServiceID", arg0)
}

func (_m *MockTenantServiceLBMappingPortDao) DELServiceLBMappingPortByServiceIDAndPort(serviceID string, lbPort int) error {
	ret := _m.ctrl.Call(_m, "DELServiceLBMappingPortByServiceIDAndPort", serviceID, lbPort)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) DELServiceLBMappingPortByServiceIDAndPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELServiceLBMappingPortByServiceIDAndPort", arg0, arg1)
}

func (_m *MockTenantServiceLBMappingPortDao) GetLBPortByTenantAndPort(tenantID string, lbport int) (*model.TenantServiceLBMappingPort, error) {
	ret := _m.ctrl.Call(_m, "GetLBPortByTenantAndPort", tenantID, lbport)
	ret0, _ := ret[0].(*model.TenantServiceLBMappingPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) GetLBPortByTenantAndPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLBPortByTenantAndPort", arg0, arg1)
}

func (_m *MockTenantServiceLBMappingPortDao) PortExists(port int) bool {
	ret := _m.ctrl.Call(_m, "PortExists", port)
	ret0, _ := ret[0].(bool)
	return ret0
}

func (_mr *_MockTenantServiceLBMappingPortDaoRecorder) PortExists(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PortExists", arg0)
}

// Mock of TenantServiceLabelDao interface
type MockTenantServiceLabelDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTenantServiceLabelDaoRecorder
}

// Recorder for MockTenantServiceLabelDao (not exported)
type _MockTenantServiceLabelDaoRecorder struct {
	mock *MockTenantServiceLabelDao
}

func NewMockTenantServiceLabelDao(ctrl *gomock.Controller) *MockTenantServiceLabelDao {
	mock := &MockTenantServiceLabelDao{ctrl: ctrl}
	mock.recorder = &_MockTenantServiceLabelDaoRecorder{mock}
	return mock
}

func (_m *MockTenantServiceLabelDao) EXPECT() *_MockTenantServiceLabelDaoRecorder {
	return _m.recorder
}

func (_m *MockTenantServiceLabelDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTenantServiceLabelDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTenantServiceLabelDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockTenantServiceLabelDao) GetTenantServiceLabel(serviceID string) ([]*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceLabel", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetTenantServiceLabel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceLabel", arg0)
}

func (_m *MockTenantServiceLabelDao) DeleteLabelByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteLabelByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) DeleteLabelByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteLabelByServiceID", arg0)
}

func (_m *MockTenantServiceLabelDao) GetTenantServiceNodeSelectorLabel(serviceID string) ([]*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceNodeSelectorLabel", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetTenantServiceNodeSelectorLabel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceNodeSelectorLabel", arg0)
}

func (_m *MockTenantServiceLabelDao) GetTenantNodeAffinityLabel(serviceID string) (*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetTenantNodeAffinityLabel", serviceID)
	ret0, _ := ret[0].(*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetTenantNodeAffinityLabel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantNodeAffinityLabel", arg0)
}

func (_m *MockTenantServiceLabelDao) GetTenantServiceAffinityLabel(serviceID string) ([]*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceAffinityLabel", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetTenantServiceAffinityLabel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceAffinityLabel", arg0)
}

func (_m *MockTenantServiceLabelDao) GetTenantServiceTypeLabel(serviceID string) (*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetTenantServiceTypeLabel", serviceID)
	ret0, _ := ret[0].(*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetTenantServiceTypeLabel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTenantServiceTypeLabel", arg0)
}

func (_m *MockTenantServiceLabelDao) DelTenantServiceLabelsByLabelValuesAndServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DelTenantServiceLabelsByLabelValuesAndServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) DelTenantServiceLabelsByLabelValuesAndServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DelTenantServiceLabelsByLabelValuesAndServiceID", arg0)
}

func (_m *MockTenantServiceLabelDao) DelTenantServiceLabelsByServiceIDKey(serviceID string, labelKey string) error {
	ret := _m.ctrl.Call(_m, "DelTenantServiceLabelsByServiceIDKey", serviceID, labelKey)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) DelTenantServiceLabelsByServiceIDKey(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DelTenantServiceLabelsByServiceIDKey", arg0, arg1)
}

func (_m *MockTenantServiceLabelDao) DelTenantServiceLabelsByServiceIDKeyValue(serviceID string, labelKey string, labelValue string) error {
	ret := _m.ctrl.Call(_m, "DelTenantServiceLabelsByServiceIDKeyValue", serviceID, labelKey, labelValue)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTenantServiceLabelDaoRecorder) DelTenantServiceLabelsByServiceIDKeyValue(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DelTenantServiceLabelsByServiceIDKeyValue", arg0, arg1, arg2)
}

func (_m *MockTenantServiceLabelDao) GetLabelByNodeSelectorKey(serviceID string, labelValue string) (*model.TenantServiceLable, error) {
	ret := _m.ctrl.Call(_m, "GetLabelByNodeSelectorKey", serviceID, labelValue)
	ret0, _ := ret[0].(*model.TenantServiceLable)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTenantServiceLabelDaoRecorder) GetLabelByNodeSelectorKey(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLabelByNodeSelectorKey", arg0, arg1)
}

// Mock of LocalSchedulerDao interface
type MockLocalSchedulerDao struct {
	ctrl     *gomock.Controller
	recorder *_MockLocalSchedulerDaoRecorder
}

// Recorder for MockLocalSchedulerDao (not exported)
type _MockLocalSchedulerDaoRecorder struct {
	mock *MockLocalSchedulerDao
}

func NewMockLocalSchedulerDao(ctrl *gomock.Controller) *MockLocalSchedulerDao {
	mock := &MockLocalSchedulerDao{ctrl: ctrl}
	mock.recorder = &_MockLocalSchedulerDaoRecorder{mock}
	return mock
}

func (_m *MockLocalSchedulerDao) EXPECT() *_MockLocalSchedulerDaoRecorder {
	return _m.recorder
}

func (_m *MockLocalSchedulerDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockLocalSchedulerDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockLocalSchedulerDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockLocalSchedulerDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockLocalSchedulerDao) GetLocalScheduler(serviceID string) ([]*model.LocalScheduler, error) {
	ret := _m.ctrl.Call(_m, "GetLocalScheduler", serviceID)
	ret0, _ := ret[0].([]*model.LocalScheduler)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockLocalSchedulerDaoRecorder) GetLocalScheduler(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetLocalScheduler", arg0)
}

// Mock of ServiceProbeDao interface
type MockServiceProbeDao struct {
	ctrl     *gomock.Controller
	recorder *_MockServiceProbeDaoRecorder
}

// Recorder for MockServiceProbeDao (not exported)
type _MockServiceProbeDaoRecorder struct {
	mock *MockServiceProbeDao
}

func NewMockServiceProbeDao(ctrl *gomock.Controller) *MockServiceProbeDao {
	mock := &MockServiceProbeDao{ctrl: ctrl}
	mock.recorder = &_MockServiceProbeDaoRecorder{mock}
	return mock
}

func (_m *MockServiceProbeDao) EXPECT() *_MockServiceProbeDaoRecorder {
	return _m.recorder
}

func (_m *MockServiceProbeDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceProbeDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockServiceProbeDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceProbeDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockServiceProbeDao) DeleteModel(serviceID string, arg ...interface{}) error {
	_s := []interface{}{serviceID}
	for _, _x := range arg {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "DeleteModel", _s...)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceProbeDaoRecorder) DeleteModel(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0}, arg1...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteModel", _s...)
}

func (_m *MockServiceProbeDao) GetServiceProbes(serviceID string) ([]*model.TenantServiceProbe, error) {
	ret := _m.ctrl.Call(_m, "GetServiceProbes", serviceID)
	ret0, _ := ret[0].([]*model.TenantServiceProbe)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockServiceProbeDaoRecorder) GetServiceProbes(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceProbes", arg0)
}

func (_m *MockServiceProbeDao) GetServiceUsedProbe(serviceID string, mode string) (*model.TenantServiceProbe, error) {
	ret := _m.ctrl.Call(_m, "GetServiceUsedProbe", serviceID, mode)
	ret0, _ := ret[0].(*model.TenantServiceProbe)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockServiceProbeDaoRecorder) GetServiceUsedProbe(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceUsedProbe", arg0, arg1)
}

func (_m *MockServiceProbeDao) DELServiceProbesByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DELServiceProbesByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceProbeDaoRecorder) DELServiceProbesByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DELServiceProbesByServiceID", arg0)
}

// Mock of CodeCheckResultDao interface
type MockCodeCheckResultDao struct {
	ctrl     *gomock.Controller
	recorder *_MockCodeCheckResultDaoRecorder
}

// Recorder for MockCodeCheckResultDao (not exported)
type _MockCodeCheckResultDaoRecorder struct {
	mock *MockCodeCheckResultDao
}

func NewMockCodeCheckResultDao(ctrl *gomock.Controller) *MockCodeCheckResultDao {
	mock := &MockCodeCheckResultDao{ctrl: ctrl}
	mock.recorder = &_MockCodeCheckResultDaoRecorder{mock}
	return mock
}

func (_m *MockCodeCheckResultDao) EXPECT() *_MockCodeCheckResultDaoRecorder {
	return _m.recorder
}

func (_m *MockCodeCheckResultDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCodeCheckResultDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockCodeCheckResultDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCodeCheckResultDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockCodeCheckResultDao) GetCodeCheckResult(serviceID string) (*model.CodeCheckResult, error) {
	ret := _m.ctrl.Call(_m, "GetCodeCheckResult", serviceID)
	ret0, _ := ret[0].(*model.CodeCheckResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockCodeCheckResultDaoRecorder) GetCodeCheckResult(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetCodeCheckResult", arg0)
}

// Mock of EventDao interface
type MockEventDao struct {
	ctrl     *gomock.Controller
	recorder *_MockEventDaoRecorder
}

// Recorder for MockEventDao (not exported)
type _MockEventDaoRecorder struct {
	mock *MockEventDao
}

func NewMockEventDao(ctrl *gomock.Controller) *MockEventDao {
	mock := &MockEventDao{ctrl: ctrl}
	mock.recorder = &_MockEventDaoRecorder{mock}
	return mock
}

func (_m *MockEventDao) EXPECT() *_MockEventDaoRecorder {
	return _m.recorder
}

func (_m *MockEventDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockEventDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockEventDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockEventDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockEventDao) GetEventByEventID(eventID string) (*model.ServiceEvent, error) {
	ret := _m.ctrl.Call(_m, "GetEventByEventID", eventID)
	ret0, _ := ret[0].(*model.ServiceEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockEventDaoRecorder) GetEventByEventID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetEventByEventID", arg0)
}

func (_m *MockEventDao) GetEventByEventIDs(eventIDs []string) ([]*model.ServiceEvent, error) {
	ret := _m.ctrl.Call(_m, "GetEventByEventIDs", eventIDs)
	ret0, _ := ret[0].([]*model.ServiceEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockEventDaoRecorder) GetEventByEventIDs(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetEventByEventIDs", arg0)
}

func (_m *MockEventDao) GetEventByServiceID(serviceID string) ([]*model.ServiceEvent, error) {
	ret := _m.ctrl.Call(_m, "GetEventByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.ServiceEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockEventDaoRecorder) GetEventByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetEventByServiceID", arg0)
}

func (_m *MockEventDao) DelEventByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DelEventByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockEventDaoRecorder) DelEventByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DelEventByServiceID", arg0)
}

// Mock of VersionInfoDao interface
type MockVersionInfoDao struct {
	ctrl     *gomock.Controller
	recorder *_MockVersionInfoDaoRecorder
}

// Recorder for MockVersionInfoDao (not exported)
type _MockVersionInfoDaoRecorder struct {
	mock *MockVersionInfoDao
}

func NewMockVersionInfoDao(ctrl *gomock.Controller) *MockVersionInfoDao {
	mock := &MockVersionInfoDao{ctrl: ctrl}
	mock.recorder = &_MockVersionInfoDaoRecorder{mock}
	return mock
}

func (_m *MockVersionInfoDao) EXPECT() *_MockVersionInfoDaoRecorder {
	return _m.recorder
}

func (_m *MockVersionInfoDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockVersionInfoDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockVersionInfoDao) GetVersionByEventID(eventID string) (*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "GetVersionByEventID", eventID)
	ret0, _ := ret[0].(*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) GetVersionByEventID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionByEventID", arg0)
}

func (_m *MockVersionInfoDao) GetVersionByDeployVersion(version string, serviceID string) (*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "GetVersionByDeployVersion", version, serviceID)
	ret0, _ := ret[0].(*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) GetVersionByDeployVersion(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionByDeployVersion", arg0, arg1)
}

func (_m *MockVersionInfoDao) GetVersionByServiceID(serviceID string) ([]*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "GetVersionByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) GetVersionByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionByServiceID", arg0)
}

func (_m *MockVersionInfoDao) GetAllVersionByServiceID(serviceID string) ([]*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "GetAllVersionByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) GetAllVersionByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllVersionByServiceID", arg0)
}

func (_m *MockVersionInfoDao) DeleteVersionByEventID(eventID string) error {
	ret := _m.ctrl.Call(_m, "DeleteVersionByEventID", eventID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) DeleteVersionByEventID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteVersionByEventID", arg0)
}

func (_m *MockVersionInfoDao) DeleteVersionByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteVersionByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) DeleteVersionByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteVersionByServiceID", arg0)
}

func (_m *MockVersionInfoDao) GetVersionInfo(timePoint time.Time, serviceIDList []string) ([]*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "GetVersionInfo", timePoint, serviceIDList)
	ret0, _ := ret[0].([]*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) GetVersionInfo(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetVersionInfo", arg0, arg1)
}

func (_m *MockVersionInfoDao) DeleteVersionInfo(obj *model.VersionInfo) error {
	ret := _m.ctrl.Call(_m, "DeleteVersionInfo", obj)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) DeleteVersionInfo(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteVersionInfo", arg0)
}

func (_m *MockVersionInfoDao) DeleteFailureVersionInfo(timePoint time.Time, status string, serviceIDList []string) error {
	ret := _m.ctrl.Call(_m, "DeleteFailureVersionInfo", timePoint, status, serviceIDList)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVersionInfoDaoRecorder) DeleteFailureVersionInfo(arg0, arg1, arg2 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteFailureVersionInfo", arg0, arg1, arg2)
}

func (_m *MockVersionInfoDao) SearchVersionInfo() ([]*model.VersionInfo, error) {
	ret := _m.ctrl.Call(_m, "SearchVersionInfo")
	ret0, _ := ret[0].([]*model.VersionInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVersionInfoDaoRecorder) SearchVersionInfo() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SearchVersionInfo")
}

// Mock of RegionUserInfoDao interface
type MockRegionUserInfoDao struct {
	ctrl     *gomock.Controller
	recorder *_MockRegionUserInfoDaoRecorder
}

// Recorder for MockRegionUserInfoDao (not exported)
type _MockRegionUserInfoDaoRecorder struct {
	mock *MockRegionUserInfoDao
}

func NewMockRegionUserInfoDao(ctrl *gomock.Controller) *MockRegionUserInfoDao {
	mock := &MockRegionUserInfoDao{ctrl: ctrl}
	mock.recorder = &_MockRegionUserInfoDaoRecorder{mock}
	return mock
}

func (_m *MockRegionUserInfoDao) EXPECT() *_MockRegionUserInfoDaoRecorder {
	return _m.recorder
}

func (_m *MockRegionUserInfoDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionUserInfoDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockRegionUserInfoDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionUserInfoDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockRegionUserInfoDao) GetALLTokenInValidityPeriod() ([]*model.RegionUserInfo, error) {
	ret := _m.ctrl.Call(_m, "GetALLTokenInValidityPeriod")
	ret0, _ := ret[0].([]*model.RegionUserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionUserInfoDaoRecorder) GetALLTokenInValidityPeriod() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetALLTokenInValidityPeriod")
}

func (_m *MockRegionUserInfoDao) GetTokenByEid(eid string) (*model.RegionUserInfo, error) {
	ret := _m.ctrl.Call(_m, "GetTokenByEid", eid)
	ret0, _ := ret[0].(*model.RegionUserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionUserInfoDaoRecorder) GetTokenByEid(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTokenByEid", arg0)
}

func (_m *MockRegionUserInfoDao) GetTokenByTokenID(token string) (*model.RegionUserInfo, error) {
	ret := _m.ctrl.Call(_m, "GetTokenByTokenID", token)
	ret0, _ := ret[0].(*model.RegionUserInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionUserInfoDaoRecorder) GetTokenByTokenID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTokenByTokenID", arg0)
}

// Mock of RegionAPIClassDao interface
type MockRegionAPIClassDao struct {
	ctrl     *gomock.Controller
	recorder *_MockRegionAPIClassDaoRecorder
}

// Recorder for MockRegionAPIClassDao (not exported)
type _MockRegionAPIClassDaoRecorder struct {
	mock *MockRegionAPIClassDao
}

func NewMockRegionAPIClassDao(ctrl *gomock.Controller) *MockRegionAPIClassDao {
	mock := &MockRegionAPIClassDao{ctrl: ctrl}
	mock.recorder = &_MockRegionAPIClassDaoRecorder{mock}
	return mock
}

func (_m *MockRegionAPIClassDao) EXPECT() *_MockRegionAPIClassDaoRecorder {
	return _m.recorder
}

func (_m *MockRegionAPIClassDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionAPIClassDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockRegionAPIClassDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionAPIClassDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockRegionAPIClassDao) GetPrefixesByClass(apiClass string) ([]*model.RegionAPIClass, error) {
	ret := _m.ctrl.Call(_m, "GetPrefixesByClass", apiClass)
	ret0, _ := ret[0].([]*model.RegionAPIClass)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionAPIClassDaoRecorder) GetPrefixesByClass(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetPrefixesByClass", arg0)
}

func (_m *MockRegionAPIClassDao) DeletePrefixInClass(apiClass string, prefix string) error {
	ret := _m.ctrl.Call(_m, "DeletePrefixInClass", apiClass, prefix)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionAPIClassDaoRecorder) DeletePrefixInClass(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeletePrefixInClass", arg0, arg1)
}

// Mock of RegionProcotolsDao interface
type MockRegionProcotolsDao struct {
	ctrl     *gomock.Controller
	recorder *_MockRegionProcotolsDaoRecorder
}

// Recorder for MockRegionProcotolsDao (not exported)
type _MockRegionProcotolsDaoRecorder struct {
	mock *MockRegionProcotolsDao
}

func NewMockRegionProcotolsDao(ctrl *gomock.Controller) *MockRegionProcotolsDao {
	mock := &MockRegionProcotolsDao{ctrl: ctrl}
	mock.recorder = &_MockRegionProcotolsDaoRecorder{mock}
	return mock
}

func (_m *MockRegionProcotolsDao) EXPECT() *_MockRegionProcotolsDaoRecorder {
	return _m.recorder
}

func (_m *MockRegionProcotolsDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionProcotolsDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockRegionProcotolsDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRegionProcotolsDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockRegionProcotolsDao) GetAllSupportProtocol(version string) ([]*model.RegionProcotols, error) {
	ret := _m.ctrl.Call(_m, "GetAllSupportProtocol", version)
	ret0, _ := ret[0].([]*model.RegionProcotols)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionProcotolsDaoRecorder) GetAllSupportProtocol(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAllSupportProtocol", arg0)
}

func (_m *MockRegionProcotolsDao) GetProtocolGroupByProtocolChild(version string, protocolChild string) (*model.RegionProcotols, error) {
	ret := _m.ctrl.Call(_m, "GetProtocolGroupByProtocolChild", version, protocolChild)
	ret0, _ := ret[0].(*model.RegionProcotols)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRegionProcotolsDaoRecorder) GetProtocolGroupByProtocolChild(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetProtocolGroupByProtocolChild", arg0, arg1)
}

// Mock of NotificationEventDao interface
type MockNotificationEventDao struct {
	ctrl     *gomock.Controller
	recorder *_MockNotificationEventDaoRecorder
}

// Recorder for MockNotificationEventDao (not exported)
type _MockNotificationEventDaoRecorder struct {
	mock *MockNotificationEventDao
}

func NewMockNotificationEventDao(ctrl *gomock.Controller) *MockNotificationEventDao {
	mock := &MockNotificationEventDao{ctrl: ctrl}
	mock.recorder = &_MockNotificationEventDaoRecorder{mock}
	return mock
}

func (_m *MockNotificationEventDao) EXPECT() *_MockNotificationEventDaoRecorder {
	return _m.recorder
}

func (_m *MockNotificationEventDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockNotificationEventDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockNotificationEventDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockNotificationEventDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockNotificationEventDao) GetNotificationEventByHash(hash string) (*model.NotificationEvent, error) {
	ret := _m.ctrl.Call(_m, "GetNotificationEventByHash", hash)
	ret0, _ := ret[0].(*model.NotificationEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockNotificationEventDaoRecorder) GetNotificationEventByHash(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNotificationEventByHash", arg0)
}

func (_m *MockNotificationEventDao) GetNotificationEventByKind(kind string, kindID string) ([]*model.NotificationEvent, error) {
	ret := _m.ctrl.Call(_m, "GetNotificationEventByKind", kind, kindID)
	ret0, _ := ret[0].([]*model.NotificationEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockNotificationEventDaoRecorder) GetNotificationEventByKind(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNotificationEventByKind", arg0, arg1)
}

func (_m *MockNotificationEventDao) GetNotificationEventByTime(start time.Time, end time.Time) ([]*model.NotificationEvent, error) {
	ret := _m.ctrl.Call(_m, "GetNotificationEventByTime", start, end)
	ret0, _ := ret[0].([]*model.NotificationEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockNotificationEventDaoRecorder) GetNotificationEventByTime(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNotificationEventByTime", arg0, arg1)
}

func (_m *MockNotificationEventDao) GetNotificationEventNotHandle() ([]*model.NotificationEvent, error) {
	ret := _m.ctrl.Call(_m, "GetNotificationEventNotHandle")
	ret0, _ := ret[0].([]*model.NotificationEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockNotificationEventDaoRecorder) GetNotificationEventNotHandle() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNotificationEventNotHandle")
}

// Mock of AppBackupDao interface
type MockAppBackupDao struct {
	ctrl     *gomock.Controller
	recorder *_MockAppBackupDaoRecorder
}

// Recorder for MockAppBackupDao (not exported)
type _MockAppBackupDaoRecorder struct {
	mock *MockAppBackupDao
}

func NewMockAppBackupDao(ctrl *gomock.Controller) *MockAppBackupDao {
	mock := &MockAppBackupDao{ctrl: ctrl}
	mock.recorder = &_MockAppBackupDaoRecorder{mock}
	return mock
}

func (_m *MockAppBackupDao) EXPECT() *_MockAppBackupDaoRecorder {
	return _m.recorder
}

func (_m *MockAppBackupDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppBackupDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockAppBackupDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppBackupDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockAppBackupDao) CheckHistory(groupID string, version string) bool {
	ret := _m.ctrl.Call(_m, "CheckHistory", groupID, version)
	ret0, _ := ret[0].(bool)
	return ret0
}

func (_mr *_MockAppBackupDaoRecorder) CheckHistory(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CheckHistory", arg0, arg1)
}

func (_m *MockAppBackupDao) GetAppBackups(groupID string) ([]*model.AppBackup, error) {
	ret := _m.ctrl.Call(_m, "GetAppBackups", groupID)
	ret0, _ := ret[0].([]*model.AppBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppBackupDaoRecorder) GetAppBackups(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAppBackups", arg0)
}

func (_m *MockAppBackupDao) DeleteAppBackup(backupID string) error {
	ret := _m.ctrl.Call(_m, "DeleteAppBackup", backupID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockAppBackupDaoRecorder) DeleteAppBackup(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteAppBackup", arg0)
}

func (_m *MockAppBackupDao) GetAppBackup(backupID string) (*model.AppBackup, error) {
	ret := _m.ctrl.Call(_m, "GetAppBackup", backupID)
	ret0, _ := ret[0].(*model.AppBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppBackupDaoRecorder) GetAppBackup(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetAppBackup", arg0)
}

func (_m *MockAppBackupDao) GetDeleteAppBackup(backupID string) (*model.AppBackup, error) {
	ret := _m.ctrl.Call(_m, "GetDeleteAppBackup", backupID)
	ret0, _ := ret[0].(*model.AppBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppBackupDaoRecorder) GetDeleteAppBackup(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDeleteAppBackup", arg0)
}

func (_m *MockAppBackupDao) GetDeleteAppBackups() ([]*model.AppBackup, error) {
	ret := _m.ctrl.Call(_m, "GetDeleteAppBackups")
	ret0, _ := ret[0].([]*model.AppBackup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockAppBackupDaoRecorder) GetDeleteAppBackups() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetDeleteAppBackups")
}

// Mock of ServiceSourceDao interface
type MockServiceSourceDao struct {
	ctrl     *gomock.Controller
	recorder *_MockServiceSourceDaoRecorder
}

// Recorder for MockServiceSourceDao (not exported)
type _MockServiceSourceDaoRecorder struct {
	mock *MockServiceSourceDao
}

func NewMockServiceSourceDao(ctrl *gomock.Controller) *MockServiceSourceDao {
	mock := &MockServiceSourceDao{ctrl: ctrl}
	mock.recorder = &_MockServiceSourceDaoRecorder{mock}
	return mock
}

func (_m *MockServiceSourceDao) EXPECT() *_MockServiceSourceDaoRecorder {
	return _m.recorder
}

func (_m *MockServiceSourceDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceSourceDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockServiceSourceDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockServiceSourceDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockServiceSourceDao) GetServiceSource(serviceID string) ([]*model.ServiceSourceConfig, error) {
	ret := _m.ctrl.Call(_m, "GetServiceSource", serviceID)
	ret0, _ := ret[0].([]*model.ServiceSourceConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockServiceSourceDaoRecorder) GetServiceSource(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetServiceSource", arg0)
}

// Mock of CertificateDao interface
type MockCertificateDao struct {
	ctrl     *gomock.Controller
	recorder *_MockCertificateDaoRecorder
}

// Recorder for MockCertificateDao (not exported)
type _MockCertificateDaoRecorder struct {
	mock *MockCertificateDao
}

func NewMockCertificateDao(ctrl *gomock.Controller) *MockCertificateDao {
	mock := &MockCertificateDao{ctrl: ctrl}
	mock.recorder = &_MockCertificateDaoRecorder{mock}
	return mock
}

func (_m *MockCertificateDao) EXPECT() *_MockCertificateDaoRecorder {
	return _m.recorder
}

func (_m *MockCertificateDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCertificateDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockCertificateDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCertificateDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockCertificateDao) AddOrUpdate(mo model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddOrUpdate", mo)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCertificateDaoRecorder) AddOrUpdate(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddOrUpdate", arg0)
}

func (_m *MockCertificateDao) GetCertificateByID(certificateID string) (*model.Certificate, error) {
	ret := _m.ctrl.Call(_m, "GetCertificateByID", certificateID)
	ret0, _ := ret[0].(*model.Certificate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockCertificateDaoRecorder) GetCertificateByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetCertificateByID", arg0)
}

func (_m *MockCertificateDao) DeleteCertificateByID(certificateID string) error {
	ret := _m.ctrl.Call(_m, "DeleteCertificateByID", certificateID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockCertificateDaoRecorder) DeleteCertificateByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteCertificateByID", arg0)
}

// Mock of RuleExtensionDao interface
type MockRuleExtensionDao struct {
	ctrl     *gomock.Controller
	recorder *_MockRuleExtensionDaoRecorder
}

// Recorder for MockRuleExtensionDao (not exported)
type _MockRuleExtensionDaoRecorder struct {
	mock *MockRuleExtensionDao
}

func NewMockRuleExtensionDao(ctrl *gomock.Controller) *MockRuleExtensionDao {
	mock := &MockRuleExtensionDao{ctrl: ctrl}
	mock.recorder = &_MockRuleExtensionDaoRecorder{mock}
	return mock
}

func (_m *MockRuleExtensionDao) EXPECT() *_MockRuleExtensionDaoRecorder {
	return _m.recorder
}

func (_m *MockRuleExtensionDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRuleExtensionDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockRuleExtensionDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRuleExtensionDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockRuleExtensionDao) GetRuleExtensionByRuleID(ruleID string) ([]*model.RuleExtension, error) {
	ret := _m.ctrl.Call(_m, "GetRuleExtensionByRuleID", ruleID)
	ret0, _ := ret[0].([]*model.RuleExtension)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockRuleExtensionDaoRecorder) GetRuleExtensionByRuleID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetRuleExtensionByRuleID", arg0)
}

func (_m *MockRuleExtensionDao) DeleteRuleExtensionByRuleID(ruleID string) error {
	ret := _m.ctrl.Call(_m, "DeleteRuleExtensionByRuleID", ruleID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockRuleExtensionDaoRecorder) DeleteRuleExtensionByRuleID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteRuleExtensionByRuleID", arg0)
}

// Mock of HTTPRuleDao interface
type MockHTTPRuleDao struct {
	ctrl     *gomock.Controller
	recorder *_MockHTTPRuleDaoRecorder
}

// Recorder for MockHTTPRuleDao (not exported)
type _MockHTTPRuleDaoRecorder struct {
	mock *MockHTTPRuleDao
}

func NewMockHTTPRuleDao(ctrl *gomock.Controller) *MockHTTPRuleDao {
	mock := &MockHTTPRuleDao{ctrl: ctrl}
	mock.recorder = &_MockHTTPRuleDaoRecorder{mock}
	return mock
}

func (_m *MockHTTPRuleDao) EXPECT() *_MockHTTPRuleDaoRecorder {
	return _m.recorder
}

func (_m *MockHTTPRuleDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHTTPRuleDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockHTTPRuleDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHTTPRuleDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockHTTPRuleDao) GetHTTPRuleByID(id string) (*model.HTTPRule, error) {
	ret := _m.ctrl.Call(_m, "GetHTTPRuleByID", id)
	ret0, _ := ret[0].(*model.HTTPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHTTPRuleDaoRecorder) GetHTTPRuleByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetHTTPRuleByID", arg0)
}

func (_m *MockHTTPRuleDao) GetHTTPRuleByServiceIDAndContainerPort(serviceID string, containerPort int) ([]*model.HTTPRule, error) {
	ret := _m.ctrl.Call(_m, "GetHTTPRuleByServiceIDAndContainerPort", serviceID, containerPort)
	ret0, _ := ret[0].([]*model.HTTPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHTTPRuleDaoRecorder) GetHTTPRuleByServiceIDAndContainerPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetHTTPRuleByServiceIDAndContainerPort", arg0, arg1)
}

func (_m *MockHTTPRuleDao) DeleteHTTPRuleByID(id string) error {
	ret := _m.ctrl.Call(_m, "DeleteHTTPRuleByID", id)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHTTPRuleDaoRecorder) DeleteHTTPRuleByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteHTTPRuleByID", arg0)
}

func (_m *MockHTTPRuleDao) DeleteHTTPRuleByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteHTTPRuleByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockHTTPRuleDaoRecorder) DeleteHTTPRuleByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteHTTPRuleByServiceID", arg0)
}

func (_m *MockHTTPRuleDao) ListByServiceID(serviceID string) ([]*model.HTTPRule, error) {
	ret := _m.ctrl.Call(_m, "ListByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.HTTPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockHTTPRuleDaoRecorder) ListByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListByServiceID", arg0)
}

// Mock of TCPRuleDao interface
type MockTCPRuleDao struct {
	ctrl     *gomock.Controller
	recorder *_MockTCPRuleDaoRecorder
}

// Recorder for MockTCPRuleDao (not exported)
type _MockTCPRuleDaoRecorder struct {
	mock *MockTCPRuleDao
}

func NewMockTCPRuleDao(ctrl *gomock.Controller) *MockTCPRuleDao {
	mock := &MockTCPRuleDao{ctrl: ctrl}
	mock.recorder = &_MockTCPRuleDaoRecorder{mock}
	return mock
}

func (_m *MockTCPRuleDao) EXPECT() *_MockTCPRuleDaoRecorder {
	return _m.recorder
}

func (_m *MockTCPRuleDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTCPRuleDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockTCPRuleDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTCPRuleDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockTCPRuleDao) GetTCPRuleByServiceIDAndContainerPort(serviceID string, containerPort int) ([]*model.TCPRule, error) {
	ret := _m.ctrl.Call(_m, "GetTCPRuleByServiceIDAndContainerPort", serviceID, containerPort)
	ret0, _ := ret[0].([]*model.TCPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTCPRuleDaoRecorder) GetTCPRuleByServiceIDAndContainerPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTCPRuleByServiceIDAndContainerPort", arg0, arg1)
}

func (_m *MockTCPRuleDao) GetTCPRuleByID(id string) (*model.TCPRule, error) {
	ret := _m.ctrl.Call(_m, "GetTCPRuleByID", id)
	ret0, _ := ret[0].(*model.TCPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTCPRuleDaoRecorder) GetTCPRuleByID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetTCPRuleByID", arg0)
}

func (_m *MockTCPRuleDao) DeleteTCPRule(tcpRule *model.TCPRule) error {
	ret := _m.ctrl.Call(_m, "DeleteTCPRule", tcpRule)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTCPRuleDaoRecorder) DeleteTCPRule(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTCPRule", arg0)
}

func (_m *MockTCPRuleDao) DeleteTCPRuleByServiceID(serviceID string) error {
	ret := _m.ctrl.Call(_m, "DeleteTCPRuleByServiceID", serviceID)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockTCPRuleDaoRecorder) DeleteTCPRuleByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteTCPRuleByServiceID", arg0)
}

func (_m *MockTCPRuleDao) ListByServiceID(serviceID string) ([]*model.TCPRule, error) {
	ret := _m.ctrl.Call(_m, "ListByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.TCPRule)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockTCPRuleDaoRecorder) ListByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListByServiceID", arg0)
}

// Mock of IPPortDao interface
type MockIPPortDao struct {
	ctrl     *gomock.Controller
	recorder *_MockIPPortDaoRecorder
}

// Recorder for MockIPPortDao (not exported)
type _MockIPPortDaoRecorder struct {
	mock *MockIPPortDao
}

func NewMockIPPortDao(ctrl *gomock.Controller) *MockIPPortDao {
	mock := &MockIPPortDao{ctrl: ctrl}
	mock.recorder = &_MockIPPortDaoRecorder{mock}
	return mock
}

func (_m *MockIPPortDao) EXPECT() *_MockIPPortDaoRecorder {
	return _m.recorder
}

func (_m *MockIPPortDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockIPPortDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockIPPortDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockIPPortDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockIPPortDao) DeleteByIPAndPort(ip string, port int) error {
	ret := _m.ctrl.Call(_m, "DeleteByIPAndPort", ip, port)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockIPPortDaoRecorder) DeleteByIPAndPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DeleteByIPAndPort", arg0, arg1)
}

func (_m *MockIPPortDao) GetIPByPort(port int) ([]*model.IPPort, error) {
	ret := _m.ctrl.Call(_m, "GetIPByPort", port)
	ret0, _ := ret[0].([]*model.IPPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockIPPortDaoRecorder) GetIPByPort(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetIPByPort", arg0)
}

func (_m *MockIPPortDao) GetIPPortByIPAndPort(ip string, port int) (*model.IPPort, error) {
	ret := _m.ctrl.Call(_m, "GetIPPortByIPAndPort", ip, port)
	ret0, _ := ret[0].(*model.IPPort)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockIPPortDaoRecorder) GetIPPortByIPAndPort(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetIPPortByIPAndPort", arg0, arg1)
}

// Mock of IPPoolDao interface
type MockIPPoolDao struct {
	ctrl     *gomock.Controller
	recorder *_MockIPPoolDaoRecorder
}

// Recorder for MockIPPoolDao (not exported)
type _MockIPPoolDaoRecorder struct {
	mock *MockIPPoolDao
}

func NewMockIPPoolDao(ctrl *gomock.Controller) *MockIPPoolDao {
	mock := &MockIPPoolDao{ctrl: ctrl}
	mock.recorder = &_MockIPPoolDaoRecorder{mock}
	return mock
}

func (_m *MockIPPoolDao) EXPECT() *_MockIPPoolDaoRecorder {
	return _m.recorder
}

func (_m *MockIPPoolDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockIPPoolDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockIPPoolDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockIPPoolDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockIPPoolDao) GetIPPoolByEID(eid string) (*model.IPPool, error) {
	ret := _m.ctrl.Call(_m, "GetIPPoolByEID", eid)
	ret0, _ := ret[0].(*model.IPPool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockIPPoolDaoRecorder) GetIPPoolByEID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetIPPoolByEID", arg0)
}

// Mock of EndpointsDao interface
type MockEndpointsDao struct {
	ctrl     *gomock.Controller
	recorder *_MockEndpointsDaoRecorder
}

// Recorder for MockEndpointsDao (not exported)
type _MockEndpointsDaoRecorder struct {
	mock *MockEndpointsDao
}

func NewMockEndpointsDao(ctrl *gomock.Controller) *MockEndpointsDao {
	mock := &MockEndpointsDao{ctrl: ctrl}
	mock.recorder = &_MockEndpointsDaoRecorder{mock}
	return mock
}

func (_m *MockEndpointsDao) EXPECT() *_MockEndpointsDaoRecorder {
	return _m.recorder
}

func (_m *MockEndpointsDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockEndpointsDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockEndpointsDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockEndpointsDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockEndpointsDao) GetByUUID(uuid string) (*model.Endpoint, error) {
	ret := _m.ctrl.Call(_m, "GetByUUID", uuid)
	ret0, _ := ret[0].(*model.Endpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockEndpointsDaoRecorder) GetByUUID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetByUUID", arg0)
}

func (_m *MockEndpointsDao) DelByUUID(uuid string) error {
	ret := _m.ctrl.Call(_m, "DelByUUID", uuid)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockEndpointsDaoRecorder) DelByUUID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DelByUUID", arg0)
}

func (_m *MockEndpointsDao) List(sid string) ([]*model.Endpoint, error) {
	ret := _m.ctrl.Call(_m, "List", sid)
	ret0, _ := ret[0].([]*model.Endpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockEndpointsDaoRecorder) List(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0)
}

func (_m *MockEndpointsDao) ListIsOnline(sid string) ([]*model.Endpoint, error) {
	ret := _m.ctrl.Call(_m, "ListIsOnline", sid)
	ret0, _ := ret[0].([]*model.Endpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockEndpointsDaoRecorder) ListIsOnline(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ListIsOnline", arg0)
}

// Mock of ThirdPartySvcDiscoveryCfgDao interface
type MockThirdPartySvcDiscoveryCfgDao struct {
	ctrl     *gomock.Controller
	recorder *_MockThirdPartySvcDiscoveryCfgDaoRecorder
}

// Recorder for MockThirdPartySvcDiscoveryCfgDao (not exported)
type _MockThirdPartySvcDiscoveryCfgDaoRecorder struct {
	mock *MockThirdPartySvcDiscoveryCfgDao
}

func NewMockThirdPartySvcDiscoveryCfgDao(ctrl *gomock.Controller) *MockThirdPartySvcDiscoveryCfgDao {
	mock := &MockThirdPartySvcDiscoveryCfgDao{ctrl: ctrl}
	mock.recorder = &_MockThirdPartySvcDiscoveryCfgDaoRecorder{mock}
	return mock
}

func (_m *MockThirdPartySvcDiscoveryCfgDao) EXPECT() *_MockThirdPartySvcDiscoveryCfgDaoRecorder {
	return _m.recorder
}

func (_m *MockThirdPartySvcDiscoveryCfgDao) AddModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "AddModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockThirdPartySvcDiscoveryCfgDaoRecorder) AddModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AddModel", arg0)
}

func (_m *MockThirdPartySvcDiscoveryCfgDao) UpdateModel(_param0 model.Interface) error {
	ret := _m.ctrl.Call(_m, "UpdateModel", _param0)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockThirdPartySvcDiscoveryCfgDaoRecorder) UpdateModel(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateModel", arg0)
}

func (_m *MockThirdPartySvcDiscoveryCfgDao) GetByServiceID(sid string) (*model.ThirdPartySvcDiscoveryCfg, error) {
	ret := _m.ctrl.Call(_m, "GetByServiceID", sid)
	ret0, _ := ret[0].(*model.ThirdPartySvcDiscoveryCfg)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockThirdPartySvcDiscoveryCfgDaoRecorder) GetByServiceID(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetByServiceID", arg0)
}