mirror of https://github.com/grafana/grafana.git
766 lines
23 KiB
Go
766 lines
23 KiB
Go
// Code generated by mockery; DO NOT EDIT.
|
|
// github.com/vektra/mockery
|
|
// template: testify
|
|
|
|
package authinfotest
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/grafana/grafana/pkg/services/login"
|
|
"github.com/grafana/grafana/pkg/services/user"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// NewMockAuthInfoService creates a new instance of MockAuthInfoService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewMockAuthInfoService(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockAuthInfoService {
|
|
mock := &MockAuthInfoService{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|
|
|
|
// MockAuthInfoService is an autogenerated mock type for the AuthInfoService type
|
|
type MockAuthInfoService struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockAuthInfoService_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockAuthInfoService) EXPECT() *MockAuthInfoService_Expecter {
|
|
return &MockAuthInfoService_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// DeleteUserAuthInfo provides a mock function for the type MockAuthInfoService
|
|
func (_mock *MockAuthInfoService) DeleteUserAuthInfo(ctx context.Context, userID int64) error {
|
|
ret := _mock.Called(ctx, userID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteUserAuthInfo")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, int64) error); ok {
|
|
r0 = returnFunc(ctx, userID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAuthInfoService_DeleteUserAuthInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUserAuthInfo'
|
|
type MockAuthInfoService_DeleteUserAuthInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteUserAuthInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - userID int64
|
|
func (_e *MockAuthInfoService_Expecter) DeleteUserAuthInfo(ctx interface{}, userID interface{}) *MockAuthInfoService_DeleteUserAuthInfo_Call {
|
|
return &MockAuthInfoService_DeleteUserAuthInfo_Call{Call: _e.mock.On("DeleteUserAuthInfo", ctx, userID)}
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_DeleteUserAuthInfo_Call) Run(run func(ctx context.Context, userID int64)) *MockAuthInfoService_DeleteUserAuthInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 int64
|
|
if args[1] != nil {
|
|
arg1 = args[1].(int64)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_DeleteUserAuthInfo_Call) Return(err error) *MockAuthInfoService_DeleteUserAuthInfo_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_DeleteUserAuthInfo_Call) RunAndReturn(run func(ctx context.Context, userID int64) error) *MockAuthInfoService_DeleteUserAuthInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAuthInfo provides a mock function for the type MockAuthInfoService
|
|
func (_mock *MockAuthInfoService) GetAuthInfo(ctx context.Context, query *login.GetAuthInfoQuery) (*login.UserAuth, error) {
|
|
ret := _mock.Called(ctx, query)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAuthInfo")
|
|
}
|
|
|
|
var r0 *login.UserAuth
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *login.GetAuthInfoQuery) (*login.UserAuth, error)); ok {
|
|
return returnFunc(ctx, query)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *login.GetAuthInfoQuery) *login.UserAuth); ok {
|
|
r0 = returnFunc(ctx, query)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*login.UserAuth)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *login.GetAuthInfoQuery) error); ok {
|
|
r1 = returnFunc(ctx, query)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAuthInfoService_GetAuthInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuthInfo'
|
|
type MockAuthInfoService_GetAuthInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAuthInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - query *login.GetAuthInfoQuery
|
|
func (_e *MockAuthInfoService_Expecter) GetAuthInfo(ctx interface{}, query interface{}) *MockAuthInfoService_GetAuthInfo_Call {
|
|
return &MockAuthInfoService_GetAuthInfo_Call{Call: _e.mock.On("GetAuthInfo", ctx, query)}
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_GetAuthInfo_Call) Run(run func(ctx context.Context, query *login.GetAuthInfoQuery)) *MockAuthInfoService_GetAuthInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *login.GetAuthInfoQuery
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*login.GetAuthInfoQuery)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_GetAuthInfo_Call) Return(userAuth *login.UserAuth, err error) *MockAuthInfoService_GetAuthInfo_Call {
|
|
_c.Call.Return(userAuth, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_GetAuthInfo_Call) RunAndReturn(run func(ctx context.Context, query *login.GetAuthInfoQuery) (*login.UserAuth, error)) *MockAuthInfoService_GetAuthInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetUserLabels provides a mock function for the type MockAuthInfoService
|
|
func (_mock *MockAuthInfoService) GetUserLabels(ctx context.Context, query login.GetUserLabelsQuery) (map[int64]string, error) {
|
|
ret := _mock.Called(ctx, query)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserLabels")
|
|
}
|
|
|
|
var r0 map[int64]string
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, login.GetUserLabelsQuery) (map[int64]string, error)); ok {
|
|
return returnFunc(ctx, query)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, login.GetUserLabelsQuery) map[int64]string); ok {
|
|
r0 = returnFunc(ctx, query)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[int64]string)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, login.GetUserLabelsQuery) error); ok {
|
|
r1 = returnFunc(ctx, query)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAuthInfoService_GetUserLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserLabels'
|
|
type MockAuthInfoService_GetUserLabels_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetUserLabels is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - query login.GetUserLabelsQuery
|
|
func (_e *MockAuthInfoService_Expecter) GetUserLabels(ctx interface{}, query interface{}) *MockAuthInfoService_GetUserLabels_Call {
|
|
return &MockAuthInfoService_GetUserLabels_Call{Call: _e.mock.On("GetUserLabels", ctx, query)}
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_GetUserLabels_Call) Run(run func(ctx context.Context, query login.GetUserLabelsQuery)) *MockAuthInfoService_GetUserLabels_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 login.GetUserLabelsQuery
|
|
if args[1] != nil {
|
|
arg1 = args[1].(login.GetUserLabelsQuery)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_GetUserLabels_Call) Return(int64ToString map[int64]string, err error) *MockAuthInfoService_GetUserLabels_Call {
|
|
_c.Call.Return(int64ToString, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_GetUserLabels_Call) RunAndReturn(run func(ctx context.Context, query login.GetUserLabelsQuery) (map[int64]string, error)) *MockAuthInfoService_GetUserLabels_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetAuthInfo provides a mock function for the type MockAuthInfoService
|
|
func (_mock *MockAuthInfoService) SetAuthInfo(ctx context.Context, cmd *login.SetAuthInfoCommand) error {
|
|
ret := _mock.Called(ctx, cmd)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetAuthInfo")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *login.SetAuthInfoCommand) error); ok {
|
|
r0 = returnFunc(ctx, cmd)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAuthInfoService_SetAuthInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAuthInfo'
|
|
type MockAuthInfoService_SetAuthInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetAuthInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - cmd *login.SetAuthInfoCommand
|
|
func (_e *MockAuthInfoService_Expecter) SetAuthInfo(ctx interface{}, cmd interface{}) *MockAuthInfoService_SetAuthInfo_Call {
|
|
return &MockAuthInfoService_SetAuthInfo_Call{Call: _e.mock.On("SetAuthInfo", ctx, cmd)}
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_SetAuthInfo_Call) Run(run func(ctx context.Context, cmd *login.SetAuthInfoCommand)) *MockAuthInfoService_SetAuthInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *login.SetAuthInfoCommand
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*login.SetAuthInfoCommand)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_SetAuthInfo_Call) Return(err error) *MockAuthInfoService_SetAuthInfo_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_SetAuthInfo_Call) RunAndReturn(run func(ctx context.Context, cmd *login.SetAuthInfoCommand) error) *MockAuthInfoService_SetAuthInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateAuthInfo provides a mock function for the type MockAuthInfoService
|
|
func (_mock *MockAuthInfoService) UpdateAuthInfo(ctx context.Context, cmd *login.UpdateAuthInfoCommand) error {
|
|
ret := _mock.Called(ctx, cmd)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateAuthInfo")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *login.UpdateAuthInfoCommand) error); ok {
|
|
r0 = returnFunc(ctx, cmd)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAuthInfoService_UpdateAuthInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAuthInfo'
|
|
type MockAuthInfoService_UpdateAuthInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateAuthInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - cmd *login.UpdateAuthInfoCommand
|
|
func (_e *MockAuthInfoService_Expecter) UpdateAuthInfo(ctx interface{}, cmd interface{}) *MockAuthInfoService_UpdateAuthInfo_Call {
|
|
return &MockAuthInfoService_UpdateAuthInfo_Call{Call: _e.mock.On("UpdateAuthInfo", ctx, cmd)}
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_UpdateAuthInfo_Call) Run(run func(ctx context.Context, cmd *login.UpdateAuthInfoCommand)) *MockAuthInfoService_UpdateAuthInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *login.UpdateAuthInfoCommand
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*login.UpdateAuthInfoCommand)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_UpdateAuthInfo_Call) Return(err error) *MockAuthInfoService_UpdateAuthInfo_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAuthInfoService_UpdateAuthInfo_Call) RunAndReturn(run func(ctx context.Context, cmd *login.UpdateAuthInfoCommand) error) *MockAuthInfoService_UpdateAuthInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockStore creates a new instance of MockStore. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewMockStore(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockStore {
|
|
mock := &MockStore{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|
|
|
|
// MockStore is an autogenerated mock type for the Store type
|
|
type MockStore struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockStore_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockStore) EXPECT() *MockStore_Expecter {
|
|
return &MockStore_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// DeleteUserAuthInfo provides a mock function for the type MockStore
|
|
func (_mock *MockStore) DeleteUserAuthInfo(ctx context.Context, userID int64) error {
|
|
ret := _mock.Called(ctx, userID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteUserAuthInfo")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, int64) error); ok {
|
|
r0 = returnFunc(ctx, userID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockStore_DeleteUserAuthInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUserAuthInfo'
|
|
type MockStore_DeleteUserAuthInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteUserAuthInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - userID int64
|
|
func (_e *MockStore_Expecter) DeleteUserAuthInfo(ctx interface{}, userID interface{}) *MockStore_DeleteUserAuthInfo_Call {
|
|
return &MockStore_DeleteUserAuthInfo_Call{Call: _e.mock.On("DeleteUserAuthInfo", ctx, userID)}
|
|
}
|
|
|
|
func (_c *MockStore_DeleteUserAuthInfo_Call) Run(run func(ctx context.Context, userID int64)) *MockStore_DeleteUserAuthInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 int64
|
|
if args[1] != nil {
|
|
arg1 = args[1].(int64)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_DeleteUserAuthInfo_Call) Return(err error) *MockStore_DeleteUserAuthInfo_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_DeleteUserAuthInfo_Call) RunAndReturn(run func(ctx context.Context, userID int64) error) *MockStore_DeleteUserAuthInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAuthInfo provides a mock function for the type MockStore
|
|
func (_mock *MockStore) GetAuthInfo(ctx context.Context, query *login.GetAuthInfoQuery) (*login.UserAuth, error) {
|
|
ret := _mock.Called(ctx, query)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAuthInfo")
|
|
}
|
|
|
|
var r0 *login.UserAuth
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *login.GetAuthInfoQuery) (*login.UserAuth, error)); ok {
|
|
return returnFunc(ctx, query)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *login.GetAuthInfoQuery) *login.UserAuth); ok {
|
|
r0 = returnFunc(ctx, query)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*login.UserAuth)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *login.GetAuthInfoQuery) error); ok {
|
|
r1 = returnFunc(ctx, query)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockStore_GetAuthInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuthInfo'
|
|
type MockStore_GetAuthInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAuthInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - query *login.GetAuthInfoQuery
|
|
func (_e *MockStore_Expecter) GetAuthInfo(ctx interface{}, query interface{}) *MockStore_GetAuthInfo_Call {
|
|
return &MockStore_GetAuthInfo_Call{Call: _e.mock.On("GetAuthInfo", ctx, query)}
|
|
}
|
|
|
|
func (_c *MockStore_GetAuthInfo_Call) Run(run func(ctx context.Context, query *login.GetAuthInfoQuery)) *MockStore_GetAuthInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *login.GetAuthInfoQuery
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*login.GetAuthInfoQuery)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_GetAuthInfo_Call) Return(userAuth *login.UserAuth, err error) *MockStore_GetAuthInfo_Call {
|
|
_c.Call.Return(userAuth, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_GetAuthInfo_Call) RunAndReturn(run func(ctx context.Context, query *login.GetAuthInfoQuery) (*login.UserAuth, error)) *MockStore_GetAuthInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetUserLabels provides a mock function for the type MockStore
|
|
func (_mock *MockStore) GetUserLabels(ctx context.Context, query login.GetUserLabelsQuery) (map[int64]string, error) {
|
|
ret := _mock.Called(ctx, query)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserLabels")
|
|
}
|
|
|
|
var r0 map[int64]string
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, login.GetUserLabelsQuery) (map[int64]string, error)); ok {
|
|
return returnFunc(ctx, query)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, login.GetUserLabelsQuery) map[int64]string); ok {
|
|
r0 = returnFunc(ctx, query)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[int64]string)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, login.GetUserLabelsQuery) error); ok {
|
|
r1 = returnFunc(ctx, query)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockStore_GetUserLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserLabels'
|
|
type MockStore_GetUserLabels_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetUserLabels is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - query login.GetUserLabelsQuery
|
|
func (_e *MockStore_Expecter) GetUserLabels(ctx interface{}, query interface{}) *MockStore_GetUserLabels_Call {
|
|
return &MockStore_GetUserLabels_Call{Call: _e.mock.On("GetUserLabels", ctx, query)}
|
|
}
|
|
|
|
func (_c *MockStore_GetUserLabels_Call) Run(run func(ctx context.Context, query login.GetUserLabelsQuery)) *MockStore_GetUserLabels_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 login.GetUserLabelsQuery
|
|
if args[1] != nil {
|
|
arg1 = args[1].(login.GetUserLabelsQuery)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_GetUserLabels_Call) Return(int64ToString map[int64]string, err error) *MockStore_GetUserLabels_Call {
|
|
_c.Call.Return(int64ToString, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_GetUserLabels_Call) RunAndReturn(run func(ctx context.Context, query login.GetUserLabelsQuery) (map[int64]string, error)) *MockStore_GetUserLabels_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetAuthInfo provides a mock function for the type MockStore
|
|
func (_mock *MockStore) SetAuthInfo(ctx context.Context, cmd *login.SetAuthInfoCommand) error {
|
|
ret := _mock.Called(ctx, cmd)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetAuthInfo")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *login.SetAuthInfoCommand) error); ok {
|
|
r0 = returnFunc(ctx, cmd)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockStore_SetAuthInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAuthInfo'
|
|
type MockStore_SetAuthInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetAuthInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - cmd *login.SetAuthInfoCommand
|
|
func (_e *MockStore_Expecter) SetAuthInfo(ctx interface{}, cmd interface{}) *MockStore_SetAuthInfo_Call {
|
|
return &MockStore_SetAuthInfo_Call{Call: _e.mock.On("SetAuthInfo", ctx, cmd)}
|
|
}
|
|
|
|
func (_c *MockStore_SetAuthInfo_Call) Run(run func(ctx context.Context, cmd *login.SetAuthInfoCommand)) *MockStore_SetAuthInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *login.SetAuthInfoCommand
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*login.SetAuthInfoCommand)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_SetAuthInfo_Call) Return(err error) *MockStore_SetAuthInfo_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_SetAuthInfo_Call) RunAndReturn(run func(ctx context.Context, cmd *login.SetAuthInfoCommand) error) *MockStore_SetAuthInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateAuthInfo provides a mock function for the type MockStore
|
|
func (_mock *MockStore) UpdateAuthInfo(ctx context.Context, cmd *login.UpdateAuthInfoCommand) error {
|
|
ret := _mock.Called(ctx, cmd)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateAuthInfo")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *login.UpdateAuthInfoCommand) error); ok {
|
|
r0 = returnFunc(ctx, cmd)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockStore_UpdateAuthInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAuthInfo'
|
|
type MockStore_UpdateAuthInfo_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateAuthInfo is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - cmd *login.UpdateAuthInfoCommand
|
|
func (_e *MockStore_Expecter) UpdateAuthInfo(ctx interface{}, cmd interface{}) *MockStore_UpdateAuthInfo_Call {
|
|
return &MockStore_UpdateAuthInfo_Call{Call: _e.mock.On("UpdateAuthInfo", ctx, cmd)}
|
|
}
|
|
|
|
func (_c *MockStore_UpdateAuthInfo_Call) Run(run func(ctx context.Context, cmd *login.UpdateAuthInfoCommand)) *MockStore_UpdateAuthInfo_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *login.UpdateAuthInfoCommand
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*login.UpdateAuthInfoCommand)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_UpdateAuthInfo_Call) Return(err error) *MockStore_UpdateAuthInfo_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockStore_UpdateAuthInfo_Call) RunAndReturn(run func(ctx context.Context, cmd *login.UpdateAuthInfoCommand) error) *MockStore_UpdateAuthInfo_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockUserProtectionService creates a new instance of MockUserProtectionService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
|
|
// The first argument is typically a *testing.T value.
|
|
func NewMockUserProtectionService(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockUserProtectionService {
|
|
mock := &MockUserProtectionService{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|
|
|
|
// MockUserProtectionService is an autogenerated mock type for the UserProtectionService type
|
|
type MockUserProtectionService struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockUserProtectionService_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockUserProtectionService) EXPECT() *MockUserProtectionService_Expecter {
|
|
return &MockUserProtectionService_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// AllowUserMapping provides a mock function for the type MockUserProtectionService
|
|
func (_mock *MockUserProtectionService) AllowUserMapping(user1 *user.User, authModule string) error {
|
|
ret := _mock.Called(user1, authModule)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AllowUserMapping")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(*user.User, string) error); ok {
|
|
r0 = returnFunc(user1, authModule)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockUserProtectionService_AllowUserMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllowUserMapping'
|
|
type MockUserProtectionService_AllowUserMapping_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AllowUserMapping is a helper method to define mock.On call
|
|
// - user1 *user.User
|
|
// - authModule string
|
|
func (_e *MockUserProtectionService_Expecter) AllowUserMapping(user1 interface{}, authModule interface{}) *MockUserProtectionService_AllowUserMapping_Call {
|
|
return &MockUserProtectionService_AllowUserMapping_Call{Call: _e.mock.On("AllowUserMapping", user1, authModule)}
|
|
}
|
|
|
|
func (_c *MockUserProtectionService_AllowUserMapping_Call) Run(run func(user1 *user.User, authModule string)) *MockUserProtectionService_AllowUserMapping_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 *user.User
|
|
if args[0] != nil {
|
|
arg0 = args[0].(*user.User)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockUserProtectionService_AllowUserMapping_Call) Return(err error) *MockUserProtectionService_AllowUserMapping_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockUserProtectionService_AllowUserMapping_Call) RunAndReturn(run func(user1 *user.User, authModule string) error) *MockUserProtectionService_AllowUserMapping_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|