mirror of
https://github.com/absmach/magistrala.git
synced 2026-06-23 04:10:28 +00:00
Dušan Borovčanin
1864 lines
55 KiB
Go
1864 lines
55 KiB
Go
// Copyright (c) Abstract Machines
|
|
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
// Code generated by mockery; DO NOT EDIT.
|
|
// github.com/vektra/mockery
|
|
// template: testify
|
|
|
|
package mocks
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/absmach/magistrala/api/grpc/token/v1"
|
|
"github.com/absmach/magistrala/pkg/authn"
|
|
"github.com/absmach/magistrala/users"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// NewService creates a new instance of Service. 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 NewService(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *Service {
|
|
mock := &Service{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|
|
|
|
// Service is an autogenerated mock type for the Service type
|
|
type Service struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type Service_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *Service) EXPECT() *Service_Expecter {
|
|
return &Service_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// Delete provides a mock function for the type Service
|
|
func (_mock *Service) Delete(ctx context.Context, session authn.Session, id string) error {
|
|
ret := _mock.Called(ctx, session, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Delete")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) error); ok {
|
|
r0 = returnFunc(ctx, session, id)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// Service_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
|
|
type Service_Delete_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Delete is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - id string
|
|
func (_e *Service_Expecter) Delete(ctx interface{}, session interface{}, id interface{}) *Service_Delete_Call {
|
|
return &Service_Delete_Call{Call: _e.mock.On("Delete", ctx, session, id)}
|
|
}
|
|
|
|
func (_c *Service_Delete_Call) Run(run func(ctx context.Context, session authn.Session, id string)) *Service_Delete_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Delete_Call) Return(err error) *Service_Delete_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Delete_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string) error) *Service_Delete_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Disable provides a mock function for the type Service
|
|
func (_mock *Service) Disable(ctx context.Context, session authn.Session, id string) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Disable")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, id)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) users.User); ok {
|
|
r0 = returnFunc(ctx, session, id)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string) error); ok {
|
|
r1 = returnFunc(ctx, session, id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_Disable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Disable'
|
|
type Service_Disable_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Disable is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - id string
|
|
func (_e *Service_Expecter) Disable(ctx interface{}, session interface{}, id interface{}) *Service_Disable_Call {
|
|
return &Service_Disable_Call{Call: _e.mock.On("Disable", ctx, session, id)}
|
|
}
|
|
|
|
func (_c *Service_Disable_Call) Run(run func(ctx context.Context, session authn.Session, id string)) *Service_Disable_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Disable_Call) Return(user users.User, err error) *Service_Disable_Call {
|
|
_c.Call.Return(user, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Disable_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string) (users.User, error)) *Service_Disable_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Enable provides a mock function for the type Service
|
|
func (_mock *Service) Enable(ctx context.Context, session authn.Session, id string) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Enable")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, id)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) users.User); ok {
|
|
r0 = returnFunc(ctx, session, id)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string) error); ok {
|
|
r1 = returnFunc(ctx, session, id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_Enable_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Enable'
|
|
type Service_Enable_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Enable is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - id string
|
|
func (_e *Service_Expecter) Enable(ctx interface{}, session interface{}, id interface{}) *Service_Enable_Call {
|
|
return &Service_Enable_Call{Call: _e.mock.On("Enable", ctx, session, id)}
|
|
}
|
|
|
|
func (_c *Service_Enable_Call) Run(run func(ctx context.Context, session authn.Session, id string)) *Service_Enable_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Enable_Call) Return(user users.User, err error) *Service_Enable_Call {
|
|
_c.Call.Return(user, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Enable_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string) (users.User, error)) *Service_Enable_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Identify provides a mock function for the type Service
|
|
func (_mock *Service) Identify(ctx context.Context, session authn.Session) (string, error) {
|
|
ret := _mock.Called(ctx, session)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Identify")
|
|
}
|
|
|
|
var r0 string
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) (string, error)); ok {
|
|
return returnFunc(ctx, session)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) string); ok {
|
|
r0 = returnFunc(ctx, session)
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session) error); ok {
|
|
r1 = returnFunc(ctx, session)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_Identify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Identify'
|
|
type Service_Identify_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Identify is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
func (_e *Service_Expecter) Identify(ctx interface{}, session interface{}) *Service_Identify_Call {
|
|
return &Service_Identify_Call{Call: _e.mock.On("Identify", ctx, session)}
|
|
}
|
|
|
|
func (_c *Service_Identify_Call) Run(run func(ctx context.Context, session authn.Session)) *Service_Identify_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Identify_Call) Return(s string, err error) *Service_Identify_Call {
|
|
_c.Call.Return(s, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Identify_Call) RunAndReturn(run func(ctx context.Context, session authn.Session) (string, error)) *Service_Identify_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// IssueToken provides a mock function for the type Service
|
|
func (_mock *Service) IssueToken(ctx context.Context, identity string, secret string, description string) (*v1.Token, error) {
|
|
ret := _mock.Called(ctx, identity, secret, description)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for IssueToken")
|
|
}
|
|
|
|
var r0 *v1.Token
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*v1.Token, error)); ok {
|
|
return returnFunc(ctx, identity, secret, description)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *v1.Token); ok {
|
|
r0 = returnFunc(ctx, identity, secret, description)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1.Token)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok {
|
|
r1 = returnFunc(ctx, identity, secret, description)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_IssueToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IssueToken'
|
|
type Service_IssueToken_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// IssueToken is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - identity string
|
|
// - secret string
|
|
// - description string
|
|
func (_e *Service_Expecter) IssueToken(ctx interface{}, identity interface{}, secret interface{}, description interface{}) *Service_IssueToken_Call {
|
|
return &Service_IssueToken_Call{Call: _e.mock.On("IssueToken", ctx, identity, secret, description)}
|
|
}
|
|
|
|
func (_c *Service_IssueToken_Call) Run(run func(ctx context.Context, identity string, secret string, description string)) *Service_IssueToken_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
var arg3 string
|
|
if args[3] != nil {
|
|
arg3 = args[3].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_IssueToken_Call) Return(token *v1.Token, err error) *Service_IssueToken_Call {
|
|
_c.Call.Return(token, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_IssueToken_Call) RunAndReturn(run func(ctx context.Context, identity string, secret string, description string) (*v1.Token, error)) *Service_IssueToken_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListActiveRefreshTokens provides a mock function for the type Service
|
|
func (_mock *Service) ListActiveRefreshTokens(ctx context.Context, session authn.Session) (*v1.ListUserRefreshTokensRes, error) {
|
|
ret := _mock.Called(ctx, session)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListActiveRefreshTokens")
|
|
}
|
|
|
|
var r0 *v1.ListUserRefreshTokensRes
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) (*v1.ListUserRefreshTokensRes, error)); ok {
|
|
return returnFunc(ctx, session)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) *v1.ListUserRefreshTokensRes); ok {
|
|
r0 = returnFunc(ctx, session)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1.ListUserRefreshTokensRes)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session) error); ok {
|
|
r1 = returnFunc(ctx, session)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_ListActiveRefreshTokens_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActiveRefreshTokens'
|
|
type Service_ListActiveRefreshTokens_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListActiveRefreshTokens is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
func (_e *Service_Expecter) ListActiveRefreshTokens(ctx interface{}, session interface{}) *Service_ListActiveRefreshTokens_Call {
|
|
return &Service_ListActiveRefreshTokens_Call{Call: _e.mock.On("ListActiveRefreshTokens", ctx, session)}
|
|
}
|
|
|
|
func (_c *Service_ListActiveRefreshTokens_Call) Run(run func(ctx context.Context, session authn.Session)) *Service_ListActiveRefreshTokens_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_ListActiveRefreshTokens_Call) Return(listUserRefreshTokensRes *v1.ListUserRefreshTokensRes, err error) *Service_ListActiveRefreshTokens_Call {
|
|
_c.Call.Return(listUserRefreshTokensRes, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_ListActiveRefreshTokens_Call) RunAndReturn(run func(ctx context.Context, session authn.Session) (*v1.ListUserRefreshTokensRes, error)) *Service_ListActiveRefreshTokens_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListUsers provides a mock function for the type Service
|
|
func (_mock *Service) ListUsers(ctx context.Context, session authn.Session, pm users.Page) (users.UsersPage, error) {
|
|
ret := _mock.Called(ctx, session, pm)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListUsers")
|
|
}
|
|
|
|
var r0 users.UsersPage
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.Page) (users.UsersPage, error)); ok {
|
|
return returnFunc(ctx, session, pm)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.Page) users.UsersPage); ok {
|
|
r0 = returnFunc(ctx, session, pm)
|
|
} else {
|
|
r0 = ret.Get(0).(users.UsersPage)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, users.Page) error); ok {
|
|
r1 = returnFunc(ctx, session, pm)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_ListUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListUsers'
|
|
type Service_ListUsers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListUsers is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - pm users.Page
|
|
func (_e *Service_Expecter) ListUsers(ctx interface{}, session interface{}, pm interface{}) *Service_ListUsers_Call {
|
|
return &Service_ListUsers_Call{Call: _e.mock.On("ListUsers", ctx, session, pm)}
|
|
}
|
|
|
|
func (_c *Service_ListUsers_Call) Run(run func(ctx context.Context, session authn.Session, pm users.Page)) *Service_ListUsers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 users.Page
|
|
if args[2] != nil {
|
|
arg2 = args[2].(users.Page)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_ListUsers_Call) Return(usersPage users.UsersPage, err error) *Service_ListUsers_Call {
|
|
_c.Call.Return(usersPage, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_ListUsers_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, pm users.Page) (users.UsersPage, error)) *Service_ListUsers_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// OAuthAddUserPolicy provides a mock function for the type Service
|
|
func (_mock *Service) OAuthAddUserPolicy(ctx context.Context, user users.User) error {
|
|
ret := _mock.Called(ctx, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OAuthAddUserPolicy")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, users.User) error); ok {
|
|
r0 = returnFunc(ctx, user)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// Service_OAuthAddUserPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OAuthAddUserPolicy'
|
|
type Service_OAuthAddUserPolicy_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// OAuthAddUserPolicy is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - user users.User
|
|
func (_e *Service_Expecter) OAuthAddUserPolicy(ctx interface{}, user interface{}) *Service_OAuthAddUserPolicy_Call {
|
|
return &Service_OAuthAddUserPolicy_Call{Call: _e.mock.On("OAuthAddUserPolicy", ctx, user)}
|
|
}
|
|
|
|
func (_c *Service_OAuthAddUserPolicy_Call) Run(run func(ctx context.Context, user users.User)) *Service_OAuthAddUserPolicy_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 users.User
|
|
if args[1] != nil {
|
|
arg1 = args[1].(users.User)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_OAuthAddUserPolicy_Call) Return(err error) *Service_OAuthAddUserPolicy_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_OAuthAddUserPolicy_Call) RunAndReturn(run func(ctx context.Context, user users.User) error) *Service_OAuthAddUserPolicy_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// OAuthCallback provides a mock function for the type Service
|
|
func (_mock *Service) OAuthCallback(ctx context.Context, user users.User) (users.User, error) {
|
|
ret := _mock.Called(ctx, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OAuthCallback")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, users.User) (users.User, error)); ok {
|
|
return returnFunc(ctx, user)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, users.User) users.User); ok {
|
|
r0 = returnFunc(ctx, user)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, users.User) error); ok {
|
|
r1 = returnFunc(ctx, user)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_OAuthCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OAuthCallback'
|
|
type Service_OAuthCallback_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// OAuthCallback is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - user users.User
|
|
func (_e *Service_Expecter) OAuthCallback(ctx interface{}, user interface{}) *Service_OAuthCallback_Call {
|
|
return &Service_OAuthCallback_Call{Call: _e.mock.On("OAuthCallback", ctx, user)}
|
|
}
|
|
|
|
func (_c *Service_OAuthCallback_Call) Run(run func(ctx context.Context, user users.User)) *Service_OAuthCallback_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 users.User
|
|
if args[1] != nil {
|
|
arg1 = args[1].(users.User)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_OAuthCallback_Call) Return(user1 users.User, err error) *Service_OAuthCallback_Call {
|
|
_c.Call.Return(user1, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_OAuthCallback_Call) RunAndReturn(run func(ctx context.Context, user users.User) (users.User, error)) *Service_OAuthCallback_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RefreshToken provides a mock function for the type Service
|
|
func (_mock *Service) RefreshToken(ctx context.Context, session authn.Session, refreshToken string) (*v1.Token, error) {
|
|
ret := _mock.Called(ctx, session, refreshToken)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RefreshToken")
|
|
}
|
|
|
|
var r0 *v1.Token
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) (*v1.Token, error)); ok {
|
|
return returnFunc(ctx, session, refreshToken)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) *v1.Token); ok {
|
|
r0 = returnFunc(ctx, session, refreshToken)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1.Token)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string) error); ok {
|
|
r1 = returnFunc(ctx, session, refreshToken)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_RefreshToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RefreshToken'
|
|
type Service_RefreshToken_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RefreshToken is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - refreshToken string
|
|
func (_e *Service_Expecter) RefreshToken(ctx interface{}, session interface{}, refreshToken interface{}) *Service_RefreshToken_Call {
|
|
return &Service_RefreshToken_Call{Call: _e.mock.On("RefreshToken", ctx, session, refreshToken)}
|
|
}
|
|
|
|
func (_c *Service_RefreshToken_Call) Run(run func(ctx context.Context, session authn.Session, refreshToken string)) *Service_RefreshToken_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_RefreshToken_Call) Return(token *v1.Token, err error) *Service_RefreshToken_Call {
|
|
_c.Call.Return(token, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_RefreshToken_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, refreshToken string) (*v1.Token, error)) *Service_RefreshToken_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Register provides a mock function for the type Service
|
|
func (_mock *Service) Register(ctx context.Context, session authn.Session, user users.User, selfRegister bool) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, user, selfRegister)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Register")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.User, bool) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, user, selfRegister)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.User, bool) users.User); ok {
|
|
r0 = returnFunc(ctx, session, user, selfRegister)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, users.User, bool) error); ok {
|
|
r1 = returnFunc(ctx, session, user, selfRegister)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_Register_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Register'
|
|
type Service_Register_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Register is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - user users.User
|
|
// - selfRegister bool
|
|
func (_e *Service_Expecter) Register(ctx interface{}, session interface{}, user interface{}, selfRegister interface{}) *Service_Register_Call {
|
|
return &Service_Register_Call{Call: _e.mock.On("Register", ctx, session, user, selfRegister)}
|
|
}
|
|
|
|
func (_c *Service_Register_Call) Run(run func(ctx context.Context, session authn.Session, user users.User, selfRegister bool)) *Service_Register_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 users.User
|
|
if args[2] != nil {
|
|
arg2 = args[2].(users.User)
|
|
}
|
|
var arg3 bool
|
|
if args[3] != nil {
|
|
arg3 = args[3].(bool)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Register_Call) Return(user1 users.User, err error) *Service_Register_Call {
|
|
_c.Call.Return(user1, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Register_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, user users.User, selfRegister bool) (users.User, error)) *Service_Register_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ResetSecret provides a mock function for the type Service
|
|
func (_mock *Service) ResetSecret(ctx context.Context, session authn.Session, secret string) error {
|
|
ret := _mock.Called(ctx, session, secret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ResetSecret")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) error); ok {
|
|
r0 = returnFunc(ctx, session, secret)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// Service_ResetSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetSecret'
|
|
type Service_ResetSecret_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ResetSecret is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - secret string
|
|
func (_e *Service_Expecter) ResetSecret(ctx interface{}, session interface{}, secret interface{}) *Service_ResetSecret_Call {
|
|
return &Service_ResetSecret_Call{Call: _e.mock.On("ResetSecret", ctx, session, secret)}
|
|
}
|
|
|
|
func (_c *Service_ResetSecret_Call) Run(run func(ctx context.Context, session authn.Session, secret string)) *Service_ResetSecret_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_ResetSecret_Call) Return(err error) *Service_ResetSecret_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_ResetSecret_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, secret string) error) *Service_ResetSecret_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RevokeRefreshToken provides a mock function for the type Service
|
|
func (_mock *Service) RevokeRefreshToken(ctx context.Context, session authn.Session, tokenID string) error {
|
|
ret := _mock.Called(ctx, session, tokenID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RevokeRefreshToken")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) error); ok {
|
|
r0 = returnFunc(ctx, session, tokenID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// Service_RevokeRefreshToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeRefreshToken'
|
|
type Service_RevokeRefreshToken_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RevokeRefreshToken is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - tokenID string
|
|
func (_e *Service_Expecter) RevokeRefreshToken(ctx interface{}, session interface{}, tokenID interface{}) *Service_RevokeRefreshToken_Call {
|
|
return &Service_RevokeRefreshToken_Call{Call: _e.mock.On("RevokeRefreshToken", ctx, session, tokenID)}
|
|
}
|
|
|
|
func (_c *Service_RevokeRefreshToken_Call) Run(run func(ctx context.Context, session authn.Session, tokenID string)) *Service_RevokeRefreshToken_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_RevokeRefreshToken_Call) Return(err error) *Service_RevokeRefreshToken_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_RevokeRefreshToken_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, tokenID string) error) *Service_RevokeRefreshToken_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SearchUsers provides a mock function for the type Service
|
|
func (_mock *Service) SearchUsers(ctx context.Context, pm users.Page) (users.UsersPage, error) {
|
|
ret := _mock.Called(ctx, pm)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SearchUsers")
|
|
}
|
|
|
|
var r0 users.UsersPage
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, users.Page) (users.UsersPage, error)); ok {
|
|
return returnFunc(ctx, pm)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, users.Page) users.UsersPage); ok {
|
|
r0 = returnFunc(ctx, pm)
|
|
} else {
|
|
r0 = ret.Get(0).(users.UsersPage)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, users.Page) error); ok {
|
|
r1 = returnFunc(ctx, pm)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_SearchUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchUsers'
|
|
type Service_SearchUsers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SearchUsers is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - pm users.Page
|
|
func (_e *Service_Expecter) SearchUsers(ctx interface{}, pm interface{}) *Service_SearchUsers_Call {
|
|
return &Service_SearchUsers_Call{Call: _e.mock.On("SearchUsers", ctx, pm)}
|
|
}
|
|
|
|
func (_c *Service_SearchUsers_Call) Run(run func(ctx context.Context, pm users.Page)) *Service_SearchUsers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 users.Page
|
|
if args[1] != nil {
|
|
arg1 = args[1].(users.Page)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_SearchUsers_Call) Return(usersPage users.UsersPage, err error) *Service_SearchUsers_Call {
|
|
_c.Call.Return(usersPage, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_SearchUsers_Call) RunAndReturn(run func(ctx context.Context, pm users.Page) (users.UsersPage, error)) *Service_SearchUsers_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SendPasswordReset provides a mock function for the type Service
|
|
func (_mock *Service) SendPasswordReset(ctx context.Context, email string) error {
|
|
ret := _mock.Called(ctx, email)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SendPasswordReset")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = returnFunc(ctx, email)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// Service_SendPasswordReset_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendPasswordReset'
|
|
type Service_SendPasswordReset_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SendPasswordReset is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - email string
|
|
func (_e *Service_Expecter) SendPasswordReset(ctx interface{}, email interface{}) *Service_SendPasswordReset_Call {
|
|
return &Service_SendPasswordReset_Call{Call: _e.mock.On("SendPasswordReset", ctx, email)}
|
|
}
|
|
|
|
func (_c *Service_SendPasswordReset_Call) Run(run func(ctx context.Context, email string)) *Service_SendPasswordReset_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_SendPasswordReset_Call) Return(err error) *Service_SendPasswordReset_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_SendPasswordReset_Call) RunAndReturn(run func(ctx context.Context, email string) error) *Service_SendPasswordReset_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SendVerification provides a mock function for the type Service
|
|
func (_mock *Service) SendVerification(ctx context.Context, session authn.Session) error {
|
|
ret := _mock.Called(ctx, session)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SendVerification")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) error); ok {
|
|
r0 = returnFunc(ctx, session)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// Service_SendVerification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendVerification'
|
|
type Service_SendVerification_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SendVerification is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
func (_e *Service_Expecter) SendVerification(ctx interface{}, session interface{}) *Service_SendVerification_Call {
|
|
return &Service_SendVerification_Call{Call: _e.mock.On("SendVerification", ctx, session)}
|
|
}
|
|
|
|
func (_c *Service_SendVerification_Call) Run(run func(ctx context.Context, session authn.Session)) *Service_SendVerification_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_SendVerification_Call) Return(err error) *Service_SendVerification_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_SendVerification_Call) RunAndReturn(run func(ctx context.Context, session authn.Session) error) *Service_SendVerification_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Update provides a mock function for the type Service
|
|
func (_mock *Service) Update(ctx context.Context, session authn.Session, id string, user users.UserReq) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, id, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Update")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, id, user)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) users.User); ok {
|
|
r0 = returnFunc(ctx, session, id, user)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, users.UserReq) error); ok {
|
|
r1 = returnFunc(ctx, session, id, user)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
|
|
type Service_Update_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Update is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - id string
|
|
// - user users.UserReq
|
|
func (_e *Service_Expecter) Update(ctx interface{}, session interface{}, id interface{}, user interface{}) *Service_Update_Call {
|
|
return &Service_Update_Call{Call: _e.mock.On("Update", ctx, session, id, user)}
|
|
}
|
|
|
|
func (_c *Service_Update_Call) Run(run func(ctx context.Context, session authn.Session, id string, user users.UserReq)) *Service_Update_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
var arg3 users.UserReq
|
|
if args[3] != nil {
|
|
arg3 = args[3].(users.UserReq)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Update_Call) Return(user1 users.User, err error) *Service_Update_Call {
|
|
_c.Call.Return(user1, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_Update_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, user users.UserReq) (users.User, error)) *Service_Update_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateEmail provides a mock function for the type Service
|
|
func (_mock *Service) UpdateEmail(ctx context.Context, session authn.Session, id string, email string) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, id, email)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateEmail")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, id, email)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) users.User); ok {
|
|
r0 = returnFunc(ctx, session, id, email)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string) error); ok {
|
|
r1 = returnFunc(ctx, session, id, email)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_UpdateEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEmail'
|
|
type Service_UpdateEmail_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateEmail is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - id string
|
|
// - email string
|
|
func (_e *Service_Expecter) UpdateEmail(ctx interface{}, session interface{}, id interface{}, email interface{}) *Service_UpdateEmail_Call {
|
|
return &Service_UpdateEmail_Call{Call: _e.mock.On("UpdateEmail", ctx, session, id, email)}
|
|
}
|
|
|
|
func (_c *Service_UpdateEmail_Call) Run(run func(ctx context.Context, session authn.Session, id string, email string)) *Service_UpdateEmail_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
var arg3 string
|
|
if args[3] != nil {
|
|
arg3 = args[3].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateEmail_Call) Return(user users.User, err error) *Service_UpdateEmail_Call {
|
|
_c.Call.Return(user, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateEmail_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, email string) (users.User, error)) *Service_UpdateEmail_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateProfilePicture provides a mock function for the type Service
|
|
func (_mock *Service) UpdateProfilePicture(ctx context.Context, session authn.Session, id string, usr users.UserReq) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, id, usr)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateProfilePicture")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, id, usr)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) users.User); ok {
|
|
r0 = returnFunc(ctx, session, id, usr)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, users.UserReq) error); ok {
|
|
r1 = returnFunc(ctx, session, id, usr)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_UpdateProfilePicture_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateProfilePicture'
|
|
type Service_UpdateProfilePicture_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateProfilePicture is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - id string
|
|
// - usr users.UserReq
|
|
func (_e *Service_Expecter) UpdateProfilePicture(ctx interface{}, session interface{}, id interface{}, usr interface{}) *Service_UpdateProfilePicture_Call {
|
|
return &Service_UpdateProfilePicture_Call{Call: _e.mock.On("UpdateProfilePicture", ctx, session, id, usr)}
|
|
}
|
|
|
|
func (_c *Service_UpdateProfilePicture_Call) Run(run func(ctx context.Context, session authn.Session, id string, usr users.UserReq)) *Service_UpdateProfilePicture_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
var arg3 users.UserReq
|
|
if args[3] != nil {
|
|
arg3 = args[3].(users.UserReq)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateProfilePicture_Call) Return(user users.User, err error) *Service_UpdateProfilePicture_Call {
|
|
_c.Call.Return(user, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateProfilePicture_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, usr users.UserReq) (users.User, error)) *Service_UpdateProfilePicture_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateRole provides a mock function for the type Service
|
|
func (_mock *Service) UpdateRole(ctx context.Context, session authn.Session, user users.User) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateRole")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.User) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, user)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, users.User) users.User); ok {
|
|
r0 = returnFunc(ctx, session, user)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, users.User) error); ok {
|
|
r1 = returnFunc(ctx, session, user)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_UpdateRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRole'
|
|
type Service_UpdateRole_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateRole is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - user users.User
|
|
func (_e *Service_Expecter) UpdateRole(ctx interface{}, session interface{}, user interface{}) *Service_UpdateRole_Call {
|
|
return &Service_UpdateRole_Call{Call: _e.mock.On("UpdateRole", ctx, session, user)}
|
|
}
|
|
|
|
func (_c *Service_UpdateRole_Call) Run(run func(ctx context.Context, session authn.Session, user users.User)) *Service_UpdateRole_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 users.User
|
|
if args[2] != nil {
|
|
arg2 = args[2].(users.User)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateRole_Call) Return(user1 users.User, err error) *Service_UpdateRole_Call {
|
|
_c.Call.Return(user1, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateRole_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, user users.User) (users.User, error)) *Service_UpdateRole_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateSecret provides a mock function for the type Service
|
|
func (_mock *Service) UpdateSecret(ctx context.Context, session authn.Session, oldSecret string, newSecret string) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, oldSecret, newSecret)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateSecret")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, oldSecret, newSecret)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) users.User); ok {
|
|
r0 = returnFunc(ctx, session, oldSecret, newSecret)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string) error); ok {
|
|
r1 = returnFunc(ctx, session, oldSecret, newSecret)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_UpdateSecret_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateSecret'
|
|
type Service_UpdateSecret_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateSecret is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - oldSecret string
|
|
// - newSecret string
|
|
func (_e *Service_Expecter) UpdateSecret(ctx interface{}, session interface{}, oldSecret interface{}, newSecret interface{}) *Service_UpdateSecret_Call {
|
|
return &Service_UpdateSecret_Call{Call: _e.mock.On("UpdateSecret", ctx, session, oldSecret, newSecret)}
|
|
}
|
|
|
|
func (_c *Service_UpdateSecret_Call) Run(run func(ctx context.Context, session authn.Session, oldSecret string, newSecret string)) *Service_UpdateSecret_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
var arg3 string
|
|
if args[3] != nil {
|
|
arg3 = args[3].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateSecret_Call) Return(user users.User, err error) *Service_UpdateSecret_Call {
|
|
_c.Call.Return(user, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateSecret_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, oldSecret string, newSecret string) (users.User, error)) *Service_UpdateSecret_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateTags provides a mock function for the type Service
|
|
func (_mock *Service) UpdateTags(ctx context.Context, session authn.Session, id string, user users.UserReq) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, id, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateTags")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, id, user)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, users.UserReq) users.User); ok {
|
|
r0 = returnFunc(ctx, session, id, user)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, users.UserReq) error); ok {
|
|
r1 = returnFunc(ctx, session, id, user)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_UpdateTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTags'
|
|
type Service_UpdateTags_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateTags is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - id string
|
|
// - user users.UserReq
|
|
func (_e *Service_Expecter) UpdateTags(ctx interface{}, session interface{}, id interface{}, user interface{}) *Service_UpdateTags_Call {
|
|
return &Service_UpdateTags_Call{Call: _e.mock.On("UpdateTags", ctx, session, id, user)}
|
|
}
|
|
|
|
func (_c *Service_UpdateTags_Call) Run(run func(ctx context.Context, session authn.Session, id string, user users.UserReq)) *Service_UpdateTags_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
var arg3 users.UserReq
|
|
if args[3] != nil {
|
|
arg3 = args[3].(users.UserReq)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateTags_Call) Return(user1 users.User, err error) *Service_UpdateTags_Call {
|
|
_c.Call.Return(user1, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateTags_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, user users.UserReq) (users.User, error)) *Service_UpdateTags_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateUsername provides a mock function for the type Service
|
|
func (_mock *Service) UpdateUsername(ctx context.Context, session authn.Session, id string, username string) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, id, username)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateUsername")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, id, username)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) users.User); ok {
|
|
r0 = returnFunc(ctx, session, id, username)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string) error); ok {
|
|
r1 = returnFunc(ctx, session, id, username)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_UpdateUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUsername'
|
|
type Service_UpdateUsername_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateUsername is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - id string
|
|
// - username string
|
|
func (_e *Service_Expecter) UpdateUsername(ctx interface{}, session interface{}, id interface{}, username interface{}) *Service_UpdateUsername_Call {
|
|
return &Service_UpdateUsername_Call{Call: _e.mock.On("UpdateUsername", ctx, session, id, username)}
|
|
}
|
|
|
|
func (_c *Service_UpdateUsername_Call) Run(run func(ctx context.Context, session authn.Session, id string, username string)) *Service_UpdateUsername_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
var arg3 string
|
|
if args[3] != nil {
|
|
arg3 = args[3].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateUsername_Call) Return(user users.User, err error) *Service_UpdateUsername_Call {
|
|
_c.Call.Return(user, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_UpdateUsername_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, username string) (users.User, error)) *Service_UpdateUsername_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// VerifyEmail provides a mock function for the type Service
|
|
func (_mock *Service) VerifyEmail(ctx context.Context, verificationToken string) (users.User, error) {
|
|
ret := _mock.Called(ctx, verificationToken)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for VerifyEmail")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) (users.User, error)); ok {
|
|
return returnFunc(ctx, verificationToken)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) users.User); ok {
|
|
r0 = returnFunc(ctx, verificationToken)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(ctx, verificationToken)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_VerifyEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VerifyEmail'
|
|
type Service_VerifyEmail_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// VerifyEmail is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - verificationToken string
|
|
func (_e *Service_Expecter) VerifyEmail(ctx interface{}, verificationToken interface{}) *Service_VerifyEmail_Call {
|
|
return &Service_VerifyEmail_Call{Call: _e.mock.On("VerifyEmail", ctx, verificationToken)}
|
|
}
|
|
|
|
func (_c *Service_VerifyEmail_Call) Run(run func(ctx context.Context, verificationToken string)) *Service_VerifyEmail_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_VerifyEmail_Call) Return(user users.User, err error) *Service_VerifyEmail_Call {
|
|
_c.Call.Return(user, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_VerifyEmail_Call) RunAndReturn(run func(ctx context.Context, verificationToken string) (users.User, error)) *Service_VerifyEmail_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// View provides a mock function for the type Service
|
|
func (_mock *Service) View(ctx context.Context, session authn.Session, id string) (users.User, error) {
|
|
ret := _mock.Called(ctx, session, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for View")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) (users.User, error)); ok {
|
|
return returnFunc(ctx, session, id)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) users.User); ok {
|
|
r0 = returnFunc(ctx, session, id)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string) error); ok {
|
|
r1 = returnFunc(ctx, session, id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_View_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'View'
|
|
type Service_View_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// View is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
// - id string
|
|
func (_e *Service_Expecter) View(ctx interface{}, session interface{}, id interface{}) *Service_View_Call {
|
|
return &Service_View_Call{Call: _e.mock.On("View", ctx, session, id)}
|
|
}
|
|
|
|
func (_c *Service_View_Call) Run(run func(ctx context.Context, session authn.Session, id string)) *Service_View_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_View_Call) Return(user users.User, err error) *Service_View_Call {
|
|
_c.Call.Return(user, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_View_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string) (users.User, error)) *Service_View_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ViewProfile provides a mock function for the type Service
|
|
func (_mock *Service) ViewProfile(ctx context.Context, session authn.Session) (users.User, error) {
|
|
ret := _mock.Called(ctx, session)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ViewProfile")
|
|
}
|
|
|
|
var r0 users.User
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) (users.User, error)); ok {
|
|
return returnFunc(ctx, session)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) users.User); ok {
|
|
r0 = returnFunc(ctx, session)
|
|
} else {
|
|
r0 = ret.Get(0).(users.User)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session) error); ok {
|
|
r1 = returnFunc(ctx, session)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// Service_ViewProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ViewProfile'
|
|
type Service_ViewProfile_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ViewProfile is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - session authn.Session
|
|
func (_e *Service_Expecter) ViewProfile(ctx interface{}, session interface{}) *Service_ViewProfile_Call {
|
|
return &Service_ViewProfile_Call{Call: _e.mock.On("ViewProfile", ctx, session)}
|
|
}
|
|
|
|
func (_c *Service_ViewProfile_Call) Run(run func(ctx context.Context, session authn.Session)) *Service_ViewProfile_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 authn.Session
|
|
if args[1] != nil {
|
|
arg1 = args[1].(authn.Session)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_ViewProfile_Call) Return(user users.User, err error) *Service_ViewProfile_Call {
|
|
_c.Call.Return(user, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Service_ViewProfile_Call) RunAndReturn(run func(ctx context.Context, session authn.Session) (users.User, error)) *Service_ViewProfile_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|